KisPaintOpPresetsEditor Class Reference

#include <kis_paintop_presets_editor.h>

Inheritance diagram for KisPaintOpPresetsEditor:

Classes
struct	Private

Public Slots
void	resourceSelected (KoResourceSP resource)
void	slotCreateNewBrushPresetEngine ()
void	slotRenameBrushActivated ()
void	slotRenameBrushDeactivated ()
void	slotSaveRenameCurrentBrush ()
void	slotUpdatePresetSettings ()
void	updateThemedIcons ()

Signals
void	brushEditorShown ()
void	createPresetFromScratch (const QString &paintOpName)
void	defaultPresetClicked ()
void	dirtyPresetToggled (bool value)
void	eraserBrushOpacityToggled (bool value)
void	eraserBrushSizeToggled (bool value)
void	paintopActivated (const QString &presetName)
void	reloadPresetClicked ()
void	saveBrushPreset ()
void	savePresetClicked ()
void	signalResourceSelected (KoResourceSP resource)
void	toggleDetachState (bool detach)

Public Member Functions
QString	currentPaintOpId ()
	returns the internal ID for the paint op (brush engine)
void	currentPresetChanged (KisPaintOpPresetSP preset)
QImage	cutOutOverlay ()
	KisPaintOpPresetsEditor (KisCanvasResourceProvider *resourceProvider, KisFavoriteResourceManager *favoriteResourceManager, KisPresetSaveWidget *savePresetWidget, QWidget *parent=0)
void	readOptionSetting (const KisPropertiesConfigurationSP setting)
void	resizeEvent (QResizeEvent *) override
void	setCreatingBrushFromScratch (bool enable)
void	setCurrentPaintOpId (const QString &paintOpId)
void	setPaintOpList (const QList< KisPaintOpFactory * > &list)
void	setPaintOpSettingsWidget (QWidget *widget)
void	updateViewSettings ()
void	writeOptionSetting (KisPropertiesConfigurationSP setting) const
	~KisPaintOpPresetsEditor () override

Public Attributes
KisPresetSaveWidget *	saveDialog

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

Private Slots
void	slotBlackListCurrentPreset ()
	we do not delete brush presets, but blacklist them so they disappear from the interface
void	slotSaveBrushPreset ()
void	slotSaveNewBrushPreset ()
void	slotSwitchScratchpad (bool visible)
void	slotSwitchShowEditor (bool visible)
void	slotSwitchShowPresets (bool visible)
void	slotToggleDetach (bool detach)
void	slotUpdateEffectiveLodAvailable (bool value)
void	slotUpdatePaintOpFilter ()

Private Member Functions
void	toggleBrushRenameUIActive (bool isRenaming)

Private Attributes
const int	brushPresetsPanelInitWidth = 200
const int	brushPresetsPanelMinWidth = 80
QString	current_paintOpId
Private *const	m_d
QList< QAction * >	newBrushEngineOptions
QMenu *	newPresetBrushEnginesMenu
const int	scratchPadPanelInitWidth = 200
const int	scratchPadPanelMinWidth = 80
QList< KisPaintOpInfo >	sortedBrushEnginesList

Detailed Description

Popup widget for presets with built-in functionality for adding and removing presets.

Definition at line 30 of file kis_paintop_presets_editor.h.

Constructor & Destructor Documentation

KisPaintOpPresetsEditor()

KisPaintOpPresetsEditor::KisPaintOpPresetsEditor	(	KisCanvasResourceProvider *	resourceProvider,
		KisFavoriteResourceManager *	favoriteResourceManager,
		KisPresetSaveWidget *	savePresetWidget,
		QWidget *	parent = 0 )

Definition at line 79 of file kis_paintop_presets_editor.cpp.

    : QWidget(parent)
    , m_d(new Private())
{
    setObjectName("KisPaintOpPresetsEditor");
 
    KisConfig cfg(true);
 
    current_paintOpId = "";
 
    m_d->resourceProvider = resourceProvider;
    m_d->favoriteResManager = favoriteResourceManager;
 
    m_d->uiWdgPaintOpPresetSettings.setupUi(this);
 
    m_d->layout = new QGridLayout(m_d->uiWdgPaintOpPresetSettings.frmOptionWidgetContainer);
 
    m_d->uiWdgPaintOpPresetSettings.scratchPad->setupScratchPad(resourceProvider, Qt::white);
    m_d->uiWdgPaintOpPresetSettings.scratchPad->setCutoutOverlayRect(QRect(25, 25, 200, 200));
 
    m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setToolTip(i18n("The settings for this preset have changed from their default."));
 
    m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setToolTip(i18n("Toggle showing presets"));
 
    m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setToolTip(i18n("Toggle showing scratchpad"));
 
    m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setToolTip(i18n("Reload the brush preset"));
    m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setToolTip(i18n("Rename the brush preset"));
 
 
    // creating a new preset from scratch. Part of the brush presets area
    // the menu options will get filled up later when we are generating all available paintops
    // in the filter drop-down
    newPresetBrushEnginesMenu = new QMenu();
 
    // overwrite existing preset and saving a new preset use the same dialog
    saveDialog = savePresetWidget;
    saveDialog->scratchPadSetup(resourceProvider);
    saveDialog->setFavoriteResourceManager(m_d->favoriteResManager); // this is needed when saving the preset
    saveDialog->hide();
 
    // the area on the brush editor for renaming the brush. make sure edit fields are hidden by default
    toggleBrushRenameUIActive(false);
 
    // Brush Preset Left Panel
    {
        // Container
        QVBoxLayout* containerLayout = dynamic_cast<QVBoxLayout*>(m_d->uiWdgPaintOpPresetSettings.presetsContainer->layout());
        containerLayout->setAlignment(Qt::AlignmentFlag::AlignTop);  // spacers are not required
 
        // Show Panel Button
        m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setCheckable(true);
        m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setChecked(cfg.presetStripVisible());
 
        connect(m_d->uiWdgPaintOpPresetSettings.showPresetsButton, SIGNAL(clicked(bool)), this, SLOT(slotSwitchShowPresets(bool)));
 
        // Brush Engine Filter
        connect(m_d->uiWdgPaintOpPresetSettings.brushEngineComboBox, SIGNAL(currentIndexChanged(int)),
            this, SLOT(slotUpdatePaintOpFilter()));
 
        // Brush Presets
        KisPresetChooser* presetChooser = m_d->uiWdgPaintOpPresetSettings.presetWidget;
        presetChooser->showTaggingBar(true);
 
        // Brush Presets ViewMode Menu
        QMenu* viewModeMenu = new QMenu(this);
        {
            viewModeMenu->setStyleSheet("margin: 6px");
 
            // View Modes Btns
            viewModeMenu->addSection(i18nc("@title Which elements to display (e.g., thumbnails or details)", "Display"));
            KisPresetChooser::ViewMode mode = (KisPresetChooser::ViewMode)cfg.presetChooserViewMode();
            QActionGroup *actionGroup = new QActionGroup(this);
 
            QAction* action = viewModeMenu->addAction(KisIconUtils::loadIcon("view-preview"), i18n("Thumbnails"));
            action->setCheckable(true);
            action->setChecked(mode == KisPresetChooser::THUMBNAIL);
            action->setActionGroup(actionGroup);
 
            connect(action, &QAction::triggered,
                m_d->uiWdgPaintOpPresetSettings.presetWidget, &KisPresetChooser::setViewModeToThumbnail);
 
            action = viewModeMenu->addAction(KisIconUtils::loadIcon("view-list-details"), i18n("Details"));
            action->setCheckable(true);
            action->setChecked(mode == KisPresetChooser::DETAIL);
            action->setActionGroup(actionGroup);
 
            connect(action, &QAction::triggered,
                m_d->uiWdgPaintOpPresetSettings.presetWidget, &KisPresetChooser::setViewModeToDetail);
 
            // Icon Size Slider
            viewModeMenu->addSection(i18n("Icon Size"));
 
            QSlider* iconSizeSlider = new QSlider(this);
            iconSizeSlider->setOrientation(Qt::Horizontal);
            iconSizeSlider->setRange(30, 80);
            iconSizeSlider->setValue(m_d->uiWdgPaintOpPresetSettings.presetWidget->iconSize());
            iconSizeSlider->setMinimumHeight(20);
            iconSizeSlider->setMinimumWidth(40);
            iconSizeSlider->setTickInterval(10);
 
            connect(iconSizeSlider, &QSlider::valueChanged,
                    m_d->uiWdgPaintOpPresetSettings.presetWidget, &KisPresetChooser::setIconSize);
 
            connect(iconSizeSlider, &QSlider::sliderReleased,
                m_d->uiWdgPaintOpPresetSettings.presetWidget, &KisPresetChooser::saveIconSize);
 
            QWidgetAction *sliderAction= new QWidgetAction(this);
            sliderAction->setDefaultWidget(iconSizeSlider);
 
            viewModeMenu->addAction(sliderAction);
        }
 
        KisResourceItemChooser* resourceChooser = presetChooser->itemChooser();
        resourceChooser->viewModeButton()->setPopupWidget(viewModeMenu);
 
        // Bottom Bar Buttons
        m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setPopupMode(QToolButton::InstantPopup);  // loading preset from scratch option
        connect(m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset,SIGNAL(clicked()),
            this, SLOT(slotBlackListCurrentPreset()));  // TODO: add confirm dialog
    }
 
    // show/hide buttons
    m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setCheckable(true);
    m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setChecked(cfg.scratchpadVisible());
 
    QMenu *viewOptionsMenu = new QMenu(this);
    QAction *detachBrushEditorAction = viewOptionsMenu->addAction(i18n("Detach Brush Editor"));
    detachBrushEditorAction->setCheckable(true);
    detachBrushEditorAction->setChecked(cfg.paintopPopupDetached());
    m_d->uiWdgPaintOpPresetSettings.viewOptionButton->setMenu(viewOptionsMenu);
 
    // Connections
    connect(m_d->uiWdgPaintOpPresetSettings.paintPresetIcon, SIGNAL(clicked()),
            m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(paintPresetImage()));
 
    connect(saveDialog, SIGNAL(resourceSelected(KoResourceSP )), this, SLOT(resourceSelected(KoResourceSP )));
 
    connect (m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton, SIGNAL(clicked(bool)),
             this, SLOT(slotRenameBrushActivated()));
 
    connect (m_d->uiWdgPaintOpPresetSettings.cancelBrushNameUpdateButton, SIGNAL(clicked(bool)),
             this, SLOT(slotRenameBrushDeactivated()));
 
    connect(m_d->uiWdgPaintOpPresetSettings.updateBrushNameButton, SIGNAL(clicked(bool)),
            this, SLOT(slotSaveRenameCurrentBrush()));
 
    connect(m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField, SIGNAL(returnPressed()),
            SLOT(slotSaveRenameCurrentBrush()));
 
    connect(m_d->uiWdgPaintOpPresetSettings.showScratchpadButton, SIGNAL(clicked(bool)),
            this, SLOT(slotSwitchScratchpad(bool)));
 
    connect(detachBrushEditorAction, SIGNAL(toggled(bool)),
            this, SLOT(slotToggleDetach(bool)));
 
    connect(m_d->uiWdgPaintOpPresetSettings.eraseScratchPad, SIGNAL(clicked()),
            m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillDefault()));
 
    connect(m_d->uiWdgPaintOpPresetSettings.fillLayer, SIGNAL(clicked()),
            m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillDocument()));
 
    connect(m_d->uiWdgPaintOpPresetSettings.fillGradient, SIGNAL(clicked()),
            m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillGradient()));
 
    connect(m_d->uiWdgPaintOpPresetSettings.fillSolid, SIGNAL(clicked()),
            m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillBackground()));
 
 
    m_d->settingsWidget = 0;
 
    connect(m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton, SIGNAL(clicked()),
            this, SLOT(slotSaveBrushPreset()));
 
    connect(m_d->uiWdgPaintOpPresetSettings.saveNewBrushPresetButton, SIGNAL(clicked()),
            this, SLOT(slotSaveNewBrushPreset()));
 
    connect(m_d->uiWdgPaintOpPresetSettings.reloadPresetButton, SIGNAL(clicked()),
            this, SIGNAL(reloadPresetClicked()));
 
    connect(m_d->uiWdgPaintOpPresetSettings.dirtyPresetCheckBox, SIGNAL(toggled(bool)),
            this, SIGNAL(dirtyPresetToggled(bool)));
 
    connect(m_d->uiWdgPaintOpPresetSettings.eraserBrushSizeCheckBox, SIGNAL(toggled(bool)),
            this, SIGNAL(eraserBrushSizeToggled(bool)));
 
    connect(m_d->uiWdgPaintOpPresetSettings.eraserBrushOpacityCheckBox, SIGNAL(toggled(bool)),
            this, SIGNAL(eraserBrushOpacityToggled(bool)));
 
 
    // preset widget connections
    connect(m_d->uiWdgPaintOpPresetSettings.presetWidget, SIGNAL(resourceSelected(KoResourceSP )),
            this, SIGNAL(signalResourceSelected(KoResourceSP )));
 
    connect(m_d->uiWdgPaintOpPresetSettings.reloadPresetButton, SIGNAL(clicked()),
            m_d->uiWdgPaintOpPresetSettings.presetWidget, SLOT(updateViewSettings()));
 
    connect(m_d->uiWdgPaintOpPresetSettings.reloadPresetButton, SIGNAL(clicked()), SLOT(slotUpdatePresetSettings()));
 
    m_d->ignoreHideEvents = false;
 
    m_d->uiWdgPaintOpPresetSettings.dirtyPresetCheckBox->setChecked(cfg.useDirtyPresets());
    m_d->uiWdgPaintOpPresetSettings.eraserBrushSizeCheckBox->setChecked(cfg.useEraserBrushSize());
    m_d->uiWdgPaintOpPresetSettings.eraserBrushOpacityCheckBox->setChecked(cfg.useEraserBrushOpacity());
 
    connect(m_d->uiWdgPaintOpPresetSettings.brushEngineComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(slotUpdatePaintOpFilter()));
    connect(m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset, SIGNAL(clicked()), this, SLOT(slotBlackListCurrentPreset()));
 
    updateThemedIcons();
 
    // setup things like the scene construct images, layers, etc that is a one-time thing
    m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->setup(resourceProvider->resourceManager());
 
    // Responsive Layout
    m_d->horzSplitter = new QSplitter(this);  // you can't add QSplitter to a UI file
    m_d->horzSplitter->setChildrenCollapsible(false);
 
    m_d->horzSplitter->addWidget(m_d->uiWdgPaintOpPresetSettings.presetsContainer);
    m_d->horzSplitter->setStretchFactor(0, 0);
    m_d->horzSplitter->addWidget(m_d->uiWdgPaintOpPresetSettings.brushEditorSettingsControls);
    m_d->horzSplitter->setStretchFactor(1, 2);
    m_d->horzSplitter->addWidget(m_d->uiWdgPaintOpPresetSettings.scratchpadControls);
    m_d->horzSplitter->setStretchFactor(2, 0);
 
    m_d->uiWdgPaintOpPresetSettings.gridLayout->addWidget(m_d->horzSplitter, 3, 0, 1, 3);
 
    // The side panels' sizeHints must be retrieved while they are visible.
    // The center widget's sizeHint must be retrieved later.
    m_d->defaultSplitterSizes << m_d->horzSplitter->widget(0)->sizeHint().width()
                              << m_d->horzSplitter->widget(1)->sizeHint().width()
                              << m_d->horzSplitter->widget(2)->sizeHint().width();
 
    // Default Configuration
    slotSwitchShowPresets(cfg.presetStripVisible());
    slotSwitchScratchpad(cfg.scratchpadVisible());
}

References connect(), current_paintOpId, KisPaintOpPresetsEditor::Private::defaultSplitterSizes, KisPresetChooser::DETAIL, dirtyPresetToggled(), eraserBrushOpacityToggled(), eraserBrushSizeToggled(), KisPaintOpPresetsEditor::Private::favoriteResManager, KisPaintOpPresetsEditor::Private::horzSplitter, KisPaintOpPresetsEditor::Private::ignoreHideEvents, KisPresetChooser::itemChooser(), KisPaintOpPresetsEditor::Private::layout, KisIconUtils::loadIcon(), m_d, newPresetBrushEnginesMenu, KisConfig::paintopPopupDetached(), KisConfig::presetChooserViewMode(), KisConfig::presetStripVisible(), reloadPresetClicked(), KisCanvasResourceProvider::resourceManager(), KisPaintOpPresetsEditor::Private::resourceProvider, resourceSelected(), saveDialog, KisPresetChooser::saveIconSize(), KisPresetSaveWidget::scratchPadSetup(), KisConfig::scratchpadVisible(), KisPresetSaveWidget::setFavoriteResourceManager(), KisPresetChooser::setIconSize(), KisPopupButton::setPopupWidget(), KisPaintOpPresetsEditor::Private::settingsWidget, KisPresetChooser::setViewModeToDetail(), KisPresetChooser::setViewModeToThumbnail(), KisPresetChooser::showTaggingBar(), signalResourceSelected(), slotBlackListCurrentPreset(), slotRenameBrushActivated(), slotRenameBrushDeactivated(), slotSaveBrushPreset(), slotSaveNewBrushPreset(), slotSaveRenameCurrentBrush(), slotSwitchScratchpad(), slotSwitchShowPresets(), slotToggleDetach(), slotUpdatePaintOpFilter(), slotUpdatePresetSettings(), KisPresetChooser::THUMBNAIL, toggleBrushRenameUIActive(), KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings, updateThemedIcons(), updateViewSettings(), KisConfig::useDirtyPresets(), KisConfig::useEraserBrushOpacity(), KisConfig::useEraserBrushSize(), and KisResourceItemChooser::viewModeButton.

~KisPaintOpPresetsEditor()

KisPaintOpPresetsEditor::~KisPaintOpPresetsEditor ( )

override

Definition at line 410 of file kis_paintop_presets_editor.cpp.

{
    if (m_d->settingsWidget) {
        m_d->layout->removeWidget(m_d->settingsWidget);
        m_d->settingsWidget->hide();
        m_d->settingsWidget->setParent(0);
        m_d->settingsWidget = 0;
    }
    delete m_d;
    delete newPresetBrushEnginesMenu;
}

References KisPaintOpPresetsEditor::Private::layout, m_d, newPresetBrushEnginesMenu, and KisPaintOpPresetsEditor::Private::settingsWidget.

Member Function Documentation

brushEditorShown

void KisPaintOpPresetsEditor::brushEditorShown ( )

signal

contextMenuEvent()

void KisPaintOpPresetsEditor::contextMenuEvent ( QContextMenuEvent * e )

overrideprotected

Definition at line 484 of file kis_paintop_presets_editor.cpp.

{
    Q_UNUSED(e);
}

createPresetFromScratch

void KisPaintOpPresetsEditor::createPresetFromScratch ( const QString & paintOpName )

signal

currentPaintOpId()

QString KisPaintOpPresetsEditor::currentPaintOpId

(

)

returns the internal ID for the paint op (brush engine)

Definition at line 619 of file kis_paintop_presets_editor.cpp.

                                                  {
    return current_paintOpId;
}

References current_paintOpId.

currentPresetChanged()

void KisPaintOpPresetsEditor::currentPresetChanged

(

KisPaintOpPresetSP

preset

)

Definition at line 873 of file kis_paintop_presets_editor.cpp.

{
    if (preset) {
        m_d->uiWdgPaintOpPresetSettings.presetWidget->setCurrentResource(preset);
        setCurrentPaintOpId(preset->paintOp().id());
    }
}

References m_d, setCurrentPaintOpId(), and KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings.

cutOutOverlay()

QImage KisPaintOpPresetsEditor::cutOutOverlay

(

)

Image for preset preview

Returns

image cut out from the scratchpad

Definition at line 479 of file kis_paintop_presets_editor.cpp.

{
    return m_d->uiWdgPaintOpPresetSettings.scratchPad->cutoutOverlay();
}

References m_d, and KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings.

defaultPresetClicked

void KisPaintOpPresetsEditor::defaultPresetClicked ( )

signal

dirtyPresetToggled

void KisPaintOpPresetsEditor::dirtyPresetToggled ( bool value )

signal

eraserBrushOpacityToggled

void KisPaintOpPresetsEditor::eraserBrushOpacityToggled ( bool value )

signal

eraserBrushSizeToggled

void KisPaintOpPresetsEditor::eraserBrushSizeToggled ( bool value )

signal

hideEvent()

void KisPaintOpPresetsEditor::hideEvent ( QHideEvent * event )

overrideprotected

Definition at line 623 of file kis_paintop_presets_editor.cpp.

{
    if (m_d->ignoreHideEvents) {
        return;
    }
 
    KisConfig cfg(false);
 
    QList<int> splitterSizes = m_d->horzSplitter->sizes();
    if (!cfg.presetStripVisible()) {
        splitterSizes[0] = m_d->presetPanelWidth;
    }
 
    if (!cfg.scratchpadVisible()) {
        splitterSizes[2] = m_d->scratchPanelWidth;
    }
 
    cfg.writeList<int>("brushEditorSplitterSizes", splitterSizes);
 
    QWidget *frame = this->parentWidget();
    cfg.writeEntry("brushEditorWindowGeometry", frame->saveGeometry());
 
    QWidget::hideEvent(event);
}

References KisPaintOpPresetsEditor::Private::horzSplitter, KisPaintOpPresetsEditor::Private::ignoreHideEvents, m_d, KisPaintOpPresetsEditor::Private::presetPanelWidth, KisConfig::presetStripVisible(), KisConfig::scratchpadVisible(), KisPaintOpPresetsEditor::Private::scratchPanelWidth, KisConfig::writeEntry(), and KisConfig::writeList().

paintopActivated

void KisPaintOpPresetsEditor::paintopActivated ( const QString & presetName )

signal

readOptionSetting()

void KisPaintOpPresetsEditor::readOptionSetting

(

const KisPropertiesConfigurationSP

setting

)

Definition at line 494 of file kis_paintop_presets_editor.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->settingsWidget);
    m_d->settingsWidget->setConfigurationSafe(setting);
 
    KisLodAvailabilityData data = m_d->lodAvailabilityData.get();
    data.read(setting.data());
    m_d->lodAvailabilityData.set(data);
}

References KisSharedPtr< T >::data(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisPaintOpPresetsEditor::Private::lodAvailabilityData, m_d, KisLodAvailabilityData::read(), KisPaintOpConfigWidget::setConfigurationSafe(), and KisPaintOpPresetsEditor::Private::settingsWidget.

reloadPresetClicked

void KisPaintOpPresetsEditor::reloadPresetClicked ( )

signal

resizeEvent()

void KisPaintOpPresetsEditor::resizeEvent ( QResizeEvent * event )

override

Definition at line 686 of file kis_paintop_presets_editor.cpp.

{
    QWidget::resizeEvent(event);
    if (parentWidget()) {
        // Make sure resizing doesn't push this widget out of the screen
        QRect screenRect = this->screen()->availableGeometry();
        QRect newPositionRect = kisEnsureInRect(parentWidget()->geometry(), screenRect);
        parentWidget()->setGeometry(newPositionRect);
    }
}

References kisEnsureInRect().

resourceSelected

void KisPaintOpPresetsEditor::resourceSelected ( KoResourceSP resource )

slot

Definition at line 512 of file kis_paintop_presets_editor.cpp.

{
    // this gets called every time the brush editor window is opened
    // TODO: this gets called multiple times whenever the preset is changed in the presets area
    // the connections probably need to be thought about with this a bit more to keep things in sync
 
    m_d->uiWdgPaintOpPresetSettings.presetWidget->setCurrentResource(resource);
 
    // find the display name of the brush engine and append it to the selected preset display
    QString currentBrushEngineName;
    QPixmap currentBrushEngineIcon = QPixmap(26, 26);
    currentBrushEngineIcon.fill(Qt::transparent);
    for(int i=0; i < sortedBrushEnginesList.length(); i++) {
        if (sortedBrushEnginesList.at(i).id == currentPaintOpId() ) {
            currentBrushEngineName = sortedBrushEnginesList.at(i).name;
            currentBrushEngineIcon = sortedBrushEnginesList.at(i).icon.pixmap(26, 26);
        }
    }
 
    // brush names have underscores as part of the file name (to help with building). We don't really need underscores
    // when viewing the names, so replace them with spaces
    QString formattedBrushName = resource->name().replace("_", " ");
 
    m_d->uiWdgPaintOpPresetSettings.currentBrushNameLabel->setToolTip(formattedBrushName);
    formattedBrushName = this->fontMetrics().elidedText(formattedBrushName, Qt::ElideRight, m_d->uiWdgPaintOpPresetSettings.currentBrushNameLabel->width());
    m_d->uiWdgPaintOpPresetSettings.currentBrushNameLabel->setText(formattedBrushName);
    m_d->uiWdgPaintOpPresetSettings.currentBrushEngineLabel->setText(i18nc("%1 is the name of a brush engine", "%1 Engine", currentBrushEngineName));
    m_d->uiWdgPaintOpPresetSettings.currentBrushEngineIcon->setPixmap(currentBrushEngineIcon);
    m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField->setText(resource->name());
 
    // get the preset image and pop it into the thumbnail area on the top of the brush editor
    QSize thumbSize = QSize(55, 55)*devicePixelRatioF();
    QImage thumbImage = resource->image();
 
    m_d->uiWdgPaintOpPresetSettings.scratchPad->setPresetImage(thumbImage);
 
    QPixmap thumbnail;
    if (!thumbImage.isNull()) {
        thumbnail = QPixmap::fromImage(thumbImage.scaled(thumbSize, Qt::KeepAspectRatio, Qt::SmoothTransformation));
    } else {
        thumbnail = QPixmap();
    }
 
    thumbnail.setDevicePixelRatio(devicePixelRatioF());
    m_d->uiWdgPaintOpPresetSettings.presetThumbnailicon->setPixmap(thumbnail);
 
    toggleBrushRenameUIActive(false); // reset the UI state of renaming a brush if we are changing brush presets
    slotUpdatePresetSettings(); // check to see if the dirty preset icon needs to be shown
}

References currentPaintOpId(), m_d, slotUpdatePresetSettings(), sortedBrushEnginesList, toggleBrushRenameUIActive(), and KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings.

saveBrushPreset

void KisPaintOpPresetsEditor::saveBrushPreset ( )

signal

savePresetClicked

void KisPaintOpPresetsEditor::savePresetClicked ( )

signal

setCreatingBrushFromScratch()

void KisPaintOpPresetsEditor::setCreatingBrushFromScratch

(

bool

enable

)

Definition at line 489 of file kis_paintop_presets_editor.cpp.

{
    m_d->isCreatingBrushFromScratch = enabled;
}

References KisPaintOpPresetsEditor::Private::isCreatingBrushFromScratch, and m_d.

setCurrentPaintOpId()

void KisPaintOpPresetsEditor::setCurrentPaintOpId

(

const QString &

paintOpId

)

Definition at line 613 of file kis_paintop_presets_editor.cpp.

{
    current_paintOpId = paintOpId;
}

References current_paintOpId.

setPaintOpList()

void KisPaintOpPresetsEditor::setPaintOpList

(

const QList< KisPaintOpFactory * > &

list

)

Definition at line 567 of file kis_paintop_presets_editor.cpp.

{
    m_d->uiWdgPaintOpPresetSettings.brushEngineComboBox->clear(); // reset combobox list just in case
 
 
    // create a new list so we can sort it and populate the brush engine combo box
    sortedBrushEnginesList.clear(); // just in case this function is called again, don't keep adding to the list
 
    for(int i=0; i < list.length(); i++) {
        KisPaintOpInfo paintOpInfo;
        paintOpInfo.id = list.at(i)->id();
        paintOpInfo.name = list.at(i)->name();
        paintOpInfo.icon = list.at(i)->icon();
        paintOpInfo.priority = list.at(i)->priority();
 
        sortedBrushEnginesList.append(paintOpInfo);
    }
 
    std::stable_sort(sortedBrushEnginesList.begin(), sortedBrushEnginesList.end(), variantLessThan );
 
    // add an "All" option at the front to show all presets
    QPixmap emptyPixmap = QPixmap(22,22);
    emptyPixmap.fill(Qt::transparent);
 
    // if we create a new brush from scratch, we need a full list of paintops to choose from
    // we don't want "All", so populate the list before that is added
    newPresetBrushEnginesMenu->actions().clear(); // clean out list in case we run this again
    newBrushEngineOptions.clear();
 
    for (int j = 0; j < sortedBrushEnginesList.length(); j++) {
        auto * newEngineAction = newPresetBrushEnginesMenu->addAction(sortedBrushEnginesList[j].name);
        newEngineAction->setObjectName(sortedBrushEnginesList[j].id); // we need the ID for changing the paintop when action triggered
        newEngineAction->setIcon(sortedBrushEnginesList[j].icon);
        newBrushEngineOptions.append(newEngineAction);
        connect(newEngineAction, SIGNAL(triggered()), this, SLOT(slotCreateNewBrushPresetEngine()));
    }
    m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setMenu(newPresetBrushEnginesMenu);
 
    // fill the list into the brush combo box
    sortedBrushEnginesList.push_front(KisPaintOpInfo(QString("all_options"), i18n("All"), QString(""), QIcon(emptyPixmap), 0 ));
    for (int m = 0; m < sortedBrushEnginesList.length(); m++) {
        m_d->uiWdgPaintOpPresetSettings.brushEngineComboBox->addItem(sortedBrushEnginesList[m].icon, sortedBrushEnginesList[m].name, QVariant(sortedBrushEnginesList[m].id));
    }
}

References connect(), KisPaintOpInfo::icon, KisPaintOpInfo::id, m_d, KisPaintOpInfo::name, newBrushEngineOptions, newPresetBrushEnginesMenu, KisPaintOpInfo::priority, slotCreateNewBrushPresetEngine(), sortedBrushEnginesList, KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings, and variantLessThan().

setPaintOpSettingsWidget()

void KisPaintOpPresetsEditor::setPaintOpSettingsWidget

(

QWidget *

widget

)

Definition at line 422 of file kis_paintop_presets_editor.cpp.

{
    if (m_d->settingsWidget) {
        m_d->layout->removeWidget(m_d->settingsWidget);
        m_d->uiWdgPaintOpPresetSettings.frmOptionWidgetContainer->updateGeometry();
    }
    m_d->layout->update();
    updateGeometry();
 
    m_d->widgetConnections.clear();
    m_d->settingsWidget = 0;
 
    if (widget) {
 
        m_d->settingsWidget = dynamic_cast<KisPaintOpConfigWidget*>(widget);
        KIS_ASSERT_RECOVER_RETURN(m_d->settingsWidget);
 
        KisConfig cfg(true);
        if (m_d->settingsWidget->supportScratchBox() && cfg.scratchpadVisible()) {
            slotSwitchScratchpad(true);
        } else {
            slotSwitchScratchpad(false);
        }
 
        slotSwitchShowPresets(cfg.presetStripVisible());
 
        KisLodAvailabilityModel *model =
            new KisLodAvailabilityModel(m_d->lodAvailabilityData,
                                        m_d->settingsWidget->effectiveBrushSize(),
                                        m_d->settingsWidget->lodLimitationsReader());
        m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->setLodAvailabilityModel(model);
 
        widget->setFont(m_d->smallFont);
 
        m_d->layout->addWidget(widget);
 
        // hook up connections that will monitor if our preset is dirty or not. Show a notification if it is
        if (m_d->resourceProvider && m_d->resourceProvider->currentPreset() ) {
 
            KisPaintOpPresetSP preset = m_d->resourceProvider->currentPreset();
            m_d->widgetConnections.addConnection(preset->updateProxy(), SIGNAL(sigSettingsChanged()),
                                                 this, SLOT(slotUpdatePresetSettings()));
        }
 
        m_d->widgetConnections.addConnection(model, SIGNAL(effectiveLodAvailableChanged(bool)),
                                             this, SLOT(slotUpdateEffectiveLodAvailable(bool)));
        slotUpdateEffectiveLodAvailable(model->effectiveLodAvailable());
 
        m_d->widgetConnections.addConnection(model, SIGNAL(sigConfigurationItemChanged()),
                                             widget, SIGNAL(sigConfigurationItemChanged()));
 
        m_d->layout->update();
        widget->show();
 
    }
}

References KisSignalAutoConnectionsStore::addConnection(), KisSignalAutoConnectionsStore::clear(), KisCanvasResourceProvider::currentPreset(), KisPaintOpConfigWidget::effectiveBrushSize(), KIS_ASSERT_RECOVER_RETURN, KisPaintOpPresetsEditor::Private::layout, KisPaintOpPresetsEditor::Private::lodAvailabilityData, KisPaintOpConfigWidget::lodLimitationsReader(), m_d, KisConfig::presetStripVisible(), KisPaintOpPresetsEditor::Private::resourceProvider, KisConfig::scratchpadVisible(), KisPaintOpPresetsEditor::Private::settingsWidget, slotSwitchScratchpad(), slotSwitchShowPresets(), slotUpdateEffectiveLodAvailable(), slotUpdatePresetSettings(), KisPaintOpPresetsEditor::Private::smallFont, KisPaintOpConfigWidget::supportScratchBox(), KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings, and KisPaintOpPresetsEditor::Private::widgetConnections.

showEvent()

void KisPaintOpPresetsEditor::showEvent ( QShowEvent * )

overrideprotected

Definition at line 648 of file kis_paintop_presets_editor.cpp.

{
    KisConfig cfg(false);
 
    // The center widget's size will be cut off if not re-retrieved.
    m_d->defaultSplitterSizes[1] = m_d->horzSplitter->widget(1)->sizeHint().width();
    QList<int> splitterSizes = cfg.readList<int>("brushEditorSplitterSizes", m_d->defaultSplitterSizes);
 
    m_d->presetPanelWidth = splitterSizes[0];
    m_d->scratchPanelWidth = splitterSizes[2];
 
    if (!cfg.presetStripVisible()) {
        splitterSizes[0] = 0;
    }
    if (!cfg.scratchpadVisible()) {
        splitterSizes[2] = 0;
    }
 
    QWidget *frame = this->parentWidget();
    QByteArray frameGeometry = cfg.readEntry("brushEditorWindowGeometry", QByteArray());
    if (!frameGeometry.isEmpty()) {
        frame->restoreGeometry(frameGeometry);
    }
    else {
        int presetPanelWidth = splitterSizes[0] != 0 ? splitterSizes[0] : m_d->uiWdgPaintOpPresetSettings.showPresetsButton->width();
        int scratchPanelWidth =
            splitterSizes[2] != 0 ? splitterSizes[2] : m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->width();
        const QMargins margins = m_d->layout->contentsMargins();
        int width = presetPanelWidth + splitterSizes[1] + scratchPanelWidth +
            margins.bottom() + margins.left() + margins.top() + margins.right();
        QRect defaultGeometry = QRect(frame->geometry().x(), frame->geometry().y(), width, frame->geometry().height());
        frame->setGeometry(defaultGeometry);
    }
    m_d->horzSplitter->setSizes(splitterSizes);
 
    Q_EMIT brushEditorShown();
}

References brushEditorShown(), KisPaintOpPresetsEditor::Private::defaultSplitterSizes, KisPaintOpPresetsEditor::Private::horzSplitter, KisPaintOpPresetsEditor::Private::layout, m_d, KisPaintOpPresetsEditor::Private::presetPanelWidth, KisConfig::presetStripVisible(), KisConfig::readEntry(), KisConfig::readList(), KisConfig::scratchpadVisible(), KisPaintOpPresetsEditor::Private::scratchPanelWidth, and KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings.

signalResourceSelected

void KisPaintOpPresetsEditor::signalResourceSelected ( KoResourceSP resource )

signal

slotBlackListCurrentPreset

void KisPaintOpPresetsEditor::slotBlackListCurrentPreset ( )

privateslot

we do not delete brush presets, but blacklist them so they disappear from the interface

Definition at line 319 of file kis_paintop_presets_editor.cpp.

{
    KisPaintOpPresetResourceServer *rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
    KisPaintOpPresetSP curPreset = m_d->resourceProvider->currentPreset();
    rServer->removeResourceFromServer(curPreset);
}

References KisCanvasResourceProvider::currentPreset(), KisResourceServerProvider::instance(), m_d, KisResourceServerProvider::paintOpPresetServer(), KoResourceServer< T >::removeResourceFromServer(), and KisPaintOpPresetsEditor::Private::resourceProvider.

slotCreateNewBrushPresetEngine

void KisPaintOpPresetsEditor::slotCreateNewBrushPresetEngine ( )

slot

Definition at line 863 of file kis_paintop_presets_editor.cpp.

{
    Q_EMIT createPresetFromScratch(sender()->objectName());
}

References createPresetFromScratch().

slotRenameBrushActivated

void KisPaintOpPresetsEditor::slotRenameBrushActivated ( )

slot

Definition at line 326 of file kis_paintop_presets_editor.cpp.

{
    toggleBrushRenameUIActive(true);
}

References toggleBrushRenameUIActive().

slotRenameBrushDeactivated

void KisPaintOpPresetsEditor::slotRenameBrushDeactivated ( )

slot

Definition at line 331 of file kis_paintop_presets_editor.cpp.

{
    toggleBrushRenameUIActive(false);
}

References toggleBrushRenameUIActive().

slotSaveBrushPreset

void KisPaintOpPresetsEditor::slotSaveBrushPreset ( )

privateslot

Definition at line 825 of file kis_paintop_presets_editor.cpp.

                                                  {
    // here we are assuming that people want to keep their existing preset icon. We will just update the
    // settings and save a new copy with the same name.
    // there is a dialog with save options, but we don't need to show it in this situation
 
    saveDialog->useNewBrushDialog(false); // this mostly just makes sure we keep the existing brush preset name when saving
    const QImage thumbImage = m_d->resourceProvider->currentPreset() ? m_d->resourceProvider->currentPreset()->image() : QImage();
    saveDialog->brushPresetThumbnailWidget->setPresetImage(thumbImage);
    saveDialog->saveScratchPadThumbnailArea(m_d->uiWdgPaintOpPresetSettings.scratchPad->cutoutOverlay());
    saveDialog->loadExistingThumbnail(); // This makes sure we use the existing preset icon when updating the existing brush preset
    saveDialog->showDialog();
 
    // refresh the view settings so the brush doesn't appear dirty
    // tiar 2021: I'm not sure if it's needed anymore; seems to work without it...
    slotUpdatePresetSettings();
}

References KisCanvasResourceProvider::currentPreset(), KisPresetSaveWidget::loadExistingThumbnail(), m_d, KisPaintOpPresetsEditor::Private::resourceProvider, saveDialog, KisPresetSaveWidget::saveScratchPadThumbnailArea(), KisPresetSaveWidget::showDialog(), slotUpdatePresetSettings(), KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings, and KisPresetSaveWidget::useNewBrushDialog().

slotSaveNewBrushPreset

void KisPaintOpPresetsEditor::slotSaveNewBrushPreset ( )

privateslot

Definition at line 842 of file kis_paintop_presets_editor.cpp.

                                                     {
    saveDialog->useNewBrushDialog(true);
    const QImage thumbImage = m_d->resourceProvider->currentPreset() ? m_d->resourceProvider->currentPreset()->image() : QImage();
    saveDialog->brushPresetThumbnailWidget->setPresetImage(thumbImage);
    saveDialog->saveScratchPadThumbnailArea(m_d->uiWdgPaintOpPresetSettings.scratchPad->cutoutOverlay());
    saveDialog->showDialog();
}

References KisCanvasResourceProvider::currentPreset(), m_d, KisPaintOpPresetsEditor::Private::resourceProvider, saveDialog, KisPresetSaveWidget::saveScratchPadThumbnailArea(), KisPresetSaveWidget::showDialog(), KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings, and KisPresetSaveWidget::useNewBrushDialog().

slotSaveRenameCurrentBrush

void KisPaintOpPresetsEditor::slotSaveRenameCurrentBrush ( )

slot

Definition at line 363 of file kis_paintop_presets_editor.cpp.

{
    // if you are renaming a brush, that is different than updating the settings
    // make sure we are in a clean state before renaming. This logic might change,
    // but that is what we are going with for now
    KisPaintOpSettingsSP prevSettings = m_d->resourceProvider->currentPreset()->settings()->clone();
    bool isDirty = m_d->resourceProvider->currentPreset()->isDirty();
 
    // this returns the UI to its original state after saving
    toggleBrushRenameUIActive(false);
    slotUpdatePresetSettings(); // update visibility of dirty preset and icon
 
    // get a reference to the existing (and new) file name and path that we are working with
    KisPaintOpPresetSP curPreset = m_d->resourceProvider->currentPreset();
    // in case the preset is dirty, we need an id to get the actual non-dirty preset to save just the name change
    // into the database
    int currentPresetResourceId = curPreset->resourceId();
 
    QString renamedPresetName = m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField->text();
 
    // If the id < 0, this is a new preset that hasn't been added to the storage and the database yet.
    if (currentPresetResourceId < 0) {
        curPreset->setName(renamedPresetName);
        slotUpdatePresetSettings(); // update visibility of dirty preset and icon
        return;
    }
 
    Q_EMIT reloadPresetClicked();
 
    // create a new brush preset with the name specified and add to resource provider
    KisResourceModel model(ResourceType::PaintOpPresets);
    KoResourceSP properCleanResource = model.resourceForId(currentPresetResourceId);
    const bool success = KisResourceUserOperations::renameResourceWithUserInput(this, properCleanResource, renamedPresetName);
 
    if (isDirty) {
        properCleanResource.dynamicCast<KisPaintOpPreset>()->setSettings(prevSettings);
        properCleanResource.dynamicCast<KisPaintOpPreset>()->setDirty(isDirty);
    }
 
    // refresh and select our freshly renamed resource
    if (success) resourceSelected(properCleanResource);
 
    m_d->favoriteResManager->updateFavoritePresets();
 
    slotUpdatePresetSettings(); // update visibility of dirty preset and icon
}

References KisCanvasResourceProvider::currentPreset(), KisPaintOpPresetsEditor::Private::favoriteResManager, m_d, ResourceType::PaintOpPresets, reloadPresetClicked(), KisResourceUserOperations::renameResourceWithUserInput(), KisResourceModel::resourceForId(), KisPaintOpPresetsEditor::Private::resourceProvider, resourceSelected(), slotUpdatePresetSettings(), toggleBrushRenameUIActive(), KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings, and KisFavoriteResourceManager::updateFavoritePresets().

slotSwitchScratchpad

void KisPaintOpPresetsEditor::slotSwitchScratchpad ( bool visible )

privateslot

Definition at line 697 of file kis_paintop_presets_editor.cpp.

{
    bool sameVisibility = m_d->uiWdgPaintOpPresetSettings.scratchPad->isVisible() == visible;
 
    // hide all the internal controls except the toggle button
    m_d->uiWdgPaintOpPresetSettings.scratchPad->setVisible(visible);
    m_d->uiWdgPaintOpPresetSettings.paintPresetIcon->setVisible(visible);
    m_d->uiWdgPaintOpPresetSettings.fillGradient->setVisible(visible);
    m_d->uiWdgPaintOpPresetSettings.fillLayer->setVisible(visible);
    m_d->uiWdgPaintOpPresetSettings.fillSolid->setVisible(visible);
    m_d->uiWdgPaintOpPresetSettings.eraseScratchPad->setVisible(visible);
    m_d->uiWdgPaintOpPresetSettings.scratchpadSidebarLabel->setVisible(visible);
 
    if (sameVisibility) {
        return;
    }
 
    QPushButton* showBtn = m_d->uiWdgPaintOpPresetSettings.showScratchpadButton;
    QGroupBox *container = m_d->uiWdgPaintOpPresetSettings.scratchpadControls;
 
    const QMargins margins = m_d->layout->contentsMargins();
    int emptyContainerWidth = showBtn->width() + margins.left() + margins.right();
 
    if (visible) {
        showBtn->setIcon(KisIconUtils::loadIcon("arrow-left"));
 
        container->setMinimumWidth(scratchPadPanelMinWidth);
        container->setMaximumWidth(0xFF'FFFF);
 
        QList<int> splitterSizes = m_d->horzSplitter->sizes();
        splitterSizes[2] = m_d->scratchPanelWidth > 0 ? m_d->scratchPanelWidth : scratchPadPanelInitWidth;
        QWidget *frame = this->parentWidget();
        QRect currentGeometry = frame->geometry();
        currentGeometry.setRight(currentGeometry.right() + (splitterSizes[2] - emptyContainerWidth));
        frame->setGeometry(currentGeometry);
        m_d->horzSplitter->setSizes(splitterSizes);
    } else {
        showBtn->setIcon(KisIconUtils::loadIcon("arrow-right"));
 
        container->setMinimumWidth(emptyContainerWidth);
        container->setMaximumWidth(emptyContainerWidth);
 
        QList<int> splitterSizes = m_d->horzSplitter->sizes();
        m_d->scratchPanelWidth = m_d->scratchPanelWidth > 0 ? splitterSizes[2] : scratchPadPanelInitWidth;
        QWidget *frame = this->parentWidget();
        QRect currentGeometry = frame->geometry();
        currentGeometry.setRight(currentGeometry.right() - (m_d->scratchPanelWidth - emptyContainerWidth));
        frame->setGeometry(currentGeometry);
 
        splitterSizes[1] = 0xFF'FFFF;
        splitterSizes[2] = emptyContainerWidth;
        m_d->horzSplitter->setSizes(splitterSizes);
    }
 
    KisConfig cfg(false);
    cfg.setScratchpadVisible(visible);
}

References KisPaintOpPresetsEditor::Private::horzSplitter, KisPaintOpPresetsEditor::Private::layout, KisIconUtils::loadIcon(), m_d, scratchPadPanelInitWidth, scratchPadPanelMinWidth, KisPaintOpPresetsEditor::Private::scratchPanelWidth, KisConfig::setScratchpadVisible(), and KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings.

slotSwitchShowEditor

void KisPaintOpPresetsEditor::slotSwitchShowEditor ( bool visible )

privateslot

Definition at line 755 of file kis_paintop_presets_editor.cpp.

                                                               {
    m_d->uiWdgPaintOpPresetSettings.brushEditorSettingsControls->setVisible(visible);
}

References m_d, and KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings.

slotSwitchShowPresets

void KisPaintOpPresetsEditor::slotSwitchShowPresets ( bool visible )

privateslot

Definition at line 759 of file kis_paintop_presets_editor.cpp.

{
    bool sameVisibility = m_d->uiWdgPaintOpPresetSettings.presetsSidebarLabel->isVisible() == visible;
 
    m_d->uiWdgPaintOpPresetSettings.presetsSidebarLabel->setVisible(visible);
    m_d->uiWdgPaintOpPresetSettings.engineFilterLabel->setVisible(visible);
    m_d->uiWdgPaintOpPresetSettings.brushEngineComboBox->setVisible(visible);
    m_d->uiWdgPaintOpPresetSettings.presetWidget->setVisible(visible);
    m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setVisible(visible);
    m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setVisible(visible);
 
    if (sameVisibility) {
        return;
    }
 
    QPushButton* showBtn = m_d->uiWdgPaintOpPresetSettings.showPresetsButton;
    QGroupBox *container = m_d->uiWdgPaintOpPresetSettings.presetsContainer;
 
    const QMargins margins = m_d->layout->contentsMargins();
    int emptyContainerWidth = showBtn->width() + margins.left() + margins.right();
 
    if (visible) {
        showBtn->setIcon(KisIconUtils::loadIcon("arrow-right"));
 
        container->setMinimumWidth(brushPresetsPanelMinWidth);
        container->setMaximumWidth(0xFF'FFFF);
 
        QList<int> splitterSizes = m_d->horzSplitter->sizes();
        splitterSizes[0] = m_d->presetPanelWidth;
        QWidget *frame = this->parentWidget();
        QRect currentGeometry = frame->geometry();
        currentGeometry.setLeft(currentGeometry.left() - (splitterSizes[0] - emptyContainerWidth));
        frame->setGeometry(currentGeometry);
        m_d->horzSplitter->setSizes(splitterSizes);
    } else {
        showBtn->setIcon(KisIconUtils::loadIcon("arrow-left"));
 
        container->setMinimumWidth(emptyContainerWidth);
        container->setMaximumWidth(emptyContainerWidth);
 
        QList<int> splitterSizes = m_d->horzSplitter->sizes();
        m_d->presetPanelWidth = m_d->presetPanelWidth > 0 ? splitterSizes[0] : brushPresetsPanelInitWidth;
        QWidget *frame = this->parentWidget();
        QRect currentGeometry = frame->geometry();
        currentGeometry.setLeft(currentGeometry.left() + (m_d->presetPanelWidth - emptyContainerWidth));
        frame->setGeometry(currentGeometry);
 
        splitterSizes[0] = emptyContainerWidth;
        splitterSizes[1] = 0xFF'FFFF;
        m_d->horzSplitter->setSizes(splitterSizes);
    }
 
    KisConfig cfg(false);
    cfg.setPresetStripVisible(visible);
}

References brushPresetsPanelInitWidth, brushPresetsPanelMinWidth, KisPaintOpPresetsEditor::Private::horzSplitter, KisPaintOpPresetsEditor::Private::layout, KisIconUtils::loadIcon(), m_d, KisPaintOpPresetsEditor::Private::presetPanelWidth, KisConfig::setPresetStripVisible(), and KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings.

slotToggleDetach

void KisPaintOpPresetsEditor::slotToggleDetach ( bool detach )

privateslot

Definition at line 850 of file kis_paintop_presets_editor.cpp.

{
    Q_EMIT toggleDetachState(detach);
    KisConfig cfg(false);
    cfg.setPaintopPopupDetached(detach);
}

References KisConfig::setPaintopPopupDetached(), and toggleDetachState().

slotUpdateEffectiveLodAvailable

void KisPaintOpPresetsEditor::slotUpdateEffectiveLodAvailable ( bool value )

privateslot

Definition at line 857 of file kis_paintop_presets_editor.cpp.

{
    if (!m_d->resourceProvider) return;
    m_d->resourceProvider->resourceManager()->setResource(KoCanvasResource::EffectiveLodAvailability, value);
}

References KoCanvasResource::EffectiveLodAvailability, m_d, KisCanvasResourceProvider::resourceManager(), KisPaintOpPresetsEditor::Private::resourceProvider, KoCanvasResourceProvider::setResource(), and value().

slotUpdatePaintOpFilter

void KisPaintOpPresetsEditor::slotUpdatePaintOpFilter ( )

privateslot

Definition at line 815 of file kis_paintop_presets_editor.cpp.

                                                      {
    QVariant userData = m_d->uiWdgPaintOpPresetSettings.brushEngineComboBox->currentData(); // grab paintOpID from data
    QString filterPaintOpId = userData.toString();
 
    if (filterPaintOpId == "all_options") {
        filterPaintOpId = "";
    }
    m_d->uiWdgPaintOpPresetSettings.presetWidget->setPresetFilter(filterPaintOpId);
}

References m_d, and KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings.

slotUpdatePresetSettings

void KisPaintOpPresetsEditor::slotUpdatePresetSettings ( )

slot

Definition at line 920 of file kis_paintop_presets_editor.cpp.

{
    if (!m_d->resourceProvider) {
        return;
    }
 
    if (!m_d->resourceProvider->currentPreset()) {
        return;
    }
 
    // hide options on UI if we are creating a brush preset from scratch to prevent confusion
    if (m_d->isCreatingBrushFromScratch) {
        m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setVisible(false);
        m_d->uiWdgPaintOpPresetSettings.brokenPresetIndicatorButton->setVisible(false);
        m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setVisible(false);
        m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setVisible(false);
        m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setVisible(false);
    } else {
        const bool isPresetDirty = m_d->resourceProvider->currentPreset()->isDirty();
 
        // don't need to reload or overwrite a clean preset
        m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setVisible(isPresetDirty);
 
        {
            bool isBroken = false;
            QString brokenReason;
            const int resourceId = m_d->resourceProvider->currentPreset()->resourceId();
            if (resourceId >= 0) {
                KisResourceModel model(ResourceType::PaintOpPresets);
                QModelIndex index = model.indexForResourceId(resourceId);
                if (index.isValid()) {
                    isBroken = index.data(Qt::UserRole + KisAbstractResourceModel::BrokenStatus).toBool();
                    brokenReason =
                        QString(
                            "<html><body style=\"margin: 20px;\"><h3>%1</h3>"
                            "%2"
                            "</body></html>")
                            .arg(i18n("Resource is broken!"),
                                 index.data(Qt::UserRole + KisAbstractResourceModel::BrokenStatusMessage).toString());
                }
            }
 
            m_d->uiWdgPaintOpPresetSettings.brokenPresetIndicatorButton->setVisible(isBroken);
            m_d->uiWdgPaintOpPresetSettings.brokenPresetIndicatorButton->setToolTip(brokenReason);
        }
        
        m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setVisible(isPresetDirty);
        m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setEnabled(isPresetDirty);
        m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setVisible(true);
    }
 
    // update live preview area in here...
    // don't update the live preview if the widget is not visible.
    if (m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->isVisible()) {
        m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->setCurrentPreset(m_d->resourceProvider->currentPreset());
        m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->requestUpdateStroke();
    }
}

References KisAbstractResourceModel::BrokenStatus, KisAbstractResourceModel::BrokenStatusMessage, KisCanvasResourceProvider::currentPreset(), KisResourceModel::indexForResourceId(), KisPaintOpPresetsEditor::Private::isCreatingBrushFromScratch, m_d, ResourceType::PaintOpPresets, KisPaintOpPresetsEditor::Private::resourceProvider, and KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings.

toggleBrushRenameUIActive()

void KisPaintOpPresetsEditor::toggleBrushRenameUIActive ( bool isRenaming )

private

Definition at line 336 of file kis_paintop_presets_editor.cpp.

{
    // This function doesn't really do anything except get the UI in a state to rename a brush preset
    m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField->setVisible(isRenaming);
    m_d->uiWdgPaintOpPresetSettings.updateBrushNameButton->setVisible(isRenaming);
    m_d->uiWdgPaintOpPresetSettings.cancelBrushNameUpdateButton->setVisible(isRenaming);
 
 
    // hide these below areas while renaming
    m_d->uiWdgPaintOpPresetSettings.currentBrushNameLabel->setVisible(!isRenaming);
    m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setVisible(!isRenaming);
    m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setEnabled(!isRenaming);
    m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setVisible(!isRenaming);
    m_d->uiWdgPaintOpPresetSettings.saveNewBrushPresetButton->setEnabled(!isRenaming);
    m_d->uiWdgPaintOpPresetSettings.saveNewBrushPresetButton->setVisible(!isRenaming);
 
    // if the presets area is shown, only then can you show/hide the load default brush
    // need to think about weird state when you are in the middle of renaming a brush
    // what happens if you try to change presets. maybe we should auto-hide (or disable)
    // the presets area in this case
    if (m_d->uiWdgPaintOpPresetSettings.presetWidget->isVisible()) {
        m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setVisible(!isRenaming);
        m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setVisible(!isRenaming);
    }
 
}

References m_d, and KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings.

toggleDetachState

void KisPaintOpPresetsEditor::toggleDetachState ( bool detach )

signal

updateThemedIcons

void KisPaintOpPresetsEditor::updateThemedIcons ( )

slot

Definition at line 881 of file kis_paintop_presets_editor.cpp.

{
    m_d->uiWdgPaintOpPresetSettings.viewOptionButton->setIcon(KisIconUtils::loadIcon("view-choose"));
 
    m_d->uiWdgPaintOpPresetSettings.paintPresetIcon->setIcon(KisIconUtils::loadIcon("krita_tool_freehand"));
    m_d->uiWdgPaintOpPresetSettings.fillLayer->setIcon(KisIconUtils::loadIcon("document-new"));
    m_d->uiWdgPaintOpPresetSettings.fillLayer->hide();
    m_d->uiWdgPaintOpPresetSettings.fillGradient->setIcon(KisIconUtils::loadIcon("krita_tool_gradient"));
    m_d->uiWdgPaintOpPresetSettings.fillSolid->setIcon(KisIconUtils::loadIcon("krita_tool_color_fill"));
    m_d->uiWdgPaintOpPresetSettings.eraseScratchPad->setIcon(KisIconUtils::loadIcon("edit-delete"));
 
    m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setIcon(KisIconUtils::loadIcon("list-add"));
    m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setIcon(KisIconUtils::loadIcon("deletelayer"));
    m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setIcon(KisIconUtils::loadIcon("reload-preset-16"));
    m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setIcon(KisIconUtils::loadIcon("document-edit"));
    m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setIcon(KisIconUtils::loadIcon("warning"));
    m_d->uiWdgPaintOpPresetSettings.brokenPresetIndicatorButton->setIcon(KisIconUtils::loadIcon("broken-preset"));
 
    m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setIcon(KisIconUtils::loadIcon("list-add"));
    m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setIcon(KisIconUtils::loadIcon("deletelayer"));
    //m_d->uiWdgPaintOpPresetSettings.presetChangeViewToolButton->setIcon(KisIconUtils::loadIcon("view-choose"));
 
    // store if the scratchpad or brush presets are visible in the config
    KisConfig cfg(true);
    if (cfg.presetStripVisible()) {
        //m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::Ignored,QSizePolicy::Ignored);
        m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
    } else {
        //m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::MinimumExpanding,QSizePolicy::MinimumExpanding);
        m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
    }
 
    if (cfg.scratchpadVisible()) {
        m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
    } else {
        m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
    }
}

References KisIconUtils::loadIcon(), m_d, KisConfig::presetStripVisible(), KisConfig::scratchpadVisible(), and KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings.

updateViewSettings()

void KisPaintOpPresetsEditor::updateViewSettings

(

)

Definition at line 868 of file kis_paintop_presets_editor.cpp.

{
    m_d->uiWdgPaintOpPresetSettings.presetWidget->updateViewSettings();
}

References m_d, and KisPaintOpPresetsEditor::Private::uiWdgPaintOpPresetSettings.

writeOptionSetting()

void KisPaintOpPresetsEditor::writeOptionSetting

(

KisPropertiesConfigurationSP

setting

)

const

Definition at line 504 of file kis_paintop_presets_editor.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->settingsWidget);
 
    m_d->settingsWidget->writeConfigurationSafe(setting);
    m_d->lodAvailabilityData->write(setting.data());
}

References KisSharedPtr< T >::data(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisPaintOpPresetsEditor::Private::lodAvailabilityData, m_d, KisPaintOpPresetsEditor::Private::settingsWidget, and KisPaintOpConfigWidget::writeConfigurationSafe().

Member Data Documentation

brushPresetsPanelInitWidth

const int KisPaintOpPresetsEditor::brushPresetsPanelInitWidth = 200

private

Definition at line 119 of file kis_paintop_presets_editor.h.

brushPresetsPanelMinWidth

const int KisPaintOpPresetsEditor::brushPresetsPanelMinWidth = 80

private

Definition at line 118 of file kis_paintop_presets_editor.h.

current_paintOpId

QString KisPaintOpPresetsEditor::current_paintOpId

private

Definition at line 123 of file kis_paintop_presets_editor.h.

m_d

Private* const KisPaintOpPresetsEditor::m_d

private

Definition at line 117 of file kis_paintop_presets_editor.h.

newBrushEngineOptions

QList<QAction*> KisPaintOpPresetsEditor::newBrushEngineOptions

private

Definition at line 127 of file kis_paintop_presets_editor.h.

newPresetBrushEnginesMenu

QMenu* KisPaintOpPresetsEditor::newPresetBrushEnginesMenu

private

Definition at line 126 of file kis_paintop_presets_editor.h.

saveDialog

KisPresetSaveWidget* KisPaintOpPresetsEditor::saveDialog

Definition at line 63 of file kis_paintop_presets_editor.h.

scratchPadPanelInitWidth

const int KisPaintOpPresetsEditor::scratchPadPanelInitWidth = 200

private

Definition at line 121 of file kis_paintop_presets_editor.h.

scratchPadPanelMinWidth

const int KisPaintOpPresetsEditor::scratchPadPanelMinWidth = 80

private

Definition at line 120 of file kis_paintop_presets_editor.h.

sortedBrushEnginesList

QList<KisPaintOpInfo> KisPaintOpPresetsEditor::sortedBrushEnginesList

private

Definition at line 124 of file kis_paintop_presets_editor.h.

---

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

• libs/ui/widgets/kis_paintop_presets_editor.h
• libs/ui/widgets/kis_paintop_presets_editor.cpp