KisToolLazyBrushOptionsWidget Class Reference

The KisToolLazyBrushOptionsWidget class. More...

#include <kis_tool_lazy_brush_options_widget.h>

Inheritance diagram for KisToolLazyBrushOptionsWidget:

Classes
struct	Private

Public Member Functions
	KisToolLazyBrushOptionsWidget (KisCanvasResourceProvider *provider, QWidget *parent)
	~KisToolLazyBrushOptionsWidget () override

Protected Member Functions
void	hideEvent (QHideEvent *event) override
void	showEvent (QShowEvent *event) override

Private Slots
void	entrySelected (QModelIndex index)
void	slotCleanUpChanged (int value)
void	slotColorLabelsChanged ()
void	slotCurrentFgColorChanged (const KoColor &color)
void	slotCurrentNodeChanged (KisNodeSP node)
void	slotEdgeDetectionSizeChanged (int value)
void	slotLimitToDeviceChanged (bool value)
void	slotMakeTransparent (bool value)
void	slotRadiusChanged (int value)
void	slotRemove ()
void	slotSetAutoUpdates (bool value)
void	slotSetShowKeyStrokes (bool value)
void	slotSetShowOutput (bool value)
void	slotUpdate ()
void	slotUpdateNodeProperties ()
void	slotUseEdgeDetectionChanged (bool value)

Private Attributes
	: static bool sortSwatchInfo(const KisSwatchGroup::SwatchInfo &first
	: friend struct PaletteEventFilter
const QScopedPointer< Private >	m_d
const KisSwatchGroup::SwatchInfo &	second

Detailed Description

The KisToolLazyBrushOptionsWidget class.

Definition at line 24 of file kis_tool_lazy_brush_options_widget.h.

Constructor & Destructor Documentation

KisToolLazyBrushOptionsWidget()

KisToolLazyBrushOptionsWidget::KisToolLazyBrushOptionsWidget	(	KisCanvasResourceProvider *	provider,
		QWidget *	parent )

Definition at line 83 of file kis_tool_lazy_brush_options_widget.cpp.

    : QWidget(parent),
      m_d(new Private)
{
    m_d->ui = new Ui_KisToolLazyBrushOptionsWidget();
    m_d->ui->setupUi(this);
 
    m_d->colorModel = new KisPaletteModel(this);
    m_d->ui->colorView->setPaletteModel(m_d->colorModel);
    m_d->ui->colorView->setAllowModification(false); //people probably shouldn't be able to edit the colorentries themselves.
    m_d->ui->colorView->setCrossedKeyword("transparent");
 
    PaletteEventFilter *filter = new PaletteEventFilter(m_d->ui->colorView, this);
    m_d->ui->colorView->viewport()->installEventFilter(filter);
 
    connect(m_d->ui->chkUseEdgeDetection, SIGNAL(toggled(bool)), SLOT(slotUseEdgeDetectionChanged(bool)));
    connect(m_d->ui->intEdgeDetectionSize, SIGNAL(valueChanged(int)), SLOT(slotEdgeDetectionSizeChanged(int)));
    connect(m_d->ui->intRadius, SIGNAL(valueChanged(int)), SLOT(slotRadiusChanged(int)));
    connect(m_d->ui->intCleanUp, SIGNAL(valueChanged(int)), SLOT(slotCleanUpChanged(int)));
    connect(m_d->ui->chkLimitToDevice, SIGNAL(toggled(bool)), SLOT(slotLimitToDeviceChanged(bool)));
 
    m_d->ui->intEdgeDetectionSize->setRange(0, 100);
    m_d->ui->intEdgeDetectionSize->setExponentRatio(2.0);
    m_d->ui->intEdgeDetectionSize->setSuffix(i18n(" px"));
    m_d->ui->intEdgeDetectionSize->setPrefix(i18n("Edge detection: "));
    m_d->ui->intEdgeDetectionSize->setToolTip(
        i18nc("@info:tooltip",
              "Activate for images with vast solid areas. "
              "Set the value to the width of the thinnest "
              "lines on the image"));
 
    m_d->ui->intRadius->setRange(0, 1000);
    m_d->ui->intRadius->setExponentRatio(3.0);
    m_d->ui->intRadius->setSuffix(i18n(" px"));
    m_d->ui->intRadius->setPrefix(i18n("Gap close hint: "));
    m_d->ui->intRadius->setToolTip(
        i18nc("@info:tooltip",
              "The mask will try to close non-closed contours "
              "if the gap is smaller than \"Gap close hint\" value"));
 
    m_d->ui->intCleanUp->setRange(0, 100);
    KisSpinBoxI18nHelper::setText(m_d->ui->intCleanUp,
                                  i18nc("{n} is the number value, % is the percent sign", "Clean up: {n}%"));
    m_d->ui->intCleanUp->setToolTip(
        i18nc("@info:tooltip",
              "The mask will try to remove parts of the key strokes "
              "that are placed outside the closed contours. 0% - no effect, 100% - max effect"));
 
 
    connect(m_d->ui->colorView, SIGNAL(sigIndexSelected(QModelIndex)), this, SLOT(entrySelected(QModelIndex)));
    connect(m_d->ui->btnTransparent, SIGNAL(toggled(bool)), this, SLOT(slotMakeTransparent(bool)));
    connect(m_d->ui->btnRemove, SIGNAL(clicked()), this, SLOT(slotRemove()));
 
    connect(m_d->ui->chkAutoUpdates, SIGNAL(toggled(bool)), m_d->ui->btnUpdate, SLOT(setDisabled(bool)));
 
    connect(m_d->ui->btnUpdate, SIGNAL(clicked()), this, SLOT(slotUpdate()));
    connect(m_d->ui->chkAutoUpdates, SIGNAL(toggled(bool)), this, SLOT(slotSetAutoUpdates(bool)));
    connect(m_d->ui->chkShowKeyStrokes, SIGNAL(toggled(bool)), this, SLOT(slotSetShowKeyStrokes(bool)));
    connect(m_d->ui->chkShowOutput, SIGNAL(toggled(bool)), this, SLOT(slotSetShowOutput(bool)));
 
    connect(&m_d->baseNodeChangedCompressor, SIGNAL(timeout()), this, SLOT(slotUpdateNodeProperties()));
 
    m_d->provider = provider;
 
    m_d->colorModel->setColorSet(m_d->colorSet);
 
    const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
 
    m_d->colorModel->addSwatch(KisSwatch(KoColor(Qt::red, cs), "color1"));
    m_d->colorModel->addSwatch(KisSwatch(KoColor(Qt::green, cs), "color2"));
    m_d->colorModel->addSwatch(KisSwatch(KoColor(Qt::blue, cs), "color3"));
}

References connect(), entrySelected(), KoColorSpaceRegistry::instance(), m_d, KoColorSpaceRegistry::rgb8(), KisSpinBoxI18nHelper::setText(), slotCleanUpChanged(), slotEdgeDetectionSizeChanged(), slotLimitToDeviceChanged(), slotMakeTransparent(), slotRadiusChanged(), slotRemove(), slotSetAutoUpdates(), slotSetShowKeyStrokes(), slotSetShowOutput(), slotUpdate(), slotUpdateNodeProperties(), and slotUseEdgeDetectionChanged().

~KisToolLazyBrushOptionsWidget()

KisToolLazyBrushOptionsWidget::~KisToolLazyBrushOptionsWidget ( )

override

Definition at line 156 of file kis_tool_lazy_brush_options_widget.cpp.

{
    delete m_d->ui;
    m_d->ui = nullptr;
}

References m_d.

Member Function Documentation

entrySelected

void KisToolLazyBrushOptionsWidget::entrySelected ( QModelIndex index )

privateslot

Definition at line 185 of file kis_tool_lazy_brush_options_widget.cpp.

{
    if (!index.isValid()) return;
    if (!qvariant_cast<bool>(index.data(KisPaletteModel::CheckSlotRole))) return;
 
    KisSwatch entry = m_d->colorModel->getSwatch(index);
    m_d->provider->setFGColor(entry.color());
 
    int idxInList = m_d->activeMask->keyStrokesColors().colors.indexOf(entry.color());
 
    if (idxInList != -1) {
        const bool transparentChecked = idxInList == m_d->transparentColorIndex;
        KisSignalsBlocker b(m_d->ui->btnTransparent);
        m_d->ui->btnTransparent->setChecked(transparentChecked);
    }
}

References KisPaletteModel::CheckSlotRole, KisSwatch::color(), and m_d.

hideEvent()

void KisToolLazyBrushOptionsWidget::hideEvent ( QHideEvent * event )

overrideprotected

Definition at line 178 of file kis_tool_lazy_brush_options_widget.cpp.

{
    QWidget::hideEvent(event);
 
    m_d->providerSignals.clear();
}

References m_d.

showEvent()

void KisToolLazyBrushOptionsWidget::showEvent ( QShowEvent * event )

overrideprotected

Definition at line 162 of file kis_tool_lazy_brush_options_widget.cpp.

{
    QWidget::showEvent(event);
 
    m_d->providerSignals.addConnection(
        m_d->provider, SIGNAL(sigNodeChanged(KisNodeSP)),
        this, SLOT(slotCurrentNodeChanged(KisNodeSP)));
 
    m_d->providerSignals.addConnection(
        m_d->provider, SIGNAL(sigFGColorChanged(KoColor)),
        this, SLOT(slotCurrentFgColorChanged(KoColor)));
 
    slotCurrentNodeChanged(m_d->provider->currentNode());
    slotCurrentFgColorChanged(m_d->provider->fgColor());
}

References m_d, slotCurrentFgColorChanged(), and slotCurrentNodeChanged().

slotCleanUpChanged

void KisToolLazyBrushOptionsWidget::slotCleanUpChanged ( int value )

privateslot

Definition at line 399 of file kis_tool_lazy_brush_options_widget.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
    m_d->activeMask->setCleanUpAmount(qreal(value) / 100.0);
}

References KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, and value().

slotColorLabelsChanged

void KisToolLazyBrushOptionsWidget::slotColorLabelsChanged ( )

privateslot

Definition at line 230 of file kis_tool_lazy_brush_options_widget.cpp.

{
    m_d->colorModel->clear(m_d->preferredColumnCount);
    m_d->transparentColorIndex = -1;
 
    if (m_d->activeMask) {
        KisColorizeMask::KeyStrokeColors colors = m_d->activeMask->keyStrokesColors();
        m_d->transparentColorIndex = colors.transparentIndex;
 
        for (int i = 0; i < colors.colors.size(); i++) {
            const QString name = i == m_d->transparentColorIndex ? "transparent" : "";
            m_d->colorModel->addSwatch(KisSwatch(colors.colors[i], name));
        }
    }
 
    slotCurrentFgColorChanged(m_d->provider->fgColor());
}

References KisColorizeMask::KeyStrokeColors::colors, m_d, slotCurrentFgColorChanged(), and KisColorizeMask::KeyStrokeColors::transparentIndex.

slotCurrentFgColorChanged

void KisToolLazyBrushOptionsWidget::slotCurrentFgColorChanged ( const KoColor & color )

privateslot

Definition at line 202 of file kis_tool_lazy_brush_options_widget.cpp.

{
    bool found = false;
 
    QModelIndex candidateIdx = m_d->colorModel->indexForClosest(color);
    if (m_d->colorModel->getSwatch(candidateIdx).color() == color) {
        found = true;
    }
 
    m_d->ui->btnRemove->setEnabled(found);
    m_d->ui->btnTransparent->setEnabled(found);
 
    if (!found) {
        KisSignalsBlocker b(m_d->ui->btnTransparent);
        m_d->ui->btnTransparent->setChecked(false);
    }
 
    QModelIndex newIndex = found ? candidateIdx : QModelIndex();
 
    if (!found) {
        m_d->ui->colorView->selectionModel()->clear();
    }
    if (newIndex.isValid() && newIndex != m_d->ui->colorView->currentIndex()) {
        m_d->ui->colorView->setCurrentIndex(newIndex);
        m_d->ui->colorView->update(newIndex);
    }
}

References m_d.

slotCurrentNodeChanged

void KisToolLazyBrushOptionsWidget::slotCurrentNodeChanged ( KisNodeSP node )

privateslot

Definition at line 292 of file kis_tool_lazy_brush_options_widget.cpp.

{
    m_d->maskSignals.clear();
 
    KisColorizeMask *mask = dynamic_cast<KisColorizeMask*>(node.data());
    m_d->activeMask = mask;
 
    if (m_d->activeMask) {
        m_d->maskSignals.addConnection(
            m_d->activeMask, SIGNAL(sigKeyStrokesListChanged()),
            this, SLOT(slotColorLabelsChanged()));
 
        m_d->maskSignals.addConnection(
            m_d->provider->currentImage(), SIGNAL(sigNodeChanged(KisNodeSP)),
            this, SLOT(slotUpdateNodeProperties()));
    }
 
    slotColorLabelsChanged();
    slotUpdateNodeProperties();
    m_d->ui->colorView->setEnabled(m_d->activeMask);
}

References KisSharedPtr< T >::data(), m_d, slotColorLabelsChanged(), and slotUpdateNodeProperties().

slotEdgeDetectionSizeChanged

void KisToolLazyBrushOptionsWidget::slotEdgeDetectionSizeChanged ( int value )

privateslot

Definition at line 387 of file kis_tool_lazy_brush_options_widget.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
    m_d->activeMask->setEdgeDetectionSize(value);
}

References KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, and value().

slotLimitToDeviceChanged

void KisToolLazyBrushOptionsWidget::slotLimitToDeviceChanged ( bool value )

privateslot

Definition at line 405 of file kis_tool_lazy_brush_options_widget.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
    m_d->activeMask->setLimitToDeviceBounds(value);
}

References KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, and value().

slotMakeTransparent

void KisToolLazyBrushOptionsWidget::slotMakeTransparent ( bool value )

privateslot

Definition at line 314 of file kis_tool_lazy_brush_options_widget.cpp.

{
    KIS_ASSERT_RECOVER_RETURN(m_d->activeMask);
 
    QModelIndex index = m_d->ui->colorView->currentIndex();
    KisSwatch activeSwatch = m_d->colorModel->getSwatch(index);
    if (!index.isValid()) return;
 
    QVector<KisSwatchGroup::SwatchInfo> infoList;
    Q_FOREACH (const QString &groupName, m_d->colorSet->swatchGroupNames()) {
        KisSwatchGroupSP group = m_d->colorSet->getGroup(groupName);
        Q_FOREACH (const KisSwatchGroup::SwatchInfo &info, group->infoList()) {
            infoList.append(info);
        }
    }
 
    // We can't rely on the order of the colors returned, so we need to sort them row by row from left to right
    std::sort(infoList.begin(), infoList.end(), sortSwatchInfo);
    KisColorizeMask::KeyStrokeColors colors;
    int i = 0;
    for (const KisSwatchGroup::SwatchInfo &info : infoList) {
        if (activeSwatch == info.swatch && enableTransparency) {
            colors.transparentIndex = i;
        }
        colors.colors << info.swatch.color();
        i++;
    }
 
    m_d->activeMask->setKeyStrokesColors(colors);
}

References KisColorizeMask::KeyStrokeColors::colors, KIS_ASSERT_RECOVER_RETURN, m_d, and KisColorizeMask::KeyStrokeColors::transparentIndex.

slotRadiusChanged

void KisToolLazyBrushOptionsWidget::slotRadiusChanged ( int value )

privateslot

Definition at line 393 of file kis_tool_lazy_brush_options_widget.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
    m_d->activeMask->setFuzzyRadius(0.5 * value);
}

References KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, and value().

slotRemove

void KisToolLazyBrushOptionsWidget::slotRemove ( )

privateslot

Definition at line 345 of file kis_tool_lazy_brush_options_widget.cpp.

{
    KIS_ASSERT_RECOVER_RETURN(m_d->activeMask);
 
    QModelIndex index = m_d->ui->colorView->currentIndex();
    if (!index.isValid()) return;
 
    const KoColor color = m_d->colorModel->getSwatch(index).color();
    m_d->activeMask->removeKeyStroke(color);
}

References KIS_ASSERT_RECOVER_RETURN, and m_d.

slotSetAutoUpdates

void KisToolLazyBrushOptionsWidget::slotSetAutoUpdates ( bool value )

privateslot

Definition at line 362 of file kis_tool_lazy_brush_options_widget.cpp.

{
    // not implemented yet!
    ENTER_FUNCTION() << ppVar(value);
}

References ENTER_FUNCTION, ppVar, and value().

slotSetShowKeyStrokes

void KisToolLazyBrushOptionsWidget::slotSetShowKeyStrokes ( bool value )

privateslot

Definition at line 368 of file kis_tool_lazy_brush_options_widget.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
    KisLayerPropertiesIcons::setNodePropertyAutoUndo(m_d->activeMask, KisLayerPropertiesIcons::colorizeEditKeyStrokes, value, m_d->provider->currentImage());
}

References KisLayerPropertiesIcons::colorizeEditKeyStrokes, KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, KisLayerPropertiesIcons::setNodePropertyAutoUndo(), and value().

slotSetShowOutput

void KisToolLazyBrushOptionsWidget::slotSetShowOutput ( bool value )

privateslot

Definition at line 374 of file kis_tool_lazy_brush_options_widget.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
    KisLayerPropertiesIcons::setNodePropertyAutoUndo(m_d->activeMask, KisLayerPropertiesIcons::colorizeShowColoring, value, m_d->provider->currentImage());
}

References KisLayerPropertiesIcons::colorizeShowColoring, KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, KisLayerPropertiesIcons::setNodePropertyAutoUndo(), and value().

slotUpdate

void KisToolLazyBrushOptionsWidget::slotUpdate ( )

privateslot

Definition at line 356 of file kis_tool_lazy_brush_options_widget.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
    KisLayerPropertiesIcons::setNodePropertyAutoUndo(m_d->activeMask, KisLayerPropertiesIcons::colorizeNeedsUpdate, false, m_d->provider->currentImage());
}

References KisLayerPropertiesIcons::colorizeNeedsUpdate, KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, and KisLayerPropertiesIcons::setNodePropertyAutoUndo().

slotUpdateNodeProperties

void KisToolLazyBrushOptionsWidget::slotUpdateNodeProperties ( )

privateslot

Definition at line 248 of file kis_tool_lazy_brush_options_widget.cpp.

{
    KisSignalsBlocker b1(m_d->ui->chkAutoUpdates,
                         m_d->ui->btnUpdate,
                         m_d->ui->chkShowKeyStrokes,
                         m_d->ui->chkShowOutput);
    KisSignalsBlocker b2(m_d->ui->chkUseEdgeDetection,
                         m_d->ui->intEdgeDetectionSize,
                         m_d->ui->intRadius,
                         m_d->ui->intCleanUp,
                         m_d->ui->chkLimitToDevice);
 
    // not implemented yet!
    //m_d->ui->chkAutoUpdates->setEnabled(m_d->activeMask);
    m_d->ui->chkAutoUpdates->setEnabled(false);
    m_d->ui->chkAutoUpdates->setVisible(false);
 
    bool value = false;
 
    value = m_d->activeMask && KisLayerPropertiesIcons::nodeProperty(m_d->activeMask, KisLayerPropertiesIcons::colorizeNeedsUpdate, true).toBool();
    m_d->ui->btnUpdate->setEnabled(m_d->activeMask && !m_d->ui->chkAutoUpdates->isChecked() && value);
 
    value = m_d->activeMask && KisLayerPropertiesIcons::nodeProperty(m_d->activeMask, KisLayerPropertiesIcons::colorizeEditKeyStrokes, true).toBool();
    m_d->ui->chkShowKeyStrokes->setEnabled(m_d->activeMask);
    m_d->ui->chkShowKeyStrokes->setChecked(value);
 
    value = m_d->activeMask && KisLayerPropertiesIcons::nodeProperty(m_d->activeMask, KisLayerPropertiesIcons::colorizeShowColoring, true).toBool();
    m_d->ui->chkShowOutput->setEnabled(m_d->activeMask);
    m_d->ui->chkShowOutput->setChecked(value);
 
    m_d->ui->chkUseEdgeDetection->setEnabled(m_d->activeMask);
    m_d->ui->chkUseEdgeDetection->setChecked(m_d->activeMask && m_d->activeMask->useEdgeDetection());
 
    m_d->ui->intEdgeDetectionSize->setEnabled(m_d->activeMask && m_d->ui->chkUseEdgeDetection->isChecked());
    m_d->ui->intEdgeDetectionSize->setValue(m_d->activeMask ? m_d->activeMask->edgeDetectionSize() : 4.0);
    m_d->ui->intRadius->setEnabled(m_d->activeMask);
    m_d->ui->intRadius->setValue(2 * (m_d->activeMask ? m_d->activeMask->fuzzyRadius() : 15));
    m_d->ui->intCleanUp->setEnabled(m_d->activeMask);
    m_d->ui->intCleanUp->setValue(100 * (m_d->activeMask ? m_d->activeMask->cleanUpAmount() : 0.7));
 
    m_d->ui->chkLimitToDevice->setEnabled(m_d->activeMask);
    m_d->ui->chkLimitToDevice->setChecked(m_d->activeMask && m_d->activeMask->limitToDeviceBounds());
}

References KisLayerPropertiesIcons::colorizeEditKeyStrokes, KisLayerPropertiesIcons::colorizeNeedsUpdate, KisLayerPropertiesIcons::colorizeShowColoring, m_d, KisLayerPropertiesIcons::nodeProperty(), and value().

slotUseEdgeDetectionChanged

void KisToolLazyBrushOptionsWidget::slotUseEdgeDetectionChanged ( bool value )

privateslot

Definition at line 380 of file kis_tool_lazy_brush_options_widget.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
    m_d->activeMask->setUseEdgeDetection(value);
    m_d->ui->intEdgeDetectionSize->setEnabled(value);
}

References KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, and value().

Member Data Documentation

__pad0__

KisToolLazyBrushOptionsWidget::__pad0__

private

Definition at line 56 of file kis_tool_lazy_brush_options_widget.h.

__pad1__

KisToolLazyBrushOptionsWidget::__pad1__

private

Definition at line 59 of file kis_tool_lazy_brush_options_widget.h.

m_d

const QScopedPointer<Private> KisToolLazyBrushOptionsWidget::m_d

private

Definition at line 65 of file kis_tool_lazy_brush_options_widget.h.

second

const KisSwatchGroup::SwatchInfo& KisToolLazyBrushOptionsWidget::second

private

Definition at line 59 of file kis_tool_lazy_brush_options_widget.h.

---

The documentation for this class was generated from the following files:

• plugins/tools/tool_lazybrush/kis_tool_lazy_brush_options_widget.h
• plugins/tools/tool_lazybrush/kis_tool_lazy_brush_options_widget.cpp