#include <kis_paintop_box.h>

Inheritance diagram for KisPaintopBox:

Classes
struct	TabletToolData

struct	TabletToolID

Public Slots
void	resourceSelected (KoResourceSP resource)

void	slotCanvasResourceChangeAttempted (int key, const QVariant &value)

void	slotCanvasResourceChanged (int key, const QVariant &v)

void	slotColorSpaceChanged (const KoColorSpace *colorSpace)

void	slotCreatePresetFromScratch (QString paintop)

void	slotInputDeviceChanged (const KoInputDevice &inputDevice)

void	slotSelectBrushPreset ()

void	slotSelectEraserPreset ()

void	slotToggleEraserPreset (bool usingEraser)

Public Member Functions
KisFavoriteResourceManager *	favoriteResourcesManager ()

	KisPaintopBox (KisViewManager view, QWidget parent, const char *name)

void	newOptionWidgets (const QList< QPointer< QWidget > > &optionWidgetList)

void	restoreResource (KoResourceSP resource)

	~KisPaintopBox () override

Private Types
enum	{ ENABLE_PRESETS = 0x0001 , DISABLE_PRESETS = 0x0002 , ENABLE_COMPOSITEOP = 0x0004 , DISABLE_COMPOSITEOP = 0x0008 , ENABLE_OPACITY = 0x0010 , DISABLE_OPACITY = 0x0020 , ENABLE_FLOW = 0x0040 , DISABLE_FLOW = 0x0080 , ENABLE_SIZE = 0x0100 , DISABLE_SIZE = 0x0200 , ENABLE_PATTERNSIZE = 0x0400 , DISABLE_PATTERNSIZE = 0x0800 , ENABLE_ALL = 0x5555 , DISABLE_ALL = 0xAAAA }

typedef QMap< KoID, KisPaintOpPresetSP >	PaintOpPresetMap

typedef QMap< TabletToolID, TabletToolData >	TabletToolMap

Private Slots
void	slotDirtyPresetToggled (bool)

void	slotDisablePressureMode (bool)

void	slotDropLockedOption (KisPropertiesConfigurationSP p)

void	slotEraserBrushOpacityToggled (bool)

void	slotEraserBrushSizeToggled (bool)

void	slotGuiChangedCurrentPreset ()

void	slotHideDecorationMirrorX (bool)

void	slotHideDecorationMirrorY (bool)

void	slotHorizontalMirrorChanged (bool value)

void	slotLockXMirrorToggle (bool)

void	slotLockYMirrorToggle (bool)

void	slotMoveToCenterMirrorX ()

void	slotMoveToCenterMirrorY ()

void	slotNextFavoritePreset ()

void	slotNodeChanged (const KisNodeSP node)

void	slotPreviousFavoritePreset ()

void	slotReloadPreset ()

void	slotSaveLockedOptionToPreset (KisPropertiesConfigurationSP p)

void	slotSetCompositeMode (int index)

void	slotSetPaintop (const QString &paintOpId)

void	slotSetupDefaultPreset ()

void	slotSlider1Changed ()

void	slotSlider2Changed ()

void	slotSlider3Changed ()

void	slotSlider4Changed ()

void	slotSlider5Changed ()

void	slotSwitchToPreviousPreset ()

void	slotToggleAlphaLockMode (bool)

void	slotToggleEraseMode (bool checked)

void	slotToolChanged (KoCanvasController *canvas)

void	slotUnsetEraseMode ()

void	slotUpdateOptionsWidgetPopup ()

void	slotUpdateSelectionIcon ()

void	slotVerticalMirrorChanged (bool value)

void	togglePresetEditor ()

void	updatePresetConfig ()

Private Member Functions
KisPaintOpPresetSP	activePreset (const KoID &paintOp)

KisPaintOpPresetSP	defaultPreset (const KoID &paintOp)

void	findDefaultPresets ()

void	setAngleSliderValue (const QString &sliderID, qreal value)

void	setCurrentPaintop (const KoID &paintop)

void	setCurrentPaintop (KisPaintOpPresetSP preset)

void	setMultiplierSliderValue (const QString &sliderID, qreal value)

void	setSliderValue (const QString &sliderID, qreal value)

void	setWidgetState (int flags)

void	sliderChanged (int n)

void	updateCompositeOp (QString compositeOpID)

Private Attributes
KisAction *	hideCanvasDecorationsX {0}

KisAction *	hideCanvasDecorationsY {0}

KisAction *	lockActionX {0}

KisAction *	lockActionY {0}

QToolButton *	m_alphaLockButton {0}

bool	m_blockUpdate {false}

KisIconWidget *	m_brushEditorPopupButton {0}

KisAction *	m_brushSelectPresetAction {0}

KisCompositeOpComboBox *	m_cmbCompositeOp {0}

QString	m_currCompositeOpID

KisNodeWSP	m_currentNode

TabletToolID	m_currTabletToolID {KoInputDevice::invalid()}

QString	m_defaultPresetName

bool	m_dirtyPresetsEnabled {false}

KisAction *	m_disablePressureAction {0}

KisAction *	m_eraseAction {0}

QToolButton *	m_eraseModeButton {0}

bool	m_eraserBrushOpacityEnabled {false}

bool	m_eraserBrushSizeEnabled {false}

QString	m_eraserName

KisAction *	m_eraserSelectPresetAction {0}

KisAction *	m_eraserTogglePresetAction {0}

KisFavoriteResourceManager *	m_favoriteResourceManager {0}

KisAction *	m_hMirrorAction {0}

QToolButton *	m_hMirrorButton {0}

QHBoxLayout *	m_layout {0}

QScopedPointer< KisAcyclicSignalConnector >	m_optionsWidgetConnections

KisPaintOpConfigWidget *	m_optionWidget {0}

KisSignalCompressor	m_optionWidgetUpdateCompressor

QMap< KoID, KisPaintOpConfigWidget * >	m_paintopOptionWidgets

PaintOpPresetMap	m_paintOpPresetMap

QWidget *	m_paintopWidget {0}

KisSignalAutoConnectionsStore	m_presetConnections

KisPaintOpPresetsChooserPopup *	m_presetsChooserPopup {0}

KisPaintOpPresetsEditor *	m_presetsEditor {0}

KisIconWidget *	m_presetSelectorPopupButton {0}

bool	m_presetsEnabled {true}

KisAction *	m_reloadAction {0}

QToolButton *	m_reloadButton {0}

KisCanvasResourceProvider *	m_resourceProvider {0}

KisPresetSaveWidget *	m_savePresetWidget {0}

KisWidgetChooser *	m_sliderChooser [5]

TabletToolMap	m_tabletToolMap

KisToolOptionsPopup *	m_toolOptionsPopup {0}

KisPopupButton *	m_toolOptionsPopupButton {0}

KisViewManager *	m_viewManager {0}

KisAction *	m_vMirrorAction {0}

QToolButton *	m_vMirrorButton {0}

KisPopupButton *	m_workspaceWidget {0}

QToolButton *	m_wrapAroundButton {0}

KisAction *	moveToCenterActionX {0}

KisAction *	moveToCenterActionY {0}

QMenu *	toolbarMenuXMirror {nullptr}

QMenu *	toolbarMenuYMirror {nullptr}

Detailed Description

This widget presents all paintops that a user can paint with. Paintops represent real-world tools or the well-known Shop computer equivalents that do nothing but change color.

To incorporate the dirty preset functionality and locked settings the following slots are added void slotReloadPreset(); void slotGuiChangedCurrentPreset(); void slotSaveLockedOptionToPreset(KisPropertiesConfigurationSP p); void slotDropLockedOption(KisPropertiesConfigurationSP p); void slotDirtyPresetToggled(bool); Every time a value is changed in a preset, the preset is made dirty through the onChange() function. For Locked Settings however, a changed Locked Setting will not cause a preset to become dirty. That is because it borrows its values from the KisLockedPropertiesServer. Hence the dirty state of the Preset is kept consistent before and after a writeConfiguration operation in most cases. XXX: When we have a lot of paintops, replace the listbox with a table, and for every category a combobox.

XXX: instead of text, use pretty pictures.

Definition at line 74 of file kis_paintop_box.h.

Member Typedef Documentation

◆ PaintOpPresetMap

typedef QMap<KoID, KisPaintOpPresetSP> KisPaintopBox::PaintOpPresetMap

private

Definition at line 259 of file kis_paintop_box.h.

◆ TabletToolMap

typedef QMap<TabletToolID, TabletToolData> KisPaintopBox::TabletToolMap

private

Definition at line 258 of file kis_paintop_box.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

private

Enumerator
ENABLE_PRESETS
DISABLE_PRESETS
ENABLE_COMPOSITEOP
DISABLE_COMPOSITEOP
ENABLE_OPACITY
DISABLE_OPACITY
ENABLE_FLOW
DISABLE_FLOW
ENABLE_SIZE
DISABLE_SIZE
ENABLE_PATTERNSIZE
DISABLE_PATTERNSIZE
ENABLE_ALL
DISABLE_ALL

Definition at line 78 of file kis_paintop_box.h.

         {
        ENABLE_PRESETS      = 0x0001,
        DISABLE_PRESETS     = 0x0002,
        ENABLE_COMPOSITEOP  = 0x0004,
        DISABLE_COMPOSITEOP = 0x0008,
        ENABLE_OPACITY      = 0x0010,
        DISABLE_OPACITY     = 0x0020,
        ENABLE_FLOW         = 0x0040,
        DISABLE_FLOW        = 0x0080,
        ENABLE_SIZE         = 0x0100,
        DISABLE_SIZE        = 0x0200,
        ENABLE_PATTERNSIZE  = 0x0400,
        DISABLE_PATTERNSIZE = 0x0800,
        ENABLE_ALL          = 0x5555,
        DISABLE_ALL         = 0xAAAA
    };

Constructor & Destructor Documentation

◆ KisPaintopBox()

KisPaintopBox::KisPaintopBox	(	KisViewManager *	view,
		QWidget *	parent,
		const char *	name )

Definition at line 84 of file kis_paintop_box.cc.

    : QWidget(parent)
    , m_resourceProvider(viewManager->canvasResourceProvider())
    , m_viewManager(viewManager)
    , m_optionWidgetUpdateCompressor(100, KisSignalCompressor::FIRST_ACTIVE)
{
    Q_ASSERT(viewManager != 0);
 
    setObjectName(name);
    KisConfig cfg(true);
    m_dirtyPresetsEnabled = cfg.useDirtyPresets();
    m_eraserBrushSizeEnabled = cfg.useEraserBrushSize();
    m_eraserBrushOpacityEnabled = cfg.useEraserBrushOpacity();
 
    KAcceleratorManager::setNoAccel(this);
 
    setWindowTitle(i18n("Painter's Toolchest"));
 
    m_favoriteResourceManager = new KisFavoriteResourceManager(this);
 
    KConfigGroup grp =  KSharedConfig::openConfig()->group("krita").group("Toolbar BrushesAndStuff");
    int iconsize = grp.readEntry("IconSize", 22);
    // NOTE: buttonsize should be the same value as the one used in ktoolbar for all QToolButton
    int buttonsize = grp.readEntry("ButtonSize", 32);
 
    if (!cfg.toolOptionsInDocker()) {
        m_toolOptionsPopupButton = new KisPopupButton(this);
        m_toolOptionsPopupButton->setIcon(KisIconUtils::loadIcon("view-choose"));
        m_toolOptionsPopupButton->setToolTip(i18n("Tool Settings"));
        m_toolOptionsPopupButton->setFixedSize(buttonsize, buttonsize);
        m_toolOptionsPopupButton->setIconSize(QSize(iconsize, iconsize));
        m_toolOptionsPopupButton->setAutoRaise(true);
    }
 
    m_brushEditorPopupButton = new KisIconWidget(this);
    m_brushEditorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_02"));
    m_brushEditorPopupButton->setToolTip(i18n("Edit brush settings"));
    m_brushEditorPopupButton->setFixedSize(buttonsize, buttonsize);
    m_brushEditorPopupButton->setIconSize(QSize(iconsize, iconsize));
    m_brushEditorPopupButton->setAutoRaise(true);
 
    m_presetSelectorPopupButton = new KisIconWidget(this);
    m_presetSelectorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_01"));
    m_presetSelectorPopupButton->setToolTip(i18n("Choose brush preset"));
    m_presetSelectorPopupButton->setFixedSize(buttonsize, buttonsize);
    m_presetSelectorPopupButton->setIconSize(QSize(iconsize, iconsize));
    m_presetSelectorPopupButton->setAutoRaise(true);
    m_presetSelectorPopupButton->setArrowVisible(false);
 
    m_eraseModeButton = new KisHighlightedToolButton(this);
    m_eraseModeButton->setFixedSize(buttonsize, buttonsize);
    m_eraseModeButton->setIconSize(QSize(iconsize, iconsize));
    m_eraseModeButton->setCheckable(true);
    m_eraseModeButton->setAutoRaise(true);
 
 
    m_eraseAction = m_viewManager->actionManager()->createAction("erase_action");
    m_eraseModeButton->setDefaultAction(m_eraseAction);
 
    // toggling eraser preset
    m_eraserTogglePresetAction = m_viewManager->actionManager()->createAction("eraser_preset_action");
 
    // explicitly select eraser or brush preset
    m_eraserSelectPresetAction = m_viewManager->actionManager()->createAction("eraser_select_preset_action");
    m_brushSelectPresetAction = m_viewManager->actionManager()->createAction("brush_select_preset_action");
 
    m_reloadButton = new QToolButton(this);
    m_reloadButton->setFixedSize(buttonsize, buttonsize);
    m_reloadButton->setIconSize(QSize(iconsize, iconsize));
    m_reloadButton->setAutoRaise(true); // make button flat
 
 
    m_reloadAction = m_viewManager->actionManager()->createAction("reload_preset_action");
    m_reloadButton->setDefaultAction(m_reloadAction);
 
    m_alphaLockButton = new KisHighlightedToolButton(this);
    m_alphaLockButton->setFixedSize(buttonsize, buttonsize);
    m_alphaLockButton->setIconSize(QSize(iconsize, iconsize));
    m_alphaLockButton->setCheckable(true);
    m_alphaLockButton->setAutoRaise(true);
 
    KisAction* alphaLockAction = m_viewManager->actionManager()->createAction("preserve_alpha");
    m_alphaLockButton->setDefaultAction(alphaLockAction);
 
    // horizontal and vertical mirror toolbar buttons
 
    // mirror tool options for the X Mirror
    toolbarMenuXMirror = new QMenu();
 
    hideCanvasDecorationsX = m_viewManager->actionManager()->createAction("mirrorX-hideDecorations");
    toolbarMenuXMirror->addAction(hideCanvasDecorationsX);
 
    lockActionX = m_viewManager->actionManager()->createAction("mirrorX-lock");
    toolbarMenuXMirror->addAction(lockActionX);
 
    moveToCenterActionX = m_viewManager->actionManager()->createAction("mirrorX-moveToCenter");
    toolbarMenuXMirror->addAction(moveToCenterActionX);
 
 
    // mirror tool options for the Y Mirror
    toolbarMenuYMirror = new QMenu();
 
    hideCanvasDecorationsY = m_viewManager->actionManager()->createAction("mirrorY-hideDecorations");
    toolbarMenuYMirror->addAction(hideCanvasDecorationsY);
 
 
    lockActionY = m_viewManager->actionManager()->createAction("mirrorY-lock");
    toolbarMenuYMirror->addAction(lockActionY);
 
    moveToCenterActionY = m_viewManager->actionManager()->createAction("mirrorY-moveToCenter");
    toolbarMenuYMirror->addAction(moveToCenterActionY);
 
    // create horizontal and vertical mirror buttons
 
    m_hMirrorButton = new KisHighlightedToolButton(this);
    int menuPadding = 20;
    m_hMirrorButton->setFixedSize(buttonsize + menuPadding, buttonsize);
    m_hMirrorButton->setIconSize(QSize(iconsize, iconsize));
    m_hMirrorButton->setCheckable(true);
    m_hMirrorAction = m_viewManager->actionManager()->createAction("hmirror_action");
    m_hMirrorButton->setDefaultAction(m_hMirrorAction);
    m_hMirrorButton->setMenu(toolbarMenuXMirror);
    m_hMirrorButton->setPopupMode(QToolButton::MenuButtonPopup);
    m_hMirrorButton->setAutoRaise(true);
 
    m_vMirrorButton = new KisHighlightedToolButton(this);
    m_vMirrorButton->setFixedSize(buttonsize + menuPadding, buttonsize);
    m_vMirrorButton->setIconSize(QSize(iconsize, iconsize));
    m_vMirrorButton->setCheckable(true);
    m_vMirrorAction = m_viewManager->actionManager()->createAction("vmirror_action");
    m_vMirrorButton->setDefaultAction(m_vMirrorAction);
    m_vMirrorButton->setMenu(toolbarMenuYMirror);
    m_vMirrorButton->setPopupMode(QToolButton::MenuButtonPopup);
    m_vMirrorButton->setAutoRaise(true);
 
    QAction *wrapAroundAction = m_viewManager->actionManager()->createAction("wrap_around_mode");
 
    m_wrapAroundButton = new KisHighlightedToolButton(this);
    m_wrapAroundButton->setFixedSize(buttonsize, buttonsize);
    m_wrapAroundButton->setIconSize(QSize(iconsize, iconsize));
    m_wrapAroundButton->setDefaultAction(wrapAroundAction);
    m_wrapAroundButton->setCheckable(true);
    m_wrapAroundButton->setAutoRaise(true);
 
    // add connections for horizontal and mirror buttons
    connect(lockActionX, SIGNAL(toggled(bool)), this, SLOT(slotLockXMirrorToggle(bool)));
    connect(lockActionY, SIGNAL(toggled(bool)), this, SLOT(slotLockYMirrorToggle(bool)));
 
    connect(moveToCenterActionX, SIGNAL(triggered(bool)), this, SLOT(slotMoveToCenterMirrorX()));
    connect(moveToCenterActionY, SIGNAL(triggered(bool)), this, SLOT(slotMoveToCenterMirrorY()));
 
    connect(hideCanvasDecorationsX, SIGNAL(toggled(bool)), this, SLOT(slotHideDecorationMirrorX(bool)));
    connect(hideCanvasDecorationsY, SIGNAL(toggled(bool)), this, SLOT(slotHideDecorationMirrorY(bool)));
 
    const bool sliderLabels = cfg.sliderLabels();
    int sliderWidth;
 
    if (sliderLabels) {
        sliderWidth = 150 * logicalDpiX() / 96;
    }
    else {
        sliderWidth = 120 * logicalDpiX() / 96;
    }
 
    for (int i = 0; i < 5; ++i) {
        m_sliderChooser[i] = new KisWidgetChooser(i + 1);
 
        KisDoubleSliderSpinBox* slOpacity;
        KisDoubleSliderSpinBox* slFlow;
        KisDoubleSliderSpinBox* slSize;
        KisAngleSelector* slRotation;
        KisMultipliersDoubleSliderSpinBox* slPatternSize;
 
        if (sliderLabels) {
            slOpacity     = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("opacity");
            slFlow        = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("flow");
            slSize        = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("size");
            slRotation    = m_sliderChooser[i]->addWidget<KisAngleSelector>("rotation");
            slPatternSize = m_sliderChooser[i]->addWidget<KisMultipliersDoubleSliderSpinBox>("patternsize");
 
            KisSpinBoxI18nHelper::setText(slOpacity,
                                          i18nc("{n} is the number value, % is the percent sign", "Opacity: {n}%"));
            KisSpinBoxI18nHelper::setText(slFlow,
                                          i18nc("{n} is the number value, % is the percent sign", "Flow: {n}%"));
            slSize->setPrefix(QString("%1 ").arg(i18n("Size:")));
            slRotation->setPrefix(QString("%1 ").arg(i18n("Rotation:")));
            slPatternSize->setPrefix(QString("%1 ").arg(i18n("Pattern Scale:")));
        }
        else {
            slOpacity     = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("opacity", i18n("Opacity:"));
            slFlow        = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("flow", i18n("Flow:"));
            slSize        = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("size", i18n("Size:"));
            slRotation    = m_sliderChooser[i]->addWidget<KisAngleSelector>("rotation", i18n("Rotation:"));
            slPatternSize = m_sliderChooser[i]->addWidget<KisMultipliersDoubleSliderSpinBox>("patternsize", i18n("Pattern Scale:"));
 
            KisSpinBoxI18nHelper::setText(slOpacity, i18nc("{n} is the number value, % is the percent sign", "{n}%"));
            KisSpinBoxI18nHelper::setText(slFlow, i18nc("{n} is the number value, % is the percent sign", "{n}%"));
        }
 
        slOpacity->setRange(0, 100, 0);
        slOpacity->setValue(100);
        slOpacity->setSingleStep(5);
        slOpacity->setMinimumWidth(qMax(sliderWidth, slOpacity->sizeHint().width()));
        slOpacity->setFixedHeight(buttonsize);
        slOpacity->setBlockUpdateSignalOnDrag(true);
 
        slFlow->setRange(0, 100, 0);
        slFlow->setValue(100);
        slFlow->setSingleStep(5);
        slFlow->setMinimumWidth(qMax(sliderWidth, slFlow->sizeHint().width()));
        slFlow->setFixedHeight(buttonsize);
        slFlow->setBlockUpdateSignalOnDrag(true);
 
        slSize->setRange(0.01, KisImageConfig(true).maxBrushSize(), 2);
        slSize->setValue(100);
 
        slSize->setSingleStep(1);
        slSize->setExponentRatio(3.0);
        slSize->setSuffix(i18n(" px"));
        slSize->setMinimumWidth(qMax(sliderWidth, slSize->sizeHint().width()));
        slSize->setFixedHeight(buttonsize);
        slSize->setBlockUpdateSignalOnDrag(true);
 
        slRotation->setFlipOptionsMode(KisAngleSelector::FlipOptionsMode_MenuButton);
        slRotation->setRange(-360.0, 360.0);
        slRotation->setMinimumWidth(qMax(sliderWidth, slRotation->sizeHint().width()));
        slRotation->setWidgetsHeight(buttonsize);
 
        slPatternSize->setRange(0.0, 2.0, 2);
        slPatternSize->setValue(1.0);
        slPatternSize->addMultiplier(0.1);
        slPatternSize->addMultiplier(2);
        slPatternSize->addMultiplier(10);
 
        slPatternSize->setSingleStep(0.01);
        slPatternSize->setSuffix(i18n("x"));
        slPatternSize->setMinimumWidth(qMax(sliderWidth, slPatternSize->sizeHint().width()));
        slPatternSize->setFixedHeight(buttonsize);
        slPatternSize->setBlockUpdateSignalOnDrag(true);
 
        m_sliderChooser[i]->setMinimumWidth(qMax(sliderWidth, slPatternSize->sizeHint().width()));
 
        m_sliderChooser[i]->chooseWidget(cfg.toolbarSlider(i + 1));
    }
 
    m_cmbCompositeOp = new KisCompositeOpComboBox();
    m_cmbCompositeOp->setFixedHeight(buttonsize);
    m_cmbCompositeOp->connectBlendmodeActions(m_viewManager->actionManager());
 
    // Workspace Button
    m_workspaceWidget = new KisPopupButton(this);
    m_workspaceWidget->setIcon(KisIconUtils::loadIcon("workspace-chooser"));
    m_workspaceWidget->setToolTip(i18n("Choose workspace"));
    m_workspaceWidget->setFixedSize(buttonsize, buttonsize);
    m_workspaceWidget->setIconSize(QSize(iconsize, iconsize));
    KisWorkspaceChooser *workspacePopup = new KisWorkspaceChooser(viewManager);
    m_workspaceWidget->setPopupWidget(workspacePopup);
    m_workspaceWidget->setAutoRaise(true);
    m_workspaceWidget->setArrowVisible(false);
 
    m_presetsChooserPopup = new KisPaintOpPresetsChooserPopup();
    m_presetsChooserPopup->setMinimumHeight(550);
    m_presetsChooserPopup->setMinimumWidth(450);
    m_presetSelectorPopupButton->setPopupWidget(m_presetsChooserPopup);
 
    QHBoxLayout* baseLayout = new QHBoxLayout(this);
    m_paintopWidget = new QWidget(this);
    baseLayout->addWidget(m_paintopWidget);
    baseLayout->setSpacing(4);
    baseLayout->setContentsMargins(0, 0, 0, 0);
 
    m_layout = new QHBoxLayout(m_paintopWidget);
    if (!cfg.toolOptionsInDocker()) {
        m_layout->addWidget(m_toolOptionsPopupButton);
    }
    m_layout->addWidget(m_brushEditorPopupButton);
    m_layout->addWidget(m_presetSelectorPopupButton);
    m_layout->setSpacing(4);
    m_layout->setContentsMargins(0, 0, 0, 0);
 
    QWidget* compositeActions = new QWidget(this);
    QHBoxLayout* compositeLayout = new QHBoxLayout(compositeActions);
    compositeLayout->addWidget(m_cmbCompositeOp);
    compositeLayout->addWidget(m_eraseModeButton);
    compositeLayout->addWidget(m_alphaLockButton);
 
    compositeLayout->setSpacing(4);
    compositeLayout->setContentsMargins(0, 0, 0, 0);
 
    compositeLayout->addWidget(m_reloadButton);
 
    QWidgetAction * action;
 
    action = new QWidgetAction(this);
    viewManager->actionCollection()->addAction("composite_actions", action);
    action->setText(i18n("Brush composite"));
    action->setDefaultWidget(compositeActions);
 
    action = new QWidgetAction(this);
    KisActionRegistry::instance()->propertizeAction("brushslider1", action);
    viewManager->actionCollection()->addAction("brushslider1", action);
    action->setDefaultWidget(m_sliderChooser[0]);
    connect(action, SIGNAL(triggered()), m_sliderChooser[0], SLOT(showPopupWidget()));
    connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[0], SLOT(updateThemedIcons()));
 
    action = new QWidgetAction(this);
    KisActionRegistry::instance()->propertizeAction("brushslider2", action);
    viewManager->actionCollection()->addAction("brushslider2", action);
    action->setDefaultWidget(m_sliderChooser[1]);
    connect(action, SIGNAL(triggered()), m_sliderChooser[1], SLOT(showPopupWidget()));
    connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[1], SLOT(updateThemedIcons()));
 
    action = new QWidgetAction(this);
    KisActionRegistry::instance()->propertizeAction("brushslider3", action);
    viewManager->actionCollection()->addAction("brushslider3", action);
    action->setDefaultWidget(m_sliderChooser[2]);
    connect(action, SIGNAL(triggered()), m_sliderChooser[2], SLOT(showPopupWidget()));
    connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[2], SLOT(updateThemedIcons()));
 
    action = new QWidgetAction(this);
    KisActionRegistry::instance()->propertizeAction("brushslider4", action);
    viewManager->actionCollection()->addAction("brushslider4", action);
    action->setDefaultWidget(m_sliderChooser[3]);
    connect(action, SIGNAL(triggered()), m_sliderChooser[3], SLOT(showPopupWidget()));
    connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[3], SLOT(updateThemedIcons()));
 
    action = new QWidgetAction(this);
    KisActionRegistry::instance()->propertizeAction("brushslider5", action);
    viewManager->actionCollection()->addAction("brushslider5", action);
    action->setDefaultWidget(m_sliderChooser[4]);
    connect(action, SIGNAL(triggered()), m_sliderChooser[4], SLOT(showPopupWidget()));
    connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[4], SLOT(updateThemedIcons()));
 
    action = new QWidgetAction(this);
    KisActionRegistry::instance()->propertizeAction("next_favorite_preset", action);
    viewManager->actionCollection()->addAction("next_favorite_preset", action);
    connect(action, SIGNAL(triggered()), this, SLOT(slotNextFavoritePreset()));
 
    action = new QWidgetAction(this);
    KisActionRegistry::instance()->propertizeAction("previous_favorite_preset", action);
    viewManager->actionCollection()->addAction("previous_favorite_preset", action);
    connect(action, SIGNAL(triggered()), this, SLOT(slotPreviousFavoritePreset()));
 
    action = new QWidgetAction(this);
    KisActionRegistry::instance()->propertizeAction("previous_preset", action);
    viewManager->actionCollection()->addAction("previous_preset", action);
    connect(action, SIGNAL(triggered()), this, SLOT(slotSwitchToPreviousPreset()));
 
    if (!cfg.toolOptionsInDocker()) {
        action = new QWidgetAction(this);
        KisActionRegistry::instance()->propertizeAction("show_tool_options", action);
        viewManager->actionCollection()->addAction("show_tool_options", action);
        connect(action, SIGNAL(triggered()), m_toolOptionsPopupButton, SLOT(showPopupWidget()));
    }
 
 
    action = new QWidgetAction(this);
    KisActionRegistry::instance()->propertizeAction("show_brush_presets", action);
    viewManager->actionCollection()->addAction("show_brush_presets", action);
    connect(action, SIGNAL(triggered()), m_presetSelectorPopupButton, SLOT(showPopupWidget()));
    m_presetsChooserPopup->addAction(action);
 
    QWidget* mirrorActions = new QWidget(this);
    QHBoxLayout* mirrorLayout = new QHBoxLayout(mirrorActions);
    mirrorLayout->addWidget(m_hMirrorButton);
 
    mirrorLayout->addWidget(m_vMirrorButton);
    mirrorLayout->addWidget(m_wrapAroundButton);
    mirrorLayout->setSpacing(4);
    mirrorLayout->setContentsMargins(0, 0, 0, 0);
 
    action = new QWidgetAction(this);
    KisActionRegistry::instance()->propertizeAction("mirror_actions", action);
    action->setDefaultWidget(mirrorActions);
    viewManager->actionCollection()->addAction("mirror_actions", action);
 
    action = new QWidgetAction(this);
    KisActionRegistry::instance()->propertizeAction(ResourceType::Workspaces, action);
    viewManager->actionCollection()->addAction(ResourceType::Workspaces, action);
    action->setDefaultWidget(m_workspaceWidget);
    connect(action, SIGNAL(triggered()), m_workspaceWidget, SLOT(showPopupWidget()));
    workspacePopup->addAction(action);
 
    if (!cfg.toolOptionsInDocker()) {
        m_toolOptionsPopup = new KisToolOptionsPopup();
        m_toolOptionsPopupButton->setPopupWidget(m_toolOptionsPopup);
    }
 
 
    m_savePresetWidget = new KisPresetSaveWidget(this);
 
    m_presetsEditor = new KisPaintOpPresetsEditor(m_resourceProvider, m_favoriteResourceManager, m_savePresetWidget, m_brushEditorPopupButton);
    m_presetsEditor->setWindowTitle(i18n("Brush Editor"));
    m_brushEditorPopupButton->setPopupWidget(m_presetsEditor);
    m_brushEditorPopupButton->setPopupWidgetDetached(cfg.paintopPopupDetached());
 
    connect(m_presetsEditor, SIGNAL(brushEditorShown()), SLOT(slotUpdateOptionsWidgetPopup()));
    connect(m_presetsEditor, SIGNAL(toggleDetachState(bool)), m_brushEditorPopupButton, SLOT(setPopupWidgetDetached(bool)));
    connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_presetsEditor, SLOT(updateThemedIcons()));
 
    action = new QWidgetAction(this);
    KisActionRegistry::instance()->propertizeAction("show_brush_editor", action);
    viewManager->actionCollection()->addAction("show_brush_editor", action);
    connect(action, SIGNAL(toggled(bool)), this, SLOT(togglePresetEditor()));
    m_presetsEditor->addAction(action);
 
    m_currCompositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
    slotNodeChanged(viewManager->activeNode());
    // Get all the paintops
    QList<QString> keys = KisPaintOpRegistry::instance()->keys();
    QList<KisPaintOpFactory*> factoryList;
 
    Q_FOREACH (const QString & paintopId, keys) {
        factoryList.append(KisPaintOpRegistry::instance()->get(paintopId));
    }
    m_presetsEditor->setPaintOpList(factoryList);
 
    connect(m_presetsEditor       , SIGNAL(paintopActivated(QString))          , SLOT(slotSetPaintop(QString)));
    connect(m_presetsEditor       , SIGNAL(defaultPresetClicked())             , SLOT(slotSetupDefaultPreset()));
    connect(m_presetsEditor       , SIGNAL(signalResourceSelected(KoResourceSP )), SLOT(resourceSelected(KoResourceSP )));
    connect(m_presetsEditor       , SIGNAL(reloadPresetClicked())              , SLOT(slotReloadPreset()));
    connect(m_presetsEditor       , SIGNAL(dirtyPresetToggled(bool))           , SLOT(slotDirtyPresetToggled(bool)));
    connect(m_presetsEditor       , SIGNAL(eraserBrushSizeToggled(bool))       , SLOT(slotEraserBrushSizeToggled(bool)));
    connect(m_presetsEditor       , SIGNAL(eraserBrushOpacityToggled(bool))       , SLOT(slotEraserBrushOpacityToggled(bool)));
 
    connect(m_presetsEditor, SIGNAL(createPresetFromScratch(QString)), this, SLOT(slotCreatePresetFromScratch(QString)));
 
    connect(m_presetsChooserPopup, SIGNAL(resourceSelected(KoResourceSP ))      , SLOT(resourceSelected(KoResourceSP )));
    connect(m_presetsChooserPopup, SIGNAL(resourceClicked(KoResourceSP ))      , SLOT(resourceSelected(KoResourceSP )));
 
    connect(m_resourceProvider   , SIGNAL(sigNodeChanged(KisNodeSP))    , SLOT(slotNodeChanged(KisNodeSP)));
    connect(m_cmbCompositeOp     , SIGNAL(currentIndexChanged(int))           , SLOT(slotSetCompositeMode(int)));
    connect(m_eraseAction          , SIGNAL(toggled(bool))                    , SLOT(slotToggleEraseMode(bool)));
    connect(m_eraserTogglePresetAction , SIGNAL(triggered(bool))                    , SLOT(slotToggleEraserPreset(bool)));
 
    connect(m_eraserSelectPresetAction , SIGNAL(triggered())                    , SLOT(slotSelectEraserPreset()));
    connect(m_brushSelectPresetAction , SIGNAL(triggered())                    , SLOT(slotSelectBrushPreset()));
 
    connect(alphaLockAction      , SIGNAL(toggled(bool))                    , SLOT(slotToggleAlphaLockMode(bool)));
 
    m_disablePressureAction = m_viewManager->actionManager()->createAction("disable_pressure");
    connect(m_disablePressureAction  , SIGNAL(toggled(bool))                    , SLOT(slotDisablePressureMode(bool)));
    m_disablePressureAction->setChecked(true);
 
    connect(m_hMirrorAction        , SIGNAL(toggled(bool))                    , SLOT(slotHorizontalMirrorChanged(bool)));
    connect(m_vMirrorAction        , SIGNAL(toggled(bool))                    , SLOT(slotVerticalMirrorChanged(bool)));
    connect(m_reloadAction         , SIGNAL(triggered())                        , SLOT(slotReloadPreset()));
 
    connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("opacity")               , SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
    connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("flow")                  , SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
    connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("size")                  , SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
    connect(m_sliderChooser[0]->getWidget<KisAngleSelector>("rotation")                    , SIGNAL(angleChanged(qreal)), SLOT(slotSlider1Changed()));
    connect(m_sliderChooser[0]->getWidget<KisMultipliersDoubleSliderSpinBox>("patternsize"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
    connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("opacity")               , SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
    connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("flow")                  , SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
    connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("size")                  , SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
    connect(m_sliderChooser[1]->getWidget<KisAngleSelector>("rotation")                    , SIGNAL(angleChanged(qreal)), SLOT(slotSlider2Changed()));
    connect(m_sliderChooser[1]->getWidget<KisMultipliersDoubleSliderSpinBox>("patternsize"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
    connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("opacity")               , SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
    connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("flow")                  , SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
    connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("size")                  , SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
    connect(m_sliderChooser[2]->getWidget<KisAngleSelector>("rotation")                    , SIGNAL(angleChanged(qreal)), SLOT(slotSlider3Changed()));
    connect(m_sliderChooser[2]->getWidget<KisMultipliersDoubleSliderSpinBox>("patternsize"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
    connect(m_sliderChooser[3]->getWidget<KisDoubleSliderSpinBox>("opacity")               , SIGNAL(valueChanged(qreal)), SLOT(slotSlider4Changed()));
    connect(m_sliderChooser[3]->getWidget<KisDoubleSliderSpinBox>("flow")                  , SIGNAL(valueChanged(qreal)), SLOT(slotSlider4Changed()));
    connect(m_sliderChooser[3]->getWidget<KisDoubleSliderSpinBox>("size")                  , SIGNAL(valueChanged(qreal)), SLOT(slotSlider4Changed()));
    connect(m_sliderChooser[3]->getWidget<KisAngleSelector>("rotation")                    , SIGNAL(angleChanged(qreal)), SLOT(slotSlider4Changed()));
    connect(m_sliderChooser[3]->getWidget<KisMultipliersDoubleSliderSpinBox>("patternsize"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider4Changed()));
    connect(m_sliderChooser[4]->getWidget<KisDoubleSliderSpinBox>("opacity")               , SIGNAL(valueChanged(qreal)), SLOT(slotSlider5Changed()));
    connect(m_sliderChooser[4]->getWidget<KisDoubleSliderSpinBox>("flow")                  , SIGNAL(valueChanged(qreal)), SLOT(slotSlider5Changed()));
    connect(m_sliderChooser[4]->getWidget<KisDoubleSliderSpinBox>("size")                  , SIGNAL(valueChanged(qreal)), SLOT(slotSlider5Changed()));
    connect(m_sliderChooser[4]->getWidget<KisAngleSelector>("rotation")                    , SIGNAL(angleChanged(qreal)), SLOT(slotSlider5Changed()));
    connect(m_sliderChooser[4]->getWidget<KisMultipliersDoubleSliderSpinBox>("patternsize"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider5Changed()));
 
    connect(m_resourceProvider, SIGNAL(sigFGColorUsed(KoColor)), m_favoriteResourceManager, SLOT(slotAddRecentColor(KoColor)));
 
    connect(m_resourceProvider, SIGNAL(sigFGColorChanged(KoColor)), m_favoriteResourceManager, SLOT(slotChangeFGColorSelector(KoColor)));
    connect(m_resourceProvider, SIGNAL(sigBGColorChanged(KoColor)), m_favoriteResourceManager, SLOT(slotSetBGColor(KoColor)));
 
    // cold initialization
    m_favoriteResourceManager->slotChangeFGColorSelector(m_resourceProvider->fgColor());
    m_favoriteResourceManager->slotSetBGColor(m_resourceProvider->bgColor());
 
    connect(m_favoriteResourceManager, SIGNAL(sigSetFGColor(KoColor)), m_resourceProvider, SLOT(slotSetFGColor(KoColor)));
    connect(m_favoriteResourceManager, SIGNAL(sigSetBGColor(KoColor)), m_resourceProvider, SLOT(slotSetBGColor(KoColor)));
 
    connect(viewManager->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateSelectionIcon()));
    connect(m_resourceProvider->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
            this, SLOT(slotCanvasResourceChanged(int,QVariant)));
    connect(m_resourceProvider->resourceManager(), SIGNAL(canvasResourceChangeAttempted(int,QVariant)),
            this, SLOT(slotCanvasResourceChangeAttempted(int,QVariant)));
 
    connect(&m_optionWidgetUpdateCompressor, SIGNAL(timeout()), this, SLOT(slotUpdateOptionsWidgetPopup()));
 
    slotInputDeviceChanged(KoToolManager::instance()->currentInputDevice());
 
    m_brushSelectPresetAction->setChecked(true);
}

◆ ~KisPaintopBox()

KisPaintopBox::~KisPaintopBox ( )

override

Definition at line 585 of file kis_paintop_box.cc.

{
    updatePresetConfig();
 
    // Do not delete the widget, since it is global to the application, not owned by the view
    m_presetsEditor->setPaintOpSettingsWidget(0);
    qDeleteAll(m_paintopOptionWidgets);
    delete m_favoriteResourceManager;
 
    delete toolbarMenuXMirror;
    delete toolbarMenuYMirror;
 
    for (int i = 0; i < 5; ++i)
    {
        delete m_sliderChooser[i];
    }
}

References m_favoriteResourceManager, m_paintopOptionWidgets, m_presetsEditor, m_sliderChooser, KisPaintOpPresetsEditor::setPaintOpSettingsWidget(), toolbarMenuXMirror, toolbarMenuYMirror, and updatePresetConfig().

Member Function Documentation

◆ activePreset()

KisPaintOpPresetSP KisPaintopBox::activePreset ( const KoID & paintOp )

private

Definition at line 828 of file kis_paintop_box.cc.

{
    if (m_paintOpPresetMap[paintOp] == 0) {
        m_paintOpPresetMap[paintOp] = defaultPreset(paintOp);
    }
 
    return m_paintOpPresetMap[paintOp];
}

References defaultPreset(), and m_paintOpPresetMap.

◆ defaultPreset()

KisPaintOpPresetSP KisPaintopBox::defaultPreset ( const KoID & paintOp )

private

Definition at line 782 of file kis_paintop_box.cc.

{
    QString path = ":/presets/" + paintOp.id() + ".kpp";
 
    if (paintOp.id() == "mypaintbrush") {
        path = ":/presets/" + paintOp.id() + ".myb";
    }
 
    dbgResources << "Getting default presets from qrc resources" << path;
 
    KisPaintOpPresetSP preset(new KisPaintOpPreset(path));
 
    if (!preset->load(KisGlobalResourcesInterface::instance())) {
        bool success = false;
 
        QFile file(path);
 
        if (file.open(QIODevice::ReadOnly))
        {
            // this is needed specifically for MyPaint brushes
            QVector<KisResourceLoaderBase*> loaders = KisResourceLoaderRegistry::instance()->resourceTypeLoaders(ResourceType::PaintOpPresets);
            for (int i = 0; i < loaders.count(); i++) {
                file.seek(0); // to ensure that one loader reading bytes won't interfere with another
                KoResourceSP resource = loaders[i]->load(paintOp.id(), file, KisGlobalResourcesInterface::instance());
                if (resource) {
                    preset = resource.dynamicCast<KisPaintOpPreset>();
                    success = !preset.isNull();
                    if (success) {
                        break;
                    }
                }
            }
            file.close();
        }
 
        if (!success) {
            preset = KisPaintOpRegistry::instance()->defaultPreset(paintOp, KisGlobalResourcesInterface::instance());
        }
    }
 
    Q_ASSERT(preset);
    Q_ASSERT(preset->valid());
 
    return preset;
}

References dbgResources, KisPaintOpRegistry::defaultPreset(), KoID::id(), KisPaintOpRegistry::instance(), KisGlobalResourcesInterface::instance(), KisResourceLoaderRegistry::instance(), ResourceType::PaintOpPresets, and KisResourceLoaderRegistry::resourceTypeLoaders().

◆ favoriteResourcesManager()

KisFavoriteResourceManager * KisPaintopBox::favoriteResourcesManager ( )

inline

Definition at line 106 of file kis_paintop_box.h.

106{ return m_favoriteResourceManager; }

◆ findDefaultPresets()

void KisPaintopBox::findDefaultPresets ( )

private

Definition at line 1557 of file kis_paintop_box.cc.

{
    m_eraserName = "a) Eraser Circle";
    m_defaultPresetName = "b) Basic-5 Size Opacity";
}

References m_defaultPresetName, and m_eraserName.

◆ newOptionWidgets()

void KisPaintopBox::newOptionWidgets ( const QList< QPointer< QWidget > > & optionWidgetList )

Update the option widgets to the argument ones, removing the currently set widgets.

Definition at line 614 of file kis_paintop_box.cc.

{
    if (m_toolOptionsPopup) {
        m_toolOptionsPopup->newOptionWidgets(optionWidgetList);
    }
}

References m_toolOptionsPopup, and KisToolOptionsPopup::newOptionWidgets().

◆ resourceSelected

void KisPaintopBox::resourceSelected ( KoResourceSP resource )

slot

Definition at line 621 of file kis_paintop_box.cc.

{
    // This happens if no storages were available on startup
    if (!m_optionWidget) {
        KisPaintOpPresetSP preset = resource.dynamicCast<KisPaintOpPreset>();
        setCurrentPaintop(preset);
        return;
    }
 
    m_presetsEditor->setCreatingBrushFromScratch(false); // show normal UI elements when we are not creating
 
    KisPaintOpPresetSP preset = resource.dynamicCast<KisPaintOpPreset>();
 
    if (preset && preset->valid() && preset != m_resourceProvider->currentPreset()) {
        if (!m_dirtyPresetsEnabled) {
            KisSignalsBlocker blocker(m_optionWidget);
            Q_UNUSED(blocker);
 
            KisPaintOpPresetResourceServer *rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
 
            if (!rserver->reloadResource(preset)) {
                qWarning() << "failed to reload the preset.";
            }
        }
 
        dbgResources << "resourceSelected: preset" << preset << (preset ? QString("%1").arg(preset->valid()) : "");
        setCurrentPaintop(preset);
 
        m_presetsEditor->resourceSelected(resource);
    }
}

References KisCanvasResourceProvider::currentPreset(), dbgResources, KisResourceServerProvider::instance(), m_dirtyPresetsEnabled, m_optionWidget, m_presetsEditor, m_resourceProvider, KisResourceServerProvider::paintOpPresetServer(), KoResourceServer< T >::reloadResource(), KisPaintOpPresetsEditor::resourceSelected(), KisPaintOpPresetsEditor::setCreatingBrushFromScratch(), and setCurrentPaintop().

◆ restoreResource()

void KisPaintopBox::restoreResource ( KoResourceSP resource )

Definition at line 603 of file kis_paintop_box.cc.

{
    KisPaintOpPresetSP preset = resource.dynamicCast<KisPaintOpPreset>();
 
    if (preset) {
        setCurrentPaintop(preset);
 
        m_presetsEditor->resourceSelected(resource);
    }
}

References m_presetsEditor, KisPaintOpPresetsEditor::resourceSelected(), and setCurrentPaintop().

◆ setAngleSliderValue()

void KisPaintopBox::setAngleSliderValue	(	const QString &	sliderID,
		qreal	value )

private

Definition at line 892 of file kis_paintop_box.cc.

{
    for (int i = 0; i < 5; ++i) {
        KisAngleSelector* slider = m_sliderChooser[i]->getWidget<KisAngleSelector>(sliderID);
        if (!slider) continue;
        KisSignalsBlocker b(slider);
 
        slider->setAngle(value);
    }
}

References KisWidgetChooser::getWidget(), m_sliderChooser, KisAngleSelector::setAngle(), and value().

◆ setCurrentPaintop() [1/2]

void KisPaintopBox::setCurrentPaintop ( const KoID & paintop )

private

Definition at line 653 of file kis_paintop_box.cc.

{
    KisPaintOpPresetSP preset = activePreset(paintop);
    setCurrentPaintop(preset);
}

References activePreset(), and setCurrentPaintop().

◆ setCurrentPaintop() [2/2]

void KisPaintopBox::setCurrentPaintop ( KisPaintOpPresetSP preset )

private

We must connect to the uncompressed version of the preset update signal. That is the only way we can guarantee that the signals will not form cycles. As a consequence, we should compress this signal ourselves.

Definition at line 659 of file kis_paintop_box.cc.

{
    if (preset == m_resourceProvider->currentPreset()) {
        if (preset == m_tabletToolMap[m_currTabletToolID].preset) {
            return;
        }
    }
    Q_ASSERT(preset);
    const KoID& paintop = preset->paintOp();
    m_presetConnections.clear();
 
    if (m_resourceProvider->currentPreset()) {
        m_resourceProvider->setPreviousPaintOpPreset(m_resourceProvider->currentPreset());
 
        if (m_optionWidget) {
            m_optionWidget->hide();
        }
 
    }
 
    if (!m_paintopOptionWidgets.contains(paintop)) {
        m_paintopOptionWidgets[paintop] =
                KisPaintOpRegistry::instance()->get(paintop.id())
                ->createConfigWidget(this,
                                     KisGlobalResourcesInterface::instance(),
                                     m_viewManager->canvasResourceProvider()->resourceManager()->canvasResourcesInterface());
    }
 
    m_optionWidget = m_paintopOptionWidgets[paintop];
 
    Q_ASSERT(m_optionWidget && m_presetSelectorPopupButton);
 
    KisSignalsBlocker b(m_optionWidget);
 
    m_optionWidget->setImage(m_viewManager->image());
    m_optionWidget->setNode(m_viewManager->activeNode());
 
    m_presetsEditor->setPaintOpSettingsWidget(m_optionWidget);
    m_presetsEditor->readOptionSetting(preset->settings());
 
    m_resourceProvider->setPaintOpPreset(preset);
 
 
 
    m_optionsWidgetConnections.reset(new KisAcyclicSignalConnector());
    m_optionsWidgetConnections->connectForwardVoid(m_optionWidget, SIGNAL(sigConfigurationUpdated()), this, SLOT(slotGuiChangedCurrentPreset()));
    m_optionsWidgetConnections->connectBackwardVoid(preset->updateProxy(), SIGNAL(sigSettingsChangedUncompressed()), &m_optionWidgetUpdateCompressor, SLOT(start()));
 
    m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigSaveLockedConfig(KisPropertiesConfigurationSP)), this, SLOT(slotSaveLockedOptionToPreset(KisPropertiesConfigurationSP)));
    m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigDropLockedConfig(KisPropertiesConfigurationSP)), this, SLOT(slotDropLockedOption(KisPropertiesConfigurationSP)));
 
    // load the current preset icon to the preset selector toolbar button
    m_presetSelectorPopupButton->setThumbnail(preset->image());
    m_presetsEditor->setCurrentPaintOpId(paintop.id());
 
 
    //o() << "\tsetting the new preset for" << m_currTabletToolID.uniqueID << "to" << preset->name();
    m_paintOpPresetMap[m_resourceProvider->currentPreset()->paintOp()] = preset;
    m_tabletToolMap[m_currTabletToolID].preset = preset;
    m_tabletToolMap[m_currTabletToolID].paintOpID = preset->paintOp();
 
 
    if (m_presetsEditor->currentPaintOpId() != paintop.id()) {
        // Must change the paintop as the current one is not supported
        // by the new colorspace.
        dbgKrita << "current paintop " << paintop.name() << " was not set, not supported by colorspace";
    }
 
    m_currCompositeOpID = preset->settings()->paintOpCompositeOp();
    updateCompositeOp(m_currCompositeOpID);
 
    if (preset->settings()->hasPatternSettings()) {
        setMultiplierSliderValue("patternsize", preset->settings()->paintOpPatternSize());
    }
 
    // MyPaint brushes don't support custom blend modes, they always perform "Normal and Erase" blending.
    if (preset->paintOp().id() == "mypaintbrush") {
        setWidgetState(DISABLE_COMPOSITEOP);
        if (m_resourceProvider->currentCompositeOp() != COMPOSITE_ERASE && m_resourceProvider->currentCompositeOp() != COMPOSITE_OVER) {
            m_resourceProvider->setCurrentCompositeOp(COMPOSITE_OVER);
        }
    }
    else {
        setWidgetState(ENABLE_COMPOSITEOP);
    }
}

References KisViewManager::activeNode(), KisSignalAutoConnectionsStore::addConnection(), KisViewManager::canvasResourceProvider(), KoCanvasResourceProvider::canvasResourcesInterface(), KisSignalAutoConnectionsStore::clear(), COMPOSITE_ERASE, COMPOSITE_OVER, KisPaintOpFactory::createConfigWidget(), KisCanvasResourceProvider::currentCompositeOp(), KisPaintOpPresetsEditor::currentPaintOpId(), KisCanvasResourceProvider::currentPreset(), dbgKrita, DISABLE_COMPOSITEOP, ENABLE_COMPOSITEOP, KoGenericRegistry< T >::get(), KoID::id(), KisViewManager::image(), KisPaintOpRegistry::instance(), KisGlobalResourcesInterface::instance(), m_currCompositeOpID, m_currTabletToolID, m_optionsWidgetConnections, m_optionWidget, m_optionWidgetUpdateCompressor, m_paintopOptionWidgets, m_paintOpPresetMap, m_presetConnections, m_presetsEditor, m_presetSelectorPopupButton, m_resourceProvider, m_tabletToolMap, m_viewManager, KoID::name(), KisPaintOpPresetsEditor::readOptionSetting(), KisCanvasResourceProvider::resourceManager(), KisCanvasResourceProvider::setCurrentCompositeOp(), KisPaintOpPresetsEditor::setCurrentPaintOpId(), KisPaintOpConfigWidget::setImage(), setMultiplierSliderValue(), KisPaintOpConfigWidget::setNode(), KisCanvasResourceProvider::setPaintOpPreset(), KisPaintOpPresetsEditor::setPaintOpSettingsWidget(), KisCanvasResourceProvider::setPreviousPaintOpPreset(), KisIconWidget::setThumbnail(), setWidgetState(), slotDropLockedOption(), slotGuiChangedCurrentPreset(), slotSaveLockedOptionToPreset(), and updateCompositeOp().

◆ setMultiplierSliderValue()

void KisPaintopBox::setMultiplierSliderValue	(	const QString &	sliderID,
		qreal	value )

private

Definition at line 881 of file kis_paintop_box.cc.

{
    for (int i = 0; i < 5; ++i) {
        KisMultipliersDoubleSliderSpinBox* slider = m_sliderChooser[i]->getWidget<KisMultipliersDoubleSliderSpinBox>(sliderID);
        if (!slider) continue;
        KisSignalsBlocker b(slider);
 
        slider->setValue(value); // brush pattern size
    }
}

References KisWidgetChooser::getWidget(), m_sliderChooser, KisMultipliersDoubleSliderSpinBox::setValue(), and value().

◆ setSliderValue()

void KisPaintopBox::setSliderValue	(	const QString &	sliderID,
		qreal	value )

private

Definition at line 865 of file kis_paintop_box.cc.

{
    for (int i = 0; i < 5; ++i) {
        KisDoubleSliderSpinBox* slider = m_sliderChooser[i]->getWidget<KisDoubleSliderSpinBox>(sliderID);
        KisSignalsBlocker b(slider);
 
        if (sliderID == "opacity" || sliderID == "flow") { // opacity and flows UI stored at 0-100%
            slider->setValue(value*100);
        } else {
            slider->setValue(value); // brush size
        }
 
 
    }
}

References KisWidgetChooser::getWidget(), m_sliderChooser, KisDoubleSliderSpinBox::setValue(), and value().

◆ setWidgetState()

void KisPaintopBox::setWidgetState ( int flags )

private

Definition at line 858 of file kis_paintop_box.cc.

{
    if (flags & (ENABLE_COMPOSITEOP | DISABLE_COMPOSITEOP)) {
        m_cmbCompositeOp->setEnabled(flags & ENABLE_COMPOSITEOP);
    }
}

References DISABLE_COMPOSITEOP, ENABLE_COMPOSITEOP, and m_cmbCompositeOp.

◆ sliderChanged()

void KisPaintopBox::sliderChanged ( int n )

private

Definition at line 1201 of file kis_paintop_box.cc.

{
    if (!m_optionWidget) // widget will not exist if the are no documents open
        return;
 
 
    KisSignalsBlocker blocker(m_optionWidget);
 
    // flow and opacity are shown as 0-100% on the UI, but their data is actually 0-1. Convert those two values
    // back for further work
    qreal opacity     = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("opacity")->value()/100;
    qreal flow        = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("flow")->value()/100;
    qreal size        = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("size")->value();
    qreal rotation    = m_sliderChooser[n]->getWidget<KisAngleSelector>("rotation")->angle();
    qreal patternsize = m_sliderChooser[n]->getWidget<KisMultipliersDoubleSliderSpinBox>("patternsize")->value();
 
 
    setSliderValue("opacity", opacity);
    setSliderValue("flow"   , flow);
    setSliderValue("size"   , size);
    setAngleSliderValue("rotation", rotation);
    setMultiplierSliderValue("patternsize", patternsize);
 
    if (m_presetsEnabled) {
        // IMPORTANT: set the PaintOp size before setting the other properties
        //            it won't work the other way
        // TODO: why?!
 
        m_resourceProvider->setSize(size);
        m_resourceProvider->setBrushRotation(rotation);
        m_resourceProvider->setPatternSize(patternsize);
        m_resourceProvider->setOpacity(opacity);
        m_resourceProvider->setFlow(flow);
 
 
        KisLockedPropertiesProxySP propertiesProxy = KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(m_resourceProvider->currentPreset()->settings());
        propertiesProxy->setProperty("FlowValue", flow);
        propertiesProxy->setProperty("Texture/Pattern/Scale", patternsize);
        m_presetsEditor->readOptionSetting(m_resourceProvider->currentPreset()->settings());
    } else {
        m_resourceProvider->setOpacity(opacity);
    }
 
    m_presetsEditor->resourceSelected(m_resourceProvider->currentPreset());
}

References KisLockedPropertiesServer::createLockedPropertiesProxy(), KisCanvasResourceProvider::currentPreset(), KisWidgetChooser::getWidget(), KisLockedPropertiesServer::instance(), m_optionWidget, m_presetsEditor, m_presetsEnabled, m_resourceProvider, m_sliderChooser, KisPaintOpPresetsEditor::readOptionSetting(), KisPaintOpPresetsEditor::resourceSelected(), setAngleSliderValue(), KisCanvasResourceProvider::setBrushRotation(), KisCanvasResourceProvider::setFlow(), setMultiplierSliderValue(), KisCanvasResourceProvider::setOpacity(), KisCanvasResourceProvider::setPatternSize(), KisCanvasResourceProvider::setSize(), setSliderValue(), and value().

◆ slotCanvasResourceChangeAttempted

void KisPaintopBox::slotCanvasResourceChangeAttempted	(	int	key,
		const QVariant &	value )

slot

Definition at line 1015 of file kis_paintop_box.cc.

{
    Q_UNUSED(value);
 
    if (key == KoCanvasResource::ForegroundColor) {
        slotUnsetEraseMode();
    }
}

References KoCanvasResource::ForegroundColor, slotUnsetEraseMode(), and value().

◆ slotCanvasResourceChanged

void KisPaintopBox::slotCanvasResourceChanged	(	int	key,
		const QVariant &	v )

slot

Update currently selected preset in both the popup widgets

Definition at line 1024 of file kis_paintop_box.cc.

{
    if (m_viewManager) {
        sender()->blockSignals(true);
        KisPaintOpPresetSP preset = m_viewManager->canvasResourceProvider()->resourceManager()->resource(KoCanvasResource::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
        if (preset && m_resourceProvider->currentPreset()->name() != preset->name()) {
            QString compositeOp = preset->settings()->getString("CompositeOp");
            updateCompositeOp(compositeOp);
            resourceSelected(preset);
        }
 
        if (key == KoCanvasResource::CurrentPaintOpPreset) {
            m_presetsChooserPopup->canvasResourceChanged(preset);
            m_presetsEditor->currentPresetChanged(preset);
        }
 
        if (key == KoCanvasResource::CurrentCompositeOp) {
            if (m_resourceProvider->currentCompositeOp() != m_currCompositeOpID) {
                updateCompositeOp(m_resourceProvider->currentCompositeOp());
            }
        }
 
        if (key == KoCanvasResource::Size) {
            setSliderValue("size", m_resourceProvider->size());
        }
 
        if (key == KoCanvasResource::BrushRotation) {
            setAngleSliderValue("rotation", m_resourceProvider->brushRotation());
        }
 
        if (key == KoCanvasResource::PatternSize) {
            setMultiplierSliderValue("patternsize", m_resourceProvider->patternSize());
        }
 
        if (key == KoCanvasResource::Opacity) {
            setSliderValue("opacity", m_resourceProvider->opacity());
        }
 
        if (key == KoCanvasResource::Flow) {
            setSliderValue("flow", m_resourceProvider->flow());
        }
 
        if (key == KoCanvasResource::EraserMode) {
            m_eraseAction->setChecked(value.toBool());
        }
 
        if (key == KoCanvasResource::DisablePressure) {
            m_disablePressureAction->setChecked(value.toBool());
        }
 
        if (key == KoCanvasResource::MirrorHorizontal) {
            m_hMirrorAction->setChecked(value.toBool());
        }
 
        if (key == KoCanvasResource::MirrorVertical) {
            m_vMirrorAction->setChecked(value.toBool());
        }
 
        sender()->blockSignals(false);
    }
}

◆ slotColorSpaceChanged

void KisPaintopBox::slotColorSpaceChanged ( const KoColorSpace * colorSpace )

slot

Definition at line 1120 of file kis_paintop_box.cc.

{
    KisNodeSP node(m_currentNode);
    const KoColorSpace *compositionSpace = colorSpace;
    if (node && node->paintDevice()) {
        // Currently, composition source is enough to determine the available blending mode,
        // because either destination is the same (paint layers), or composition happens
        // in source space (masks).
        compositionSpace = node->paintDevice()->compositionSourceColorSpace();
    }
    m_cmbCompositeOp->validate(compositionSpace);
}

References KisPaintDevice::compositionSourceColorSpace(), m_cmbCompositeOp, m_currentNode, KisBaseNode::paintDevice(), and KisCompositeOpComboBox::validate().

◆ slotCreatePresetFromScratch

void KisPaintopBox::slotCreatePresetFromScratch ( QString paintop )

slot

This should take care of creating a new brush preset from scratch It will either load the default brush preset for the engine, or create a new empty preset if a default preset does not exist

Definition at line 996 of file kis_paintop_box.cc.

{
    //First try to select an available default preset for that engine. If it doesn't exist, then
    //manually set the engine to use a new preset.
    KoID id(paintop, KisPaintOpRegistry::instance()->get(paintop)->name());
    KisPaintOpPresetSP preset = defaultPreset(id);
 
    slotSetPaintop(paintop);  // change the paintop settings area and update the UI
 
    if (!preset) {
        m_presetsEditor->setCreatingBrushFromScratch(true); // disable UI elements while creating from scratch
        preset = m_resourceProvider->currentPreset();
    } else {
        m_presetsEditor->readOptionSetting(preset->settings());
        m_resourceProvider->setPaintOpPreset(preset);
    }
    m_presetsEditor->resourceSelected(preset);  // this helps update the UI on the brush editor
}

References KisCanvasResourceProvider::currentPreset(), defaultPreset(), get(), KisPaintOpRegistry::instance(), m_presetsEditor, m_resourceProvider, KisPaintOpPresetsEditor::readOptionSetting(), KisPaintOpPresetsEditor::resourceSelected(), KisPaintOpPresetsEditor::setCreatingBrushFromScratch(), KisCanvasResourceProvider::setPaintOpPreset(), and slotSetPaintop().

◆ slotDirtyPresetToggled

void KisPaintopBox::slotDirtyPresetToggled ( bool value )

privateslot

Definition at line 1489 of file kis_paintop_box.cc.

{
    if (!value) {
        slotReloadPreset();
        m_presetsEditor->resourceSelected(m_resourceProvider->currentPreset());
        m_presetsEditor->updateViewSettings();
    }
    m_dirtyPresetsEnabled = value;
    KisConfig cfg(false);
    cfg.setUseDirtyPresets(m_dirtyPresetsEnabled);
}

References KisCanvasResourceProvider::currentPreset(), m_dirtyPresetsEnabled, m_presetsEditor, m_resourceProvider, KisPaintOpPresetsEditor::resourceSelected(), KisConfig::setUseDirtyPresets(), slotReloadPreset(), KisPaintOpPresetsEditor::updateViewSettings(), and value().

◆ slotDisablePressureMode

void KisPaintopBox::slotDisablePressureMode ( bool checked )

privateslot

Definition at line 1395 of file kis_paintop_box.cc.

{
    if (checked) {
        m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
    } else {
        m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure_locked"));
    }
 
    m_resourceProvider->setDisablePressure(checked);
}

References KisIconUtils::loadIcon(), m_disablePressureAction, m_resourceProvider, and KisCanvasResourceProvider::setDisablePressure().

◆ slotDropLockedOption

void KisPaintopBox::slotDropLockedOption ( KisPropertiesConfigurationSP p )

privateslot

Definition at line 1469 of file kis_paintop_box.cc.

{
    KisSignalsBlocker blocker(m_optionWidget);
    KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
    {
        KisPaintOpPreset::UpdatedPostponer postponer(preset);
        KisDirtyStateSaver<KisPaintOpPresetSP> dirtySaver(preset);
 
        QMapIterator<QString, QVariant> i(p->getProperties());
        while (i.hasNext()) {
            i.next();
            if (preset->settings()->hasProperty(i.key() + "_previous")) {
                preset->settings()->setProperty(i.key(), preset->settings()->getProperty(i.key() + "_previous"));
                preset->settings()->removeProperty(i.key() + "_previous");
            }
 
        }
    }
}

References KisCanvasResourceProvider::currentPreset(), m_optionWidget, m_resourceProvider, and p.

◆ slotEraserBrushOpacityToggled

void KisPaintopBox::slotEraserBrushOpacityToggled ( bool value )

privateslot

Definition at line 1508 of file kis_paintop_box.cc.

{
    m_eraserBrushOpacityEnabled = value;
    KisConfig cfg(false);
    cfg.setUseEraserBrushOpacity(m_eraserBrushOpacityEnabled);
}

References m_eraserBrushOpacityEnabled, KisConfig::setUseEraserBrushOpacity(), and value().

◆ slotEraserBrushSizeToggled

void KisPaintopBox::slotEraserBrushSizeToggled ( bool value )

privateslot

Definition at line 1501 of file kis_paintop_box.cc.

{
    m_eraserBrushSizeEnabled = value;
    KisConfig cfg(false);
    cfg.setUseEraserBrushSize(m_eraserBrushSizeEnabled);
}

References m_eraserBrushSizeEnabled, KisConfig::setUseEraserBrushSize(), and value().

◆ slotGuiChangedCurrentPreset

void KisPaintopBox::slotGuiChangedCurrentPreset ( )

privateslot

Here we postpone all the settings updates events until the entire writing operation will be finished. As soon as it is finished, the updates will be emitted happily (if there were any).

Definition at line 1419 of file kis_paintop_box.cc.

{
    KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
    {
        KisPaintOpPreset::UpdatedPostponer postponer(preset);
 
        // clear all the properties before dumping the stuff into the preset,
        // some of the options add the values incrementally
        // (e.g. KisPaintOpUtils::RequiredBrushFilesListTag), therefore they
        // may add up if we pass the same preset multiple times
        preset->settings()->resetSettings();
 
        m_presetsEditor->writeOptionSetting(const_cast<KisPaintOpSettings*>(preset->settings().data()));
    }
 
    // we should also update the preset strip to update the status of the "dirty" mark
    m_presetsEditor->resourceSelected(m_resourceProvider->currentPreset());
 
    // TODO!!!!!!!!
    //m_presetsPopup->updateViewSettings();
}

References KisCanvasResourceProvider::currentPreset(), m_presetsEditor, m_resourceProvider, KisPaintOpPresetsEditor::resourceSelected(), and KisPaintOpPresetsEditor::writeOptionSetting().

◆ slotHideDecorationMirrorX

void KisPaintopBox::slotHideDecorationMirrorX ( bool toggled )

privateslot

Definition at line 1541 of file kis_paintop_box.cc.

                                                          {
    m_resourceProvider->setMirrorHorizontalHideDecorations(toggled);
}

References m_resourceProvider, and KisCanvasResourceProvider::setMirrorHorizontalHideDecorations().

◆ slotHideDecorationMirrorY

void KisPaintopBox::slotHideDecorationMirrorY ( bool toggled )

privateslot

Definition at line 1545 of file kis_paintop_box.cc.

                                                          {
    m_resourceProvider->setMirrorVerticalHideDecorations(toggled);
}

References m_resourceProvider, and KisCanvasResourceProvider::setMirrorVerticalHideDecorations().

◆ slotHorizontalMirrorChanged

void KisPaintopBox::slotHorizontalMirrorChanged ( bool value )

privateslot

Definition at line 1191 of file kis_paintop_box.cc.

{
    m_resourceProvider->setMirrorHorizontal(value);
}

References m_resourceProvider, KisCanvasResourceProvider::setMirrorHorizontal(), and value().

◆ slotInputDeviceChanged

void KisPaintopBox::slotInputDeviceChanged ( const KoInputDevice & inputDevice )

slot

Definition at line 912 of file kis_paintop_box.cc.

{
    TabletToolMap::iterator toolData = m_tabletToolMap.find(inputDevice);
 
    //qDebug() << "slotInputDeviceChanged()" << inputDevice.device() << inputDevice.uniqueTabletId();
 
    m_eraserTogglePresetAction->setChecked(inputDevice.pointer() == KoInputDevice::Pointer::Eraser);
    m_eraserSelectPresetAction->setChecked(inputDevice.pointer() == KoInputDevice::Pointer::Eraser);
    m_brushSelectPresetAction->setChecked(inputDevice.pointer() == KoInputDevice::Pointer::Pen);
 
    m_currTabletToolID = TabletToolID(inputDevice);
 
    if (toolData == m_tabletToolMap.end()) {
        KisConfig cfg(true);
        KisPaintOpPresetResourceServer *rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
        KisPaintOpPresetSP preset;
 
        findDefaultPresets();
 
        if (inputDevice.pointer() == KoInputDevice::Pointer::Eraser) {
            preset = rserver->resource("", "", cfg.readEntry<QString>(QString("LastEraser_%1").arg(inputDevice.uniqueTabletId()), m_eraserName));
        }
        else {
            preset = rserver->resource("", "", cfg.readEntry<QString>(QString("LastPreset_%1").arg(inputDevice.uniqueTabletId()), m_defaultPresetName));
//            if (preset)
//                qDebug() << "found stored preset " << preset->name() << "for" << inputDevice.uniqueTabletId();
//            else
//                qDebug() << "no preset found for" << inputDevice.uniqueTabletId();
        }
        if (!preset) {
            preset = rserver->resource("", "", m_defaultPresetName);
        }
        if (preset) {
//            qDebug() << "inputdevicechanged 1" << preset;
            setCurrentPaintop(preset);
        }
    }
    else {
        if (toolData->preset) {
            //qDebug() << "inputdevicechanged 2" << toolData->preset;
            setCurrentPaintop(toolData->preset);
        }
        else {
            //qDebug() << "inputdevicechanged 3" << toolData->paintOpID;
            setCurrentPaintop(toolData->paintOpID);
        }
    }
}

References KoInputDevice::Eraser, findDefaultPresets(), KisResourceServerProvider::instance(), m_brushSelectPresetAction, m_currTabletToolID, m_defaultPresetName, m_eraserName, m_eraserSelectPresetAction, m_eraserTogglePresetAction, m_tabletToolMap, KisResourceServerProvider::paintOpPresetServer(), KoInputDevice::Pen, KoInputDevice::pointer, KisConfig::readEntry(), KoResourceServer< T >::resource(), setCurrentPaintop(), and KoInputDevice::uniqueTabletId.

◆ slotLockXMirrorToggle

void KisPaintopBox::slotLockXMirrorToggle ( bool toggleLock )

privateslot

Definition at line 1533 of file kis_paintop_box.cc.

                                                         {
    m_resourceProvider->setMirrorHorizontalLock(toggleLock);
}

References m_resourceProvider, and KisCanvasResourceProvider::setMirrorHorizontalLock().

◆ slotLockYMirrorToggle

void KisPaintopBox::slotLockYMirrorToggle ( bool toggleLock )

privateslot

Definition at line 1537 of file kis_paintop_box.cc.

                                                         {
    m_resourceProvider->setMirrorVerticalLock(toggleLock);
}

References m_resourceProvider, and KisCanvasResourceProvider::setMirrorVerticalLock().

◆ slotMoveToCenterMirrorX

void KisPaintopBox::slotMoveToCenterMirrorX ( )

privateslot

Definition at line 1549 of file kis_paintop_box.cc.

                                            {
    m_resourceProvider->mirrorHorizontalMoveCanvasToCenter();
}

References m_resourceProvider, and KisCanvasResourceProvider::mirrorHorizontalMoveCanvasToCenter().

◆ slotMoveToCenterMirrorY

void KisPaintopBox::slotMoveToCenterMirrorY ( )

privateslot

Definition at line 1553 of file kis_paintop_box.cc.

                                            {
    m_resourceProvider->mirrorVerticalMoveCanvasToCenter();
}

References m_resourceProvider, and KisCanvasResourceProvider::mirrorVerticalMoveCanvasToCenter().

◆ slotNextFavoritePreset

void KisPaintopBox::slotNextFavoritePreset ( )

privateslot

Definition at line 1347 of file kis_paintop_box.cc.

{
    if (!m_favoriteResourceManager) return;
 
    QVector<QString> presets = m_favoriteResourceManager->favoritePresetNamesList();
    for(int i = 0; i < presets.size(); ++i) {
        if (m_resourceProvider->currentPreset()->name() == presets[i]) {
            if (i < m_favoriteResourceManager->numFavoritePresets() - 1) {
                m_favoriteResourceManager->slotChangeActivePaintop(i + 1);
            } else {
                m_favoriteResourceManager->slotChangeActivePaintop(0);
            }
            m_viewManager->showFloatingMessage(
                        i18n("%1\nselected",
                             m_resourceProvider->currentPreset()->name()),
                        QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
 
            return;
        }
    }
}

References KisCanvasResourceProvider::currentPreset(), KisFavoriteResourceManager::favoritePresetNamesList(), m_favoriteResourceManager, m_resourceProvider, m_viewManager, KisViewManager::showFloatingMessage(), and KisFavoriteResourceManager::slotChangeActivePaintop().

◆ slotNodeChanged

void KisPaintopBox::slotNodeChanged ( const KisNodeSP node )

privateslot

Definition at line 1101 of file kis_paintop_box.cc.

{
    KisNodeSP previousNode(m_currentNode);
    if (previousNode && previousNode->paintDevice())
        disconnect(previousNode->paintDevice().data(), SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(slotColorSpaceChanged(const KoColorSpace*)));
 
    // Reconnect colorspace change of node
    if (node && node->paintDevice()) {
        connect(node->paintDevice().data(), SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(slotColorSpaceChanged(const KoColorSpace*)));
        m_resourceProvider->setCurrentCompositeOp(m_currCompositeOpID);
        m_currentNode = node;
        slotColorSpaceChanged(node->paintDevice()->colorSpace());
    }
 
    if (m_optionWidget) {
        m_optionWidget->setNode(node);
    }
}

References KisPaintDevice::colorSpace(), connect(), KisSharedPtr< T >::data(), m_currCompositeOpID, m_currentNode, m_optionWidget, m_resourceProvider, KisBaseNode::paintDevice(), KisCanvasResourceProvider::setCurrentCompositeOp(), KisPaintOpConfigWidget::setNode(), and slotColorSpaceChanged().

◆ slotPreviousFavoritePreset

void KisPaintopBox::slotPreviousFavoritePreset ( )

privateslot

Definition at line 1321 of file kis_paintop_box.cc.

{
    if (!m_favoriteResourceManager) return;
 
    QVector<QString> presets = m_favoriteResourceManager->favoritePresetNamesList();
    for (int i=0; i < presets.size(); ++i) {
        if (m_resourceProvider->currentPreset() &&
                m_resourceProvider->currentPreset()->name() == presets[i]) {
            if (i > 0) {
                m_favoriteResourceManager->slotChangeActivePaintop(i - 1);
            } else {
                m_favoriteResourceManager->slotChangeActivePaintop(m_favoriteResourceManager->numFavoritePresets() - 1);
            }
            //floating message should have least 2 lines, otherwise
            //preset thumbnail will be too small to distinguish
            //(because size of image on floating message depends on amount of lines in msg)
            m_viewManager->showFloatingMessage(
                        i18n("%1\nselected",
                             m_resourceProvider->currentPreset()->name()),
                        QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
 
            return;
        }
    }
}

References KisCanvasResourceProvider::currentPreset(), KisFavoriteResourceManager::favoritePresetNamesList(), m_favoriteResourceManager, m_resourceProvider, m_viewManager, KisFavoriteResourceManager::numFavoritePresets(), KisViewManager::showFloatingMessage(), and KisFavoriteResourceManager::slotChangeActivePaintop().

◆ slotReloadPreset

void KisPaintopBox::slotReloadPreset ( )

privateslot

Definition at line 1406 of file kis_paintop_box.cc.

{
    KisSignalsBlocker blocker(m_optionWidget);
 
    KisPaintOpPresetResourceServer *rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
    QSharedPointer<KisPaintOpPreset> preset = m_resourceProvider->currentPreset();
 
    // Presets that just have been created cannot be reloaded.
    if (preset && preset->resourceId() > -1) {
        const bool result = rserver->reloadResource(preset);
        KIS_SAFE_ASSERT_RECOVER_NOOP(result && "couldn't reload preset");
    }
}

References KisCanvasResourceProvider::currentPreset(), KisResourceServerProvider::instance(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_optionWidget, m_resourceProvider, KisResourceServerProvider::paintOpPresetServer(), and KoResourceServer< T >::reloadResource().

◆ slotSaveLockedOptionToPreset

void KisPaintopBox::slotSaveLockedOptionToPreset ( KisPropertiesConfigurationSP p )

privateslot

explicitly mark the preset as dirty since the properties might have the same values (updated before)

Definition at line 1447 of file kis_paintop_box.cc.

{
    KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
    KisPaintOpPreset::UpdatedPostponer postponer(preset);
 
 
    QMapIterator<QString, QVariant> i(p->getProperties());
    while (i.hasNext()) {
        i.next();
 
        preset->settings()->setProperty(i.key(), QVariant(i.value()));
        if (preset->settings()->hasProperty(i.key() + "_previous")) {
            preset->settings()->removeProperty(i.key() + "_previous");
        }
 
    }
 
    preset->setDirty(true);
}

References KisCanvasResourceProvider::currentPreset(), m_resourceProvider, and p.

◆ slotSelectBrushPreset

void KisPaintopBox::slotSelectBrushPreset ( )

slot

Definition at line 983 of file kis_paintop_box.cc.

{
    // automatically select freehand brush tool for these select actions
    KoToolManager::instance()->switchToolRequested("KritaShape/KisToolBrush");
 
    KoInputDevice::InputDevice dev = KoInputDevice::InputDevice::Unknown;
    KoInputDevice::Pointer ptr = KoInputDevice::Pointer::Pen;
    qint64 id = -1;
    const KoInputDevice inputDevice(dev, ptr, id);
    slotInputDeviceChanged(inputDevice);
}

References KoToolManager::instance(), KoInputDevice::Pen, slotInputDeviceChanged(), KoToolManager::switchToolRequested(), and KoInputDevice::Unknown.

◆ slotSelectEraserPreset

void KisPaintopBox::slotSelectEraserPreset ( )

slot

Definition at line 970 of file kis_paintop_box.cc.

{
    // automatically select freehand brush tool for these select actions
    KoToolManager::instance()->switchToolRequested("KritaShape/KisToolBrush");
 
    KoInputDevice::InputDevice dev = KoInputDevice::InputDevice::Unknown;
    KoInputDevice::Pointer ptr = KoInputDevice::Pointer::Eraser;
    qint64 id = -1;
    const KoInputDevice inputDevice(dev, ptr, id);
    slotInputDeviceChanged(inputDevice);
}

References KoInputDevice::Eraser, KoToolManager::instance(), slotInputDeviceChanged(), KoToolManager::switchToolRequested(), and KoInputDevice::Unknown.

◆ slotSetCompositeMode

void KisPaintopBox::slotSetCompositeMode ( int index )

privateslot

Definition at line 1184 of file kis_paintop_box.cc.

{
    Q_UNUSED(index);
    QString compositeOp = m_cmbCompositeOp->selectedCompositeOp().id();
    m_resourceProvider->setCurrentCompositeOp(compositeOp);
}

References KoID::id(), m_cmbCompositeOp, m_resourceProvider, KisCompositeOpComboBox::selectedCompositeOp(), and KisCanvasResourceProvider::setCurrentCompositeOp().

◆ slotSetPaintop

void KisPaintopBox::slotSetPaintop ( const QString & paintOpId )

privateslot

Definition at line 903 of file kis_paintop_box.cc.

{
    if (KisPaintOpRegistry::instance()->get(paintOpId) != 0) {
        KoID id(paintOpId, KisPaintOpRegistry::instance()->get(paintOpId)->name());
        //qDebug() << "slotsetpaintop" << id;
        setCurrentPaintop(id);
    }
}

References get(), KisPaintOpRegistry::instance(), and setCurrentPaintop().

◆ slotSetupDefaultPreset

void KisPaintopBox::slotSetupDefaultPreset ( )

privateslot

Definition at line 1089 of file kis_paintop_box.cc.

{
    KisPaintOpPresetSP preset = defaultPreset(m_resourceProvider->currentPreset()->paintOp());
 
    m_presetsEditor->readOptionSetting(preset->settings());
    m_resourceProvider->setPaintOpPreset(preset);
 
    // tell the brush editor that the resource has changed
    // so it can update everything
    m_presetsEditor->resourceSelected(preset);
}

References KisCanvasResourceProvider::currentPreset(), defaultPreset(), m_presetsEditor, m_resourceProvider, KisPaintOpPresetsEditor::readOptionSetting(), KisPaintOpPresetsEditor::resourceSelected(), and KisCanvasResourceProvider::setPaintOpPreset().

◆ slotSlider1Changed

void KisPaintopBox::slotSlider1Changed ( )

privateslot

Definition at line 1247 of file kis_paintop_box.cc.

{
    sliderChanged(0);
}

References sliderChanged().

◆ slotSlider2Changed

void KisPaintopBox::slotSlider2Changed ( )

privateslot

Definition at line 1252 of file kis_paintop_box.cc.

{
    sliderChanged(1);
}

References sliderChanged().

◆ slotSlider3Changed

void KisPaintopBox::slotSlider3Changed ( )

privateslot

Definition at line 1257 of file kis_paintop_box.cc.

{
    sliderChanged(2);
}

References sliderChanged().

◆ slotSlider4Changed

void KisPaintopBox::slotSlider4Changed ( )

privateslot

Definition at line 1262 of file kis_paintop_box.cc.

{
    sliderChanged(3);
}

References sliderChanged().

◆ slotSlider5Changed

void KisPaintopBox::slotSlider5Changed ( )

privateslot

Definition at line 1267 of file kis_paintop_box.cc.

{
    sliderChanged(4);
}

References sliderChanged().

◆ slotSwitchToPreviousPreset

void KisPaintopBox::slotSwitchToPreviousPreset ( )

privateslot

Definition at line 1369 of file kis_paintop_box.cc.

{
    if (m_resourceProvider->previousPreset()) {
        setCurrentPaintop(m_resourceProvider->previousPreset());
        m_viewManager->showFloatingMessage(
                    i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
                    QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
    }
}

References KisCanvasResourceProvider::currentPreset(), m_resourceProvider, m_viewManager, KisCanvasResourceProvider::previousPreset(), setCurrentPaintop(), and KisViewManager::showFloatingMessage().

◆ slotToggleAlphaLockMode

void KisPaintopBox::slotToggleAlphaLockMode ( bool checked )

privateslot

Definition at line 1385 of file kis_paintop_box.cc.

{
    if (checked) {
        m_alphaLockButton->actions()[0]->setIcon(KisIconUtils::loadIcon("bar-transparency-locked"));
    } else {
        m_alphaLockButton->actions()[0]->setIcon(KisIconUtils::loadIcon("bar-transparency-unlocked"));
    }
    m_resourceProvider->setGlobalAlphaLock(checked);
}

References KisIconUtils::loadIcon(), m_alphaLockButton, m_resourceProvider, and KisCanvasResourceProvider::setGlobalAlphaLock().

◆ slotToggleEraseMode

void KisPaintopBox::slotToggleEraseMode ( bool checked )

privateslot

Definition at line 1133 of file kis_paintop_box.cc.

{
    const bool oldEraserMode = m_resourceProvider->eraserMode();
    m_resourceProvider->setEraserMode(checked);
 
    if (oldEraserMode != checked && m_eraserBrushSizeEnabled) {
        const qreal currentSize = m_resourceProvider->size();
 
        KisPaintOpSettingsSP settings = m_resourceProvider->currentPreset()->settings();
 
        // remember brush size. set the eraser size to the normal brush size if not set
        if (checked) {
            settings->setSavedBrushSize(currentSize);
            if (qFuzzyIsNull(settings->savedEraserSize())) {
                settings->setSavedEraserSize(currentSize);
            }
        } else {
            settings->setSavedEraserSize(currentSize);
            if (qFuzzyIsNull(settings->savedBrushSize())) {
                settings->setSavedBrushSize(currentSize);
            }
        }
 
        //update value in UI (this is the main place the value is 'stored' in memory)
        qreal newSize = checked ? settings->savedEraserSize() : settings->savedBrushSize();
        m_resourceProvider->setSize(newSize);
    }
    if (oldEraserMode != checked && m_eraserBrushOpacityEnabled) {
        const qreal currentOpacity = m_resourceProvider->opacity();
 
        KisPaintOpSettingsSP settings = m_resourceProvider->currentPreset()->settings();
 
        // remember brush opacity. set the eraser opacity to the normal brush opacity if not set
        if (checked) {
            settings->setSavedBrushOpacity(currentOpacity);
            if (qFuzzyIsNull(settings->savedEraserOpacity())) {
                settings->setSavedEraserOpacity(currentOpacity);
            }
        } else {
            settings->setSavedEraserOpacity(currentOpacity);
            if (qFuzzyIsNull(settings->savedBrushOpacity())) {
                settings->setSavedBrushOpacity(currentOpacity);
            }
        }
 
        //update value in UI (this is the main place the value is 'stored' in memory)
        qreal newOpacity = checked ? settings->savedEraserOpacity() : settings->savedBrushOpacity();
        m_resourceProvider->setOpacity(newOpacity);
    }
}

References KisCanvasResourceProvider::currentPreset(), KisCanvasResourceProvider::eraserMode(), m_eraserBrushOpacityEnabled, m_eraserBrushSizeEnabled, m_resourceProvider, KisCanvasResourceProvider::opacity(), qFuzzyIsNull(), KisCanvasResourceProvider::setEraserMode(), KisCanvasResourceProvider::setOpacity(), KisCanvasResourceProvider::setSize(), and KisCanvasResourceProvider::size().

◆ slotToggleEraserPreset

void KisPaintopBox::slotToggleEraserPreset ( bool usingEraser )

slot

Definition at line 961 of file kis_paintop_box.cc.

{
    KoInputDevice::InputDevice dev = KoInputDevice::InputDevice::Unknown;
    KoInputDevice::Pointer ptr = usingEraser ? KoInputDevice::Pointer::Eraser : KoInputDevice::Pointer::Pen;
    qint64 id = -1;
    const KoInputDevice inputDevice(dev, ptr, id);
    slotInputDeviceChanged(inputDevice);
}

References KoInputDevice::Eraser, KoInputDevice::Pen, slotInputDeviceChanged(), and KoInputDevice::Unknown.

◆ slotToolChanged

void KisPaintopBox::slotToolChanged ( KoCanvasController * canvas )

privateslot

Definition at line 1272 of file kis_paintop_box.cc.

{
    Q_UNUSED(canvas);
 
    if (!m_viewManager->canvasBase()) return;
 
    QString  id   = KoToolManager::instance()->activeToolId();
    KisTool* tool = dynamic_cast<KisTool*>(KoToolManager::instance()->toolById(m_viewManager->canvasBase(), id));
 
    setSliderValue("opacity", m_resourceProvider->opacity());
 
    if (tool) {
        int flags = tool->flags();
 
        if (flags & KisTool::FLAG_USES_CUSTOM_PRESET) {
            if (!m_resourceProvider->currentPreset()) return;
 
            // block updates of avoid some over updating of the option widget
            m_blockUpdate = true;
 
            setSliderValue("size", m_resourceProvider->size());
            setAngleSliderValue("rotation", m_resourceProvider->brushRotation());
 
            {
                setSliderValue("flow", m_resourceProvider->currentPreset()->settings()->paintOpFlow());
            }
 
            {
                setMultiplierSliderValue("patternsize", m_resourceProvider->currentPreset()->settings()->paintOpPatternSize());
            }
 
            // MyPaint brushes don't support custom blend modes, they always perform "Normal and Erase" blending.
            if (m_resourceProvider->currentPreset()->paintOp().id() == "mypaintbrush") {
                if (m_resourceProvider->currentCompositeOp() != COMPOSITE_ERASE && m_resourceProvider->currentCompositeOp() != COMPOSITE_OVER) {
                    updateCompositeOp(COMPOSITE_OVER);
                }
            } else {
                updateCompositeOp(m_resourceProvider->currentPreset()->settings()->paintOpCompositeOp());
            }
 
            m_blockUpdate = false;
 
            m_presetsEnabled = true;
        } else {
            m_presetsEnabled = false;
        }
    }
}

References KoToolManager::activeToolId(), KisCanvasResourceProvider::brushRotation(), KisViewManager::canvasBase(), COMPOSITE_ERASE, COMPOSITE_OVER, KisCanvasResourceProvider::currentCompositeOp(), KisCanvasResourceProvider::currentPreset(), KisTool::FLAG_USES_CUSTOM_PRESET, KisTool::flags(), KoToolManager::instance(), m_blockUpdate, m_presetsEnabled, m_resourceProvider, m_viewManager, KisCanvasResourceProvider::opacity(), setAngleSliderValue(), setMultiplierSliderValue(), setSliderValue(), KisCanvasResourceProvider::size(), KoToolManager::toolById(), and updateCompositeOp().

◆ slotUnsetEraseMode

void KisPaintopBox::slotUnsetEraseMode ( )

privateslot

Definition at line 1380 of file kis_paintop_box.cc.

{
    m_eraseAction->setChecked(false);
}

References m_eraseAction.

◆ slotUpdateOptionsWidgetPopup

void KisPaintopBox::slotUpdateOptionsWidgetPopup ( )

privateslot

Definition at line 750 of file kis_paintop_box.cc.

{
    KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
    // This happens when we have a new brush engine for which no default preset exists yet.
    if (!preset) return;
 
    // the connection to the preset is maintained even when the editor
    // is hidden, so skip the updates
    if (!m_presetsEditor->isVisible()) return;
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(preset);
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_optionWidget);
 
    m_presetsEditor->readOptionSetting(preset->settings());
    m_presetsEditor->resourceSelected(preset);
    m_presetsEditor->updateViewSettings();
 
    // the m_viewManager->image() is set earlier, but the reference will be missing when the stamp button is pressed
    // need to later do some research on how and when we should be using weak shared pointers (WSP) that creates this situation
    m_optionWidget->setImage(m_viewManager->image());
}

References KisCanvasResourceProvider::currentPreset(), KisViewManager::image(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_optionWidget, m_presetsEditor, m_resourceProvider, m_viewManager, KisPaintOpPresetsEditor::readOptionSetting(), KisPaintOpPresetsEditor::resourceSelected(), KisPaintOpConfigWidget::setImage(), and KisPaintOpPresetsEditor::updateViewSettings().

◆ slotUpdateSelectionIcon

void KisPaintopBox::slotUpdateSelectionIcon ( )

privateslot

Definition at line 1515 of file kis_paintop_box.cc.

{
    KisConfig cfg(true);
    if (!cfg.toolOptionsInDocker() && m_toolOptionsPopupButton) {
        m_toolOptionsPopupButton->setIcon(KisIconUtils::loadIcon("configure"));
    }
 
    m_presetSelectorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_01"));
    m_brushEditorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_02"));
    m_workspaceWidget->setIcon(KisIconUtils::loadIcon("workspace-chooser"));
 
    if (m_disablePressureAction->isChecked()) {
        m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
    } else {
        m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure_locked"));
    }
}

References KisIconUtils::loadIcon(), m_brushEditorPopupButton, m_disablePressureAction, m_presetSelectorPopupButton, m_toolOptionsPopupButton, m_workspaceWidget, and KisConfig::toolOptionsInDocker().

◆ slotVerticalMirrorChanged

void KisPaintopBox::slotVerticalMirrorChanged ( bool value )

privateslot

Definition at line 1196 of file kis_paintop_box.cc.

{
    m_resourceProvider->setMirrorVertical(value);
}

References m_resourceProvider, KisCanvasResourceProvider::setMirrorVertical(), and value().

◆ togglePresetEditor

void KisPaintopBox::togglePresetEditor ( )

privateslot

Definition at line 773 of file kis_paintop_box.cc.

{
    if (m_brushEditorPopupButton->isPopupWidgetVisible()) {
        m_brushEditorPopupButton->hidePopupWidget();
    } else {
        m_brushEditorPopupButton->showPopupWidget();
    }
}

References KisPopupButton::hidePopupWidget(), KisPopupButton::isPopupWidgetVisible(), m_brushEditorPopupButton, and KisPopupButton::showPopupWidget().

◆ updateCompositeOp()

void KisPaintopBox::updateCompositeOp ( QString compositeOpID )

private

Definition at line 837 of file kis_paintop_box.cc.

{
    if (!m_optionWidget) return;
    KisSignalsBlocker blocker(m_optionWidget);
 
    KisNodeSP node = m_resourceProvider->currentNode();
 
    if (node && node->paintDevice()) {
        if (!node->paintDevice()->compositionSourceColorSpace()->hasCompositeOp(compositeOpID)) {
            compositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
        }
    }
 
    {
        KisSignalsBlocker b1(m_cmbCompositeOp, m_eraseModeButton);
        m_cmbCompositeOp->selectCompositeOp(KoID(compositeOpID));
        m_eraseModeButton->setChecked(compositeOpID == COMPOSITE_ERASE || m_resourceProvider->eraserMode());
    }
    m_currCompositeOpID = compositeOpID;
}

References COMPOSITE_ERASE, KisPaintDevice::compositionSourceColorSpace(), KisCanvasResourceProvider::currentNode(), KisCanvasResourceProvider::eraserMode(), KoCompositeOpRegistry::getDefaultCompositeOp(), KoColorSpace::hasCompositeOp(), KoID::id(), KoCompositeOpRegistry::instance(), m_cmbCompositeOp, m_currCompositeOpID, m_eraseModeButton, m_optionWidget, m_resourceProvider, KisBaseNode::paintDevice(), and KisCompositeOpComboBox::selectCompositeOp().

◆ updatePresetConfig

void KisPaintopBox::updatePresetConfig ( )

privateslot

Definition at line 1563 of file kis_paintop_box.cc.

{
    KisConfig cfg(false);
    QMapIterator<TabletToolID, TabletToolData> iter(m_tabletToolMap);
    while (iter.hasNext()) {
        iter.next();
        if ((iter.key().pointer) == KoInputDevice::Pointer::Eraser) {
            cfg.writeEntry(QString("LastEraser_%1").arg(iter.key().uniqueTabletId),
                           iter.value().preset->name());
        }
        else {
            cfg.writeEntry(QString("LastPreset_%1").arg(iter.key().uniqueTabletId),
                           iter.value().preset->name());
        }
    }
}

References KoInputDevice::Eraser, m_tabletToolMap, and KisConfig::writeEntry().

Member Data Documentation

◆ hideCanvasDecorationsX

KisAction* KisPaintopBox::hideCanvasDecorationsX {0}

private

Definition at line 223 of file kis_paintop_box.h.

223{0};

◆ hideCanvasDecorationsY

KisAction* KisPaintopBox::hideCanvasDecorationsY {0}

private

Definition at line 226 of file kis_paintop_box.h.

226{0};

◆ lockActionX

KisAction* KisPaintopBox::lockActionX {0}

private

Definition at line 224 of file kis_paintop_box.h.

224{0};

◆ lockActionY

KisAction* KisPaintopBox::lockActionY {0}

private

Definition at line 227 of file kis_paintop_box.h.

227{0};

◆ m_alphaLockButton

QToolButton* KisPaintopBox::m_alphaLockButton {0}

private

Definition at line 194 of file kis_paintop_box.h.

194{0};

◆ m_blockUpdate

bool KisPaintopBox::m_blockUpdate {false}

private

Definition at line 265 of file kis_paintop_box.h.

265{false};

◆ m_brushEditorPopupButton

KisIconWidget* KisPaintopBox::m_brushEditorPopupButton {0}

private

Definition at line 190 of file kis_paintop_box.h.

190{0};

◆ m_brushSelectPresetAction

KisAction* KisPaintopBox::m_brushSelectPresetAction {0}

private

Definition at line 210 of file kis_paintop_box.h.

210{0};

◆ m_cmbCompositeOp

KisCompositeOpComboBox* KisPaintopBox::m_cmbCompositeOp {0}

private

Definition at line 192 of file kis_paintop_box.h.

192{0};

◆ m_currCompositeOpID

QString KisPaintopBox::m_currCompositeOpID

private

Definition at line 214 of file kis_paintop_box.h.

◆ m_currentNode

KisNodeWSP KisPaintopBox::m_currentNode

private

Definition at line 215 of file kis_paintop_box.h.

◆ m_currTabletToolID

TabletToolID KisPaintopBox::m_currTabletToolID {KoInputDevice::invalid()}

private

Definition at line 263 of file kis_paintop_box.h.

263{KoInputDevice::invalid()};

KoInputDevice::invalid

static KoInputDevice invalid()

invalid input device

Definition KoInputDevice.cpp:86

◆ m_defaultPresetName

QString KisPaintopBox::m_defaultPresetName

private

Definition at line 275 of file kis_paintop_box.h.

◆ m_dirtyPresetsEnabled

bool KisPaintopBox::m_dirtyPresetsEnabled {false}

private

Definition at line 266 of file kis_paintop_box.h.

266{false};

◆ m_disablePressureAction

KisAction* KisPaintopBox::m_disablePressureAction {0}

private

Definition at line 212 of file kis_paintop_box.h.

212{0};

◆ m_eraseAction

KisAction* KisPaintopBox::m_eraseAction {0}

private

Definition at line 207 of file kis_paintop_box.h.

207{0};

◆ m_eraseModeButton

QToolButton* KisPaintopBox::m_eraseModeButton {0}

private

Definition at line 193 of file kis_paintop_box.h.

193{0};

◆ m_eraserBrushOpacityEnabled

bool KisPaintopBox::m_eraserBrushOpacityEnabled {false}

private

Definition at line 268 of file kis_paintop_box.h.

268{false};

◆ m_eraserBrushSizeEnabled

bool KisPaintopBox::m_eraserBrushSizeEnabled {false}

private

Definition at line 267 of file kis_paintop_box.h.

267{false};

◆ m_eraserName

QString KisPaintopBox::m_eraserName

private

Definition at line 274 of file kis_paintop_box.h.

◆ m_eraserSelectPresetAction

KisAction* KisPaintopBox::m_eraserSelectPresetAction {0}

private

Definition at line 209 of file kis_paintop_box.h.

209{0};

◆ m_eraserTogglePresetAction

KisAction* KisPaintopBox::m_eraserTogglePresetAction {0}

private

Definition at line 208 of file kis_paintop_box.h.

208{0};

◆ m_favoriteResourceManager

KisFavoriteResourceManager* KisPaintopBox::m_favoriteResourceManager {0}

private

Definition at line 205 of file kis_paintop_box.h.

205{0};

◆ m_hMirrorAction

KisAction* KisPaintopBox::m_hMirrorAction {0}

private

Definition at line 220 of file kis_paintop_box.h.

220{0};

◆ m_hMirrorButton

QToolButton* KisPaintopBox::m_hMirrorButton {0}

private

Definition at line 195 of file kis_paintop_box.h.

195{0};

◆ m_layout

QHBoxLayout* KisPaintopBox::m_layout {0}

private

Definition at line 184 of file kis_paintop_box.h.

184{0};

◆ m_optionsWidgetConnections

QScopedPointer<KisAcyclicSignalConnector> KisPaintopBox::m_optionsWidgetConnections

private

Definition at line 271 of file kis_paintop_box.h.

◆ m_optionWidget

KisPaintOpConfigWidget* KisPaintopBox::m_optionWidget {0}

private

Definition at line 186 of file kis_paintop_box.h.

186{0};

◆ m_optionWidgetUpdateCompressor

KisSignalCompressor KisPaintopBox::m_optionWidgetUpdateCompressor

private

Definition at line 272 of file kis_paintop_box.h.

◆ m_paintopOptionWidgets

QMap<KoID, KisPaintOpConfigWidget*> KisPaintopBox::m_paintopOptionWidgets

private

Definition at line 204 of file kis_paintop_box.h.

◆ m_paintOpPresetMap

PaintOpPresetMap KisPaintopBox::m_paintOpPresetMap

private

Definition at line 262 of file kis_paintop_box.h.

◆ m_paintopWidget

QWidget* KisPaintopBox::m_paintopWidget {0}

private

Definition at line 185 of file kis_paintop_box.h.

185{0};

◆ m_presetConnections

KisSignalAutoConnectionsStore KisPaintopBox::m_presetConnections

private

Definition at line 270 of file kis_paintop_box.h.

◆ m_presetsChooserPopup

KisPaintOpPresetsChooserPopup* KisPaintopBox::m_presetsChooserPopup {0}

private

Definition at line 200 of file kis_paintop_box.h.

200{0};

◆ m_presetsEditor

KisPaintOpPresetsEditor* KisPaintopBox::m_presetsEditor {0}

private

Definition at line 199 of file kis_paintop_box.h.

199{0};

◆ m_presetSelectorPopupButton

KisIconWidget* KisPaintopBox::m_presetSelectorPopupButton {0}

private

Definition at line 191 of file kis_paintop_box.h.

191{0};

◆ m_presetsEnabled

bool KisPaintopBox::m_presetsEnabled {true}

private

Definition at line 264 of file kis_paintop_box.h.

264{true};

◆ m_reloadAction

KisAction* KisPaintopBox::m_reloadAction {0}

private

Definition at line 211 of file kis_paintop_box.h.

211{0};

◆ m_reloadButton

QToolButton* KisPaintopBox::m_reloadButton {0}

private

Definition at line 206 of file kis_paintop_box.h.

206{0};

◆ m_resourceProvider

KisCanvasResourceProvider* KisPaintopBox::m_resourceProvider {0}

private

Definition at line 183 of file kis_paintop_box.h.

183{0};

◆ m_savePresetWidget

KisPresetSaveWidget* KisPaintopBox::m_savePresetWidget {0}

private

Definition at line 189 of file kis_paintop_box.h.

189{0};

◆ m_sliderChooser

KisWidgetChooser* KisPaintopBox::m_sliderChooser[5]

private

Definition at line 203 of file kis_paintop_box.h.

◆ m_tabletToolMap

TabletToolMap KisPaintopBox::m_tabletToolMap

private

Definition at line 261 of file kis_paintop_box.h.

◆ m_toolOptionsPopup

KisToolOptionsPopup* KisPaintopBox::m_toolOptionsPopup {0}

private

Definition at line 198 of file kis_paintop_box.h.

198{0};

◆ m_toolOptionsPopupButton

KisPopupButton* KisPaintopBox::m_toolOptionsPopupButton {0}

private

Definition at line 187 of file kis_paintop_box.h.

187{0};

◆ m_viewManager

KisViewManager* KisPaintopBox::m_viewManager {0}

private

Definition at line 201 of file kis_paintop_box.h.

201{0};

◆ m_vMirrorAction

KisAction* KisPaintopBox::m_vMirrorAction {0}

private

Definition at line 221 of file kis_paintop_box.h.

221{0};

◆ m_vMirrorButton

QToolButton* KisPaintopBox::m_vMirrorButton {0}

private

Definition at line 196 of file kis_paintop_box.h.

196{0};

◆ m_workspaceWidget

KisPopupButton* KisPaintopBox::m_workspaceWidget {0}

private

Definition at line 202 of file kis_paintop_box.h.

202{0};

◆ m_wrapAroundButton

QToolButton* KisPaintopBox::m_wrapAroundButton {0}

private

Definition at line 197 of file kis_paintop_box.h.

197{0};

◆ moveToCenterActionX

KisAction* KisPaintopBox::moveToCenterActionX {0}

private

Definition at line 225 of file kis_paintop_box.h.

225{0};

◆ moveToCenterActionY

KisAction* KisPaintopBox::moveToCenterActionY {0}

private

Definition at line 228 of file kis_paintop_box.h.

228{0};

◆ toolbarMenuXMirror

QMenu* KisPaintopBox::toolbarMenuXMirror {nullptr}

private

Definition at line 217 of file kis_paintop_box.h.

217{nullptr};

◆ toolbarMenuYMirror

QMenu* KisPaintopBox::toolbarMenuYMirror {nullptr}

private

Definition at line 218 of file kis_paintop_box.h.

218{nullptr};

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

libs/ui/kis_paintop_box.h
libs/ui/kis_paintop_box.cc

Classes

Public Slots

Public Member Functions

Private Types

Private Slots

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ PaintOpPresetMap

◆ TabletToolMap

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ KisPaintopBox()

◆ ~KisPaintopBox()

Member Function Documentation

◆ activePreset()

◆ defaultPreset()

◆ favoriteResourcesManager()

◆ findDefaultPresets()

◆ newOptionWidgets()

◆ resourceSelected

◆ restoreResource()

◆ setAngleSliderValue()

◆ setCurrentPaintop() [1/2]

◆ setCurrentPaintop() [2/2]

◆ setMultiplierSliderValue()

◆ setSliderValue()

◆ setWidgetState()

◆ sliderChanged()

◆ slotCanvasResourceChangeAttempted

◆ slotCanvasResourceChanged

◆ slotColorSpaceChanged

◆ slotCreatePresetFromScratch

◆ slotDirtyPresetToggled

◆ slotDisablePressureMode

◆ slotDropLockedOption

◆ slotEraserBrushOpacityToggled

◆ slotEraserBrushSizeToggled

◆ slotGuiChangedCurrentPreset

◆ slotHideDecorationMirrorX

◆ slotHideDecorationMirrorY

◆ slotHorizontalMirrorChanged

◆ slotInputDeviceChanged

◆ slotLockXMirrorToggle

◆ slotLockYMirrorToggle

◆ slotMoveToCenterMirrorX

◆ slotMoveToCenterMirrorY

◆ slotNextFavoritePreset

◆ slotNodeChanged

◆ slotPreviousFavoritePreset

◆ slotReloadPreset

◆ slotSaveLockedOptionToPreset

◆ slotSelectBrushPreset

◆ slotSelectEraserPreset

◆ slotSetCompositeMode

◆ slotSetPaintop

◆ slotSetupDefaultPreset

◆ slotSlider1Changed

◆ slotSlider2Changed

◆ slotSlider3Changed

◆ slotSlider4Changed

◆ slotSlider5Changed

◆ slotSwitchToPreviousPreset

◆ slotToggleAlphaLockMode

◆ slotToggleEraseMode

◆ slotToggleEraserPreset

◆ slotToolChanged

◆ slotUnsetEraseMode

◆ slotUpdateOptionsWidgetPopup

◆ slotUpdateSelectionIcon

◆ slotVerticalMirrorChanged

◆ togglePresetEditor

◆ updateCompositeOp()

◆ updatePresetConfig

Member Data Documentation

◆ hideCanvasDecorationsX

◆ hideCanvasDecorationsY

◆ lockActionX