LayerBox Class Reference

#include <LayerBox.h>

Inheritance diagram for LayerBox:

Signals
void	imageChanged ()

Public Member Functions
	LayerBox ()
QString	observerName () override
void	setCanvas (KoCanvasBase *canvas) override
void	setViewManager (KisViewManager *kisview) override
	reimplemented from KisMainwindowObserver
void	unsetCanvas () override
	~LayerBox () override
Public Member Functions inherited from KisMainwindowObserver
	KisMainwindowObserver ()
	~KisMainwindowObserver () override
Public Member Functions inherited from KoCanvasObserverBase
	KoCanvasObserverBase ()
KoCanvasBase *	observedCanvas () const
void	setObservedCanvas (KoCanvasBase *canvas)
void	unsetObservedCanvas ()
virtual	~KoCanvasObserverBase ()

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

Private Slots
void	notifyImageDeleted ()
void	selectionChanged (const QModelIndexList &selection)
void	setCurrentNode (KisNodeSP node)
void	slotAddLayerBnClicked ()
void	slotAdjustCurrentBeforeRemoveRows (const QModelIndex &parent, int first, int last)
void	slotChangeCloneSourceClicked ()
void	slotCollapsed (const QModelIndex &index)
void	slotColorLabelChanged (int index)
void	slotCompositeOpChanged (int index)
void	slotContextMenuRequested (const QPoint &pos, const QModelIndex &index)
void	slotEditGlobalSelection (bool showSelections)
void	slotExpanded (const QModelIndex &index)
void	slotForgetAboutSavedNodeBeforeEditSelectionMode ()
void	slotImageTimeChanged (int time)
void	slotLayerOpMenuClosed ()
void	slotLayerOpMenuOpened ()
void	slotLowerClicked ()
void	slotModelReset ()
void	slotNodeCollapsedChanged ()
void	slotNodeManagerChangedSelection (const QList< KisNodeSP > &nodes)
void	slotOpacityChanged ()
void	slotOpacitySliderMoved (qreal opacity)
void	slotPropertiesClicked ()
void	slotRaiseClicked ()
void	slotRenameCurrentNode ()
void	slotRmClicked ()
void	slotSelectOpaque ()
void	slotSetCompositeOp (const KoCompositeOp *compositeOp)
void	slotSetOpacity (double opacity)
void	slotUpdateIcons ()
void	slotUpdateLayerInfoTextOpacity ()
void	slotUpdateLayerInfoTextStyle ()
void	slotUpdateOpacitySlider (quint8 value)
void	slotUpdateThumbnailIconSize ()
void	slotUpdateTreeIndentation ()
void	slotUpdateUseInlineLayerInfoText ()
void	slotUpdateUseLayerSelectionCheckbox ()
void	toggleActiveLayerSolo ()
void	updateAvailableLabels ()
void	updateLayerFiltering ()
void	updateLayerOpMenu (const QModelIndex &index, QMenu &menu)
void	updateUI ()

Private Member Functions
void	addActionToMenu (QMenu *menu, const QString &id)
void	connectActionToButton (KisViewManager *view, QAbstractButton *button, const QString &id)
qint32	convertOpacityToInt (qreal opacity)
KisNodeSP	findNonHidableNode (KisNodeSP startNode)

Private Attributes
QSlider *	indentationSlider
QComboBox *	infoTextCombobox
QCheckBox *	infoTextInlineChkbox
KisSliderSpinBox *	infoTextOpacitySlider
KisLayerFilterWidget *	layerFilterWidget
QCheckBox *	layerSelectionCheckBox {nullptr}
KisNodeSP	m_activeNode
KisSignalAutoConnectionsStore	m_activeNodeConnections
QPointer< KisCanvas2 >	m_canvas
KisAction *	m_changeCloneSourceAction
KisNodeSP	m_changedOpacityNode
KisSignalCompressor	m_colorLabelCompressor
QPointer< KisColorLabelSelectorWidgetMenuWrapper >	m_colorSelector
QPointer< QWidgetAction >	m_colorSelectorAction
QPointer< KisNodeFilterProxyModel >	m_filteringModel
KisImageWSP	m_image
KisSignalCompressor	m_infoTextOpacityCompressor
KisAction *	m_layerToggleSolo
QMenu *	m_newLayerMenu
int	m_newOpacity
QPointer< KisNodeManager >	m_nodeManager
QPointer< KisNodeModel >	m_nodeModel
KisSignalCompressor	m_nodeOpacityCompressor
QMenu *	m_opLayerMenu
KisAction *	m_propertiesAction
KisAction *	m_removeAction
KisNodeWSP	m_savedNodeBeforeEditSelectionMode
QScopedPointer< KisSelectionActionsAdapter >	m_selectionActionsAdapter
KisAction *	m_showGlobalSelectionMask
KisSignalCompressor	m_thumbnailSizeCompressor
KisSignalCompressor	m_treeIndentationCompressor
Ui_WdgLayerBox *	m_wdgLayerBox
QSlider *	thumbnailSizeSlider

Detailed Description

A widget that shows a visualization of the layer structure.

The center of the layer box is KisNodeModel, which shows the actual layers. This widget adds docking functionality and command buttons.

Definition at line 63 of file LayerBox.h.

Constructor & Destructor Documentation

LayerBox()

LayerBox::LayerBox

(

)

Connect model updateUI() to enable/disable controls. Note: nodeActivated() is connected separately in setImage(), because it needs particular order of calls: first the connection to the node manager should be called, then updateUI()

Definition at line 158 of file LayerBox.cpp.

    : QDockWidget(i18n("Layers"))
    , m_canvas(0)
    , m_wdgLayerBox(new Ui_WdgLayerBox)
    , m_colorLabelCompressor(500, KisSignalCompressor::FIRST_INACTIVE)
    , m_thumbnailSizeCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
    , m_treeIndentationCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
    , m_infoTextOpacityCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
    , m_nodeOpacityCompressor(200, KisSignalCompressor::FIRST_INACTIVE)
{
    KisConfig cfg(false);
 
    QWidget* mainWidget = new QWidget(this);
    setWidget(mainWidget);
 
    m_wdgLayerBox->setupUi(mainWidget);
 
    QStyle *newStyle = QStyleFactory::create(m_wdgLayerBox->listLayers->style()->objectName());
    // proxy style steals the ownership of the style and deletes it later
    LayerBoxStyle *proxyStyle = new LayerBoxStyle(newStyle);
 
    proxyStyle->setParent(m_wdgLayerBox->listLayers);
    m_wdgLayerBox->listLayers->setStyle(proxyStyle);
 
    connect(m_wdgLayerBox->listLayers,
            SIGNAL(contextMenuRequested(QPoint,QModelIndex)),
            this, SLOT(slotContextMenuRequested(QPoint,QModelIndex)));
    connect(m_wdgLayerBox->listLayers,
            SIGNAL(collapsed(QModelIndex)), SLOT(slotCollapsed(QModelIndex)));
    connect(m_wdgLayerBox->listLayers,
            SIGNAL(expanded(QModelIndex)), SLOT(slotExpanded(QModelIndex)));
    connect(m_wdgLayerBox->listLayers,
            SIGNAL(selectionChanged(QModelIndexList)), SLOT(selectionChanged(QModelIndexList)));
 
    slotUpdateIcons();
 
    m_wdgLayerBox->bnAdd->setIconSize(QSize(22, 22));
    m_wdgLayerBox->bnDelete->setIconSize(QSize(22, 22));
    m_wdgLayerBox->bnRaise->setIconSize(QSize(22, 22));
    m_wdgLayerBox->bnLower->setIconSize(QSize(22, 22));
    m_wdgLayerBox->bnProperties->setIconSize(QSize(22, 22));
    m_wdgLayerBox->bnDuplicate->setIconSize(QSize(22, 22));
 
    m_wdgLayerBox->bnLower->setEnabled(false);
    m_wdgLayerBox->bnRaise->setEnabled(false);
 
    m_wdgLayerBox->doubleOpacity->setRange(0, 100, 0);
    if (cfg.sliderLabels()) {
        m_wdgLayerBox->opacityLabel->hide();
        KisSpinBoxI18nHelper::setText(m_wdgLayerBox->doubleOpacity,
                                      i18nc("{n} is the number value, % is the percent sign", "Opacity: {n}%"));
    } else {
        KisSpinBoxI18nHelper::setText(m_wdgLayerBox->doubleOpacity,
                                      i18nc("{n} is the number value, % is the percent sign", "{n}%"));
    }
 
    connect(m_wdgLayerBox->doubleOpacity, SIGNAL(valueChanged(qreal)), SLOT(slotOpacitySliderMoved(qreal)));
    connect(&m_nodeOpacityCompressor, SIGNAL(timeout()), SLOT(slotOpacityChanged()));
 
    connect(m_wdgLayerBox->cmbComposite, SIGNAL(activated(int)), SLOT(slotCompositeOpChanged(int)));
 
    m_newLayerMenu = new QMenu(this);
    m_wdgLayerBox->bnAdd->setMenu(m_newLayerMenu);
    m_wdgLayerBox->bnAdd->setPopupMode(QToolButton::MenuButtonPopup);
 
    m_opLayerMenu = new QMenu(this);
    m_wdgLayerBox->bnProperties->setMenu(m_opLayerMenu);
    m_wdgLayerBox->bnProperties->setPopupMode(QToolButton::MenuButtonPopup);
 
    m_nodeModel = new KisNodeModel(this, 2);
    m_filteringModel = new KisNodeFilterProxyModel(this);
    m_filteringModel->setNodeModel(m_nodeModel);
 
    connect(m_nodeModel, SIGNAL(rowsInserted(QModelIndex,int,int)), SLOT(updateUI()));
    connect(m_nodeModel, SIGNAL(rowsRemoved(QModelIndex,int,int)), SLOT(updateUI()));
    connect(m_nodeModel, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)), SLOT(updateUI()));
    connect(m_nodeModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), SLOT(updateUI()));
    connect(m_nodeModel, SIGNAL(modelReset()), SLOT(slotModelReset()));
 
    connect(m_nodeModel, SIGNAL(rowsInserted(QModelIndex,int,int)), SLOT(slotForgetAboutSavedNodeBeforeEditSelectionMode()));
    connect(m_nodeModel, SIGNAL(rowsRemoved(QModelIndex,int,int)), SLOT(slotForgetAboutSavedNodeBeforeEditSelectionMode()));
    connect(m_nodeModel, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)), SLOT(slotForgetAboutSavedNodeBeforeEditSelectionMode()));
    connect(m_nodeModel, SIGNAL(modelReset()), SLOT(slotForgetAboutSavedNodeBeforeEditSelectionMode()));
 
    // we should update expanded state of the nodes on adding the nodes
    connect(m_nodeModel, SIGNAL(rowsInserted(QModelIndex,int,int)), SLOT(slotNodeCollapsedChanged()));
    connect(m_nodeModel, SIGNAL(modelReset()), SLOT(slotNodeCollapsedChanged()));
 
    m_showGlobalSelectionMask = new KisAction(i18n("&Show Global Selection Mask"), this);
    m_showGlobalSelectionMask->setObjectName("show-global-selection-mask");
    m_showGlobalSelectionMask->setActivationFlags(KisAction::ACTIVE_IMAGE);
    m_showGlobalSelectionMask->setToolTip(i18nc("@info:tooltip", "Shows global selection as a usual selection mask in <b>Layers</b> docker"));
    m_showGlobalSelectionMask->setCheckable(true);
    connect(m_showGlobalSelectionMask, SIGNAL(triggered(bool)), SLOT(slotEditGlobalSelection(bool)));
 
    m_showGlobalSelectionMask->setChecked(cfg.showGlobalSelection());
 
    m_colorSelector = new KisColorLabelSelectorWidgetMenuWrapper(this);
    MouseClickIgnore* mouseEater = new MouseClickIgnore(this);
    m_colorSelector->installEventFilter(mouseEater);
    connect(m_colorSelector->colorLabelSelector(), SIGNAL(currentIndexChanged(int)), SLOT(slotColorLabelChanged(int)));
    m_colorSelectorAction = new QWidgetAction(this);
    m_colorSelectorAction->setDefaultWidget(m_colorSelector);
 
    connect(m_nodeModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
            &m_colorLabelCompressor, SLOT(start()));
 
    m_wdgLayerBox->listLayers->setModel(m_filteringModel);
    // this connection should be done *after* the setModel() call to
    // happen later than the internal selection model
    connect(m_filteringModel.data(), &KisNodeFilterProxyModel::sigBeforeBeginRemoveRows,
            this, &LayerBox::slotAdjustCurrentBeforeRemoveRows);
 
 
    //LayerFilter Menu
    QMenu *layerFilterMenu = new QMenu(this);
    m_wdgLayerBox->bnLayerFilters->setMenu(layerFilterMenu);
    m_wdgLayerBox->bnLayerFilters->setPopupMode(QToolButton::InstantPopup);
 
    const QIcon filterIcon = KisIconUtils::loadIcon("view-filter");
    m_wdgLayerBox->bnLayerFilters->setIcon(filterIcon);
    m_wdgLayerBox->bnLayerFilters->setAutoRaise(true);
    QPixmap filterEnabledPixmap = filterIcon.pixmap(64,64);
    const QBitmap filterEnabledBitmask = filterEnabledPixmap.mask();
    filterEnabledPixmap.fill(palette().color(QPalette::Highlight));
    filterEnabledPixmap.setMask(filterEnabledBitmask);
    const QIcon filterEnabledIcon = QIcon(filterEnabledPixmap);
 
    layerFilterWidget = new KisLayerFilterWidget(this);
    connect(layerFilterWidget, SIGNAL(filteringOptionsChanged()), this, SLOT(updateLayerFiltering()));
    connect(layerFilterWidget, &KisLayerFilterWidget::filteringOptionsChanged, [this, filterIcon, filterEnabledIcon](){
        if (layerFilterWidget->isCurrentlyFiltering()) {
            m_wdgLayerBox->bnLayerFilters->setIcon(filterEnabledIcon);
        } else {
            m_wdgLayerBox->bnLayerFilters->setIcon(filterIcon);
        }
 
        auto activeColors = layerFilterWidget->getActiveColors();
        m_wdgLayerBox->bnLayerFilters->setSelectedColors(QList(activeColors.begin(), activeColors.end()));
        m_wdgLayerBox->bnLayerFilters->setTextFilter(layerFilterWidget->hasTextFilter());
    });
 
    QWidgetAction *layerFilterMenuAction = new QWidgetAction(this);
    layerFilterMenuAction->setDefaultWidget(layerFilterWidget);
    layerFilterMenu->addAction(layerFilterMenuAction);
 
 
    KisMenuStyleDontCloseOnAlt *menuStyle = new KisMenuStyleDontCloseOnAlt(layerFilterMenu->style());
    menuStyle->setParent(layerFilterMenu);
    layerFilterMenu->setStyle(menuStyle);
 
    setEnabled(false);
 
    connect(&m_colorLabelCompressor, SIGNAL(timeout()), SLOT(updateAvailableLabels()));
 
 
    // set up the configure menu for changing thumbnail size
    QMenu* configureMenu = new QMenu(this);
    configureMenu->setContentsMargins(6, 6, 6, 6);
    configureMenu->addSection(i18n("Thumbnail Size"));
 
    m_wdgLayerBox->configureLayerDockerToolbar->setMenu(configureMenu);
    m_wdgLayerBox->configureLayerDockerToolbar->setIconSize(QSize(16, 16));
    m_wdgLayerBox->configureLayerDockerToolbar->setPopupMode(QToolButton::InstantPopup);
    m_wdgLayerBox->configureLayerDockerToolbar->setAutoRaise(true);
 
 
    // add horizontal slider
    thumbnailSizeSlider = new QSlider(this);
    thumbnailSizeSlider->setOrientation(Qt::Horizontal);
    thumbnailSizeSlider->setRange(20, 80);
 
    thumbnailSizeSlider->setValue(cfg.layerThumbnailSize(false)); // grab this from the kritarc
 
    thumbnailSizeSlider->setMinimumHeight(20);
    thumbnailSizeSlider->setMinimumWidth(40);
    thumbnailSizeSlider->setTickInterval(5);
    m_nodeModel->setPreferredThumnalSize(cfg.layerThumbnailSize());
 
    QWidgetAction *sliderAction= new QWidgetAction(this);
    sliderAction->setDefaultWidget(thumbnailSizeSlider);
    configureMenu->addAction(sliderAction);
 
 
    connect(thumbnailSizeSlider, SIGNAL(valueChanged(int)), &m_thumbnailSizeCompressor, SLOT(start()));
    connect(&m_thumbnailSizeCompressor, SIGNAL(timeout()), SLOT(slotUpdateThumbnailIconSize()));
 
    configureMenu->addSection(i18nc("@item:inmenu Layers Docker settings, slider", "Tree Indentation"));
 
    // add horizontal slider
    indentationSlider = new QSlider(Qt::Horizontal, this);
    indentationSlider->setRange(20, 100);
    indentationSlider->setMinimumSize(40, 20);
    indentationSlider->setSingleStep(5);
    indentationSlider->setPageStep(20);
    indentationSlider->setValue(cfg.layerTreeIndentation());
 
 
    sliderAction= new QWidgetAction(this);
    sliderAction->setDefaultWidget(indentationSlider);
    configureMenu->addAction(sliderAction);
 
    // NOTE: if KisConfig would just compress its file sync events, we wouldn't need
    // this extra compressor that juggles between slow UI and disk thrashing
    connect(indentationSlider, SIGNAL(valueChanged(int)), &m_treeIndentationCompressor, SLOT(start()));
    connect(&m_treeIndentationCompressor, SIGNAL(timeout()), SLOT(slotUpdateTreeIndentation()));
 
 
    // Layer info-text settings:
    // blending info-text style combobox
    configureMenu->addSection(i18nc("@item:inmenu Layers Docker settings, combobox", "Blending Info Style"));
    infoTextCombobox = new QComboBox(this);
    infoTextCombobox->setToolTip(i18nc("@item:tooltip", "None: Show nothing.\n"
                                                        "Simple: Show changed opacities or blending modes.\n"
                                                        "Balanced: Show both opacity and blending mode if either are changed.\n"
                                                        "Detailed: Show both opacity and blending mode even if unchanged."));
    infoTextCombobox->insertItems(0, QStringList ({
        i18nc("@item:inlistbox Layer Docker blending info style", "None"),
        i18nc("@item:inlistbox Layer Docker blending info style", "Simple"),
        i18nc("@item:inlistbox Layer Docker blending info style", "Balanced"),
        i18nc("@item:inlistbox Layer Docker blending info style", "Detailed"),
    }));
    infoTextCombobox->setCurrentIndex((int)cfg.layerInfoTextStyle());
 
    QWidgetAction *cmbboxAction = new QWidgetAction(this);
    cmbboxAction->setDefaultWidget(infoTextCombobox);
    configureMenu->addAction(cmbboxAction);
    connect(infoTextCombobox, SIGNAL(currentIndexChanged(int)), SLOT(slotUpdateLayerInfoTextStyle()));
 
    // info-text opacity slider
    infoTextOpacitySlider = new KisSliderSpinBox(this);
    KisSpinBoxI18nHelper::setText(infoTextOpacitySlider,
                                  i18nc("{n} is the number value, % is the percent sign", "Opacity: {n}%"));
    infoTextOpacitySlider->setToolTip(i18nc("@item:tooltip", "Blending info text opacity"));
    // 55% is the opacity of nonvisible layer text
    infoTextOpacitySlider->setRange(55, 100);
    infoTextOpacitySlider->setMinimumSize(40, 20);
    infoTextOpacitySlider->setSingleStep(5);
    infoTextOpacitySlider->setPageStep(15);
    infoTextOpacitySlider->setValue(cfg.layerInfoTextOpacity());
    if (infoTextCombobox->currentIndex() == 0) {
        infoTextOpacitySlider->setDisabled(true);
    }
 
    sliderAction= new QWidgetAction(this);
    sliderAction->setDefaultWidget(infoTextOpacitySlider);
    configureMenu->addAction(sliderAction);
    connect(infoTextOpacitySlider, SIGNAL(valueChanged(int)), &m_infoTextOpacityCompressor, SLOT(start()));
    connect(&m_infoTextOpacityCompressor, SIGNAL(timeout()), SLOT(slotUpdateLayerInfoTextOpacity()));
 
    // info-text inline checkbox
    infoTextInlineChkbox = new QCheckBox(i18nc("@item:inmenu Layers Docker settings, checkbox", "Inline"), this);
    infoTextInlineChkbox->setChecked(cfg.useInlineLayerInfoText());
    infoTextInlineChkbox->setToolTip(i18nc("@item:tooltip", "If enabled, show blending info beside layer names.\n"
                                                            "If disabled, show below layer names (when enough space)."));
    if (infoTextCombobox->currentIndex() == 0) {
        infoTextInlineChkbox->setDisabled(true);
    }
 
    QWidgetAction *chkboxAction = new QWidgetAction(this);
    chkboxAction->setDefaultWidget(infoTextInlineChkbox);
    configureMenu->addAction(chkboxAction);
    connect(infoTextInlineChkbox, SIGNAL(stateChanged(int)), SLOT(slotUpdateUseInlineLayerInfoText()));
 
    layerSelectionCheckBox = new QCheckBox(
        i18nc("@item:inmenu Layers Docker settings, checkbox", "Checkbox for Selecting Layers"), this);
    layerSelectionCheckBox->setToolTip(i18nc("@item:tooltip", "Show checkbox to select/unselect layers."));
    layerSelectionCheckBox->setChecked(cfg.useLayerSelectionCheckbox());
 
    QWidgetAction *layerSelectionAction = new QWidgetAction(this);
    layerSelectionAction->setDefaultWidget(layerSelectionCheckBox);
    configureMenu->addAction(layerSelectionAction);
    connect(layerSelectionCheckBox, SIGNAL(stateChanged(int)), SLOT(slotUpdateUseLayerSelectionCheckbox()));
}

References KisAction::ACTIVE_IMAGE, KisLayerFilterWidget::filteringOptionsChanged(), KisLayerFilterWidget::getActiveColors(), KisLayerFilterWidget::hasTextFilter(), indentationSlider, infoTextCombobox, infoTextInlineChkbox, infoTextOpacitySlider, KisLayerFilterWidget::isCurrentlyFiltering(), layerFilterWidget, KisConfig::layerInfoTextOpacity(), KisConfig::layerInfoTextStyle(), layerSelectionCheckBox, KisConfig::layerThumbnailSize(), KisConfig::layerTreeIndentation(), KisIconUtils::loadIcon(), m_colorLabelCompressor, m_colorSelector, m_colorSelectorAction, m_filteringModel, m_infoTextOpacityCompressor, m_newLayerMenu, m_nodeModel, m_nodeOpacityCompressor, m_opLayerMenu, m_showGlobalSelectionMask, m_thumbnailSizeCompressor, m_treeIndentationCompressor, m_wdgLayerBox, palette, selectionChanged(), KisAction::setActivationFlags(), KisSliderSpinBox::setPageStep(), KisSliderSpinBox::setRange(), KisSpinBoxI18nHelper::setText(), KisSliderSpinBox::setValue(), KisConfig::showGlobalSelection(), KisNodeFilterProxyModel::sigBeforeBeginRemoveRows(), KisConfig::sliderLabels(), slotAdjustCurrentBeforeRemoveRows(), slotCollapsed(), slotColorLabelChanged(), slotCompositeOpChanged(), slotContextMenuRequested(), slotEditGlobalSelection(), slotExpanded(), slotForgetAboutSavedNodeBeforeEditSelectionMode(), slotModelReset(), slotNodeCollapsedChanged(), slotOpacityChanged(), slotOpacitySliderMoved(), slotUpdateIcons(), slotUpdateLayerInfoTextOpacity(), slotUpdateLayerInfoTextStyle(), slotUpdateThumbnailIconSize(), slotUpdateTreeIndentation(), slotUpdateUseInlineLayerInfoText(), slotUpdateUseLayerSelectionCheckbox(), thumbnailSizeSlider, updateAvailableLabels(), updateLayerFiltering(), updateUI(), KisConfig::useInlineLayerInfoText(), and KisConfig::useLayerSelectionCheckbox().

~LayerBox()

LayerBox::~LayerBox ( )

override

Definition at line 439 of file LayerBox.cpp.

{
    delete m_wdgLayerBox;
}

References m_wdgLayerBox.

Member Function Documentation

addActionToMenu()

void LayerBox::addActionToMenu ( QMenu * menu, const QString & id )

inlineprivate

Definition at line 141 of file LayerBox.cpp.

{
    if (m_canvas) {
        menu->addAction(m_canvas->viewManager()->actionManager()->actionByName(id));
    }
}

References m_canvas.

connectActionToButton()

void LayerBox::connectActionToButton ( KisViewManager * view, QAbstractButton * button, const QString & id )

inlineprivate

Definition at line 128 of file LayerBox.cpp.

{
    if (!viewManager || !button) return;
 
    KisAction *action = viewManager->actionManager()->actionByName(id);
 
    if (!action) return;
 
    connect(button, SIGNAL(clicked()), action, SLOT(trigger()));
    connect(action, SIGNAL(sigEnableSlaves(bool)), button, SLOT(setEnabled(bool)));
    connect(viewManager->mainWindowAsQWidget(), SIGNAL(themeChanged()), this, SLOT(slotUpdateIcons()));
}

References KisActionManager::actionByName(), KisViewManager::actionManager(), button(), KisViewManager::mainWindowAsQWidget(), and slotUpdateIcons().

convertOpacityToInt()

qint32 LayerBox::convertOpacityToInt ( qreal opacity )

private

Scales opacity from the range 0...100 to the integer range 0...255

Definition at line 148 of file LayerBox.cpp.

{
    return qMin(255, int(opacity * 2.55 + 0.5));
}

findNonHidableNode()

KisNodeSP LayerBox::findNonHidableNode ( KisNodeSP startNode )

private

Definition at line 923 of file LayerBox.cpp.

{
    if (KisNodeManager::isNodeHidden(startNode, true) &&
            startNode->parent() &&
            !startNode->parent()->parent()) {
 
 
        KisNodeSP node = startNode->prevSibling();
        while (node && KisNodeManager::isNodeHidden(node, true)) {
            node = node->prevSibling();
        }
 
        if (!node) {
            node = startNode->nextSibling();
            while (node && KisNodeManager::isNodeHidden(node, true)) {
                node = node->nextSibling();
            }
        }
 
        if (!node) {
            node = m_image->root()->lastChild();
            while (node && KisNodeManager::isNodeHidden(node, true)) {
                node = node->prevSibling();
            }
        }
 
        KIS_ASSERT_RECOVER_NOOP(node && "cannot activate any node!");
        startNode = node;
    }
 
    return startNode;
}

References KisNodeManager::isNodeHidden(), KIS_ASSERT_RECOVER_NOOP, KisNode::lastChild(), m_image, KisNode::nextSibling(), KisNode::parent, KisNode::prevSibling(), and KisNodeFacade::root.

hideEvent()

void LayerBox::hideEvent ( QHideEvent * event )

overrideprotected

Definition at line 659 of file LayerBox.cpp.

{
    QDockWidget::hideEvent(event);
    m_nodeModel->setIdleTaskManager(0);
}

References m_nodeModel.

imageChanged

void LayerBox::imageChanged ( )

signal

notifyImageDeleted

void LayerBox::notifyImageDeleted ( )

privateslot

Definition at line 665 of file LayerBox.cpp.

{
    setCanvas(0);
}

References setCanvas().

observerName()

QString LayerBox::observerName ( )

inlineoverridevirtual

Reimplemented from KoCanvasObserverBase.

Definition at line 72 of file LayerBox.h.

{ return "LayerBox"; }

selectionChanged

void LayerBox::selectionChanged ( const QModelIndexList & selection )

privateslot

When the user clears the extended selection by clicking on the empty area of the docker, the selection should be reset on to the active layer, which might be even unselected(!).

Definition at line 1040 of file LayerBox.cpp.

{
    if (!m_nodeManager) return;
 
    if (selection.isEmpty() && m_nodeManager->activeNode()) {
        QModelIndex selectedIndex =
                m_filteringModel->indexFromNode(m_nodeManager->activeNode());
 
        m_wdgLayerBox->listLayers->selectionModel()->
                setCurrentIndex(selectedIndex, QItemSelectionModel::ClearAndSelect);
        return;
    }
 
    QList<KisNodeSP> selectedNodes;
    Q_FOREACH (const QModelIndex &idx, selection) {
        // Precaution because node manager doesn't like duplicates in that list.
        // NodeView Selection behavior is SelectRows, although currently only column 0 allows selections.
        if (idx.column() != 0) {
            continue;
        }
        selectedNodes << m_filteringModel->nodeFromIndex(idx);
    }
 
    m_nodeManager->slotSetSelectedNodes(selectedNodes);
    updateUI();
}

References m_filteringModel, m_nodeManager, m_wdgLayerBox, and updateUI().

setCanvas()

void LayerBox::setCanvas ( KoCanvasBase * canvas )

overridevirtual

re-implement this method in your canvas observer. It will be called whenever a canvas becomes active. Note that you are responsible for not connecting more than one time to the signals of a canvas or any of the QObjects you can access through the canvas.

Implements KoCanvasObserverBase.

Definition at line 539 of file LayerBox.cpp.

{
    if (m_canvas == canvas)
        return;
 
    setEnabled(canvas != 0);
 
    if (m_canvas) {
        m_canvas->disconnectCanvasObserver(this);
        m_nodeModel->setIdleTaskManager(0);
        m_nodeModel->setDummiesFacade(0, 0, 0, 0, 0);
        m_selectionActionsAdapter.reset();
 
        if (m_image) {
            KisImageAnimationInterface *animation = m_image->animationInterface();
            animation->disconnect(this);
        }
 
        disconnect(m_image, 0, this, 0);
        disconnect(m_nodeManager, 0, this, 0);
        disconnect(m_nodeModel, 0, m_nodeManager, 0);
        m_nodeManager->slotSetSelectedNodes(KisNodeList());
    }
 
    m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
    if (m_canvas) {
        m_image = m_canvas->image();
        Q_EMIT imageChanged();
 
        KisDocument* doc = static_cast<KisDocument*>(m_canvas->imageView()->document());
        KisShapeController *kritaShapeController =
                dynamic_cast<KisShapeController*>(doc->shapeController());
        KisDummiesFacadeBase *kritaDummiesFacade =
                static_cast<KisDummiesFacadeBase*>(kritaShapeController);
 
 
        m_selectionActionsAdapter.reset(new KisSelectionActionsAdapter(m_canvas->viewManager()->selectionManager()));
        m_nodeModel->setDummiesFacade(kritaDummiesFacade,
                                      m_image,
                                      kritaShapeController,
                                      m_selectionActionsAdapter.data(),
                                      m_nodeManager);
 
        if (isVisible()) {
            m_nodeModel->setIdleTaskManager(m_canvas->viewManager()->idleTasksManager());
        }
 
        connect(m_image, SIGNAL(sigAboutToBeDeleted()), SLOT(notifyImageDeleted()));
        connect(m_image, SIGNAL(sigNodeCollapsedChanged()), SLOT(slotNodeCollapsedChanged()));
 
        // cold start
        if (m_nodeManager) {
            setCurrentNode(m_nodeManager->activeNode());
            // Connection KisNodeManager -> LayerBox
            connect(m_nodeManager, SIGNAL(sigUiNeedChangeActiveNode(KisNodeSP)),
                    this, SLOT(setCurrentNode(KisNodeSP)));
 
            connect(m_nodeManager,
                    SIGNAL(sigUiNeedChangeSelectedNodes(QList<KisNodeSP>)),
                    SLOT(slotNodeManagerChangedSelection(QList<KisNodeSP>)));
        }
        else {
            setCurrentNode(m_canvas->imageView()->currentNode());
        }
 
        // Connection LayerBox -> KisNodeManager (isolate layer)
        connect(m_nodeModel, SIGNAL(toggleIsolateActiveNode()),
                m_nodeManager, SLOT(toggleIsolateActiveNode()));
 
        KisImageAnimationInterface *animation = m_image->animationInterface();
        connect(animation, &KisImageAnimationInterface::sigUiTimeChanged, this, &LayerBox::slotImageTimeChanged);
 
        expandNodesRecursively(m_image->rootLayer(), m_filteringModel, m_wdgLayerBox->listLayers);
        m_wdgLayerBox->listLayers->scrollTo(m_wdgLayerBox->listLayers->currentIndex());
        updateAvailableLabels();
 
        addActionToMenu(m_newLayerMenu, "add_new_paint_layer");
        addActionToMenu(m_newLayerMenu, "add_new_group_layer");
        addActionToMenu(m_newLayerMenu, "add_new_clone_layer");
        addActionToMenu(m_newLayerMenu, "add_new_shape_layer");
        addActionToMenu(m_newLayerMenu, "add_new_adjustment_layer");
        addActionToMenu(m_newLayerMenu, "add_new_fill_layer");
        addActionToMenu(m_newLayerMenu, "add_new_file_layer");
        m_newLayerMenu->addSeparator();
        addActionToMenu(m_newLayerMenu, "add_new_transparency_mask");
        addActionToMenu(m_newLayerMenu, "add_new_filter_mask");
        addActionToMenu(m_newLayerMenu, "add_new_fast_color_overlay_mask");
        addActionToMenu(m_newLayerMenu, "add_new_colorize_mask");
        addActionToMenu(m_newLayerMenu, "add_new_transform_mask");
        addActionToMenu(m_newLayerMenu, "add_new_selection_mask");
    }
}

References addActionToMenu(), KisImage::animationInterface(), expandNodesRecursively(), imageChanged(), m_canvas, m_filteringModel, m_image, m_newLayerMenu, m_nodeManager, m_nodeModel, m_selectionActionsAdapter, m_wdgLayerBox, notifyImageDeleted(), KisImage::rootLayer(), setCurrentNode(), KisDocument::shapeController, KisImageAnimationInterface::sigUiTimeChanged(), slotImageTimeChanged(), slotNodeCollapsedChanged(), slotNodeManagerChangedSelection(), and updateAvailableLabels().

setCurrentNode

void LayerBox::setCurrentNode ( KisNodeSP node )

privateslot

This method is called only when non-GUI code requested the change of the current node

setCanvas() calls to node managed and layer box are coming out-of-sync, so it might happen that setCurrentNode() call will arrive with a node from a different image. We should check that and ignore such calls.

TODO: make bootstrapping of layers-related structures a bit more straight-forward. We need to have a single source of truth for the "active layer", and all the initialization should happen in one direction without cycles.

Definition at line 740 of file LayerBox.cpp.

{
    if (node && m_image && node->graphListener() != m_image.data()) {
        return;
    }
 
    m_filteringModel->setActiveNode(node);
 
    QModelIndex index = node ? m_filteringModel->indexFromNode(node) : QModelIndex();
    m_filteringModel->setData(index, true, KisNodeModel::ActiveRole);
    updateUI();
}

References KisNodeModel::ActiveRole, KisWeakSharedPtr< T >::data(), KisNode::graphListener, m_filteringModel, m_image, and updateUI().

setViewManager()

void LayerBox::setViewManager ( KisViewManager * kisview )

overridevirtual

reimplemented from KisMainwindowObserver

Implements KisMainwindowObserver.

Definition at line 482 of file LayerBox.cpp.

{
    m_nodeManager = kisview->nodeManager();
 
    if (m_nodeManager) {
        connect(m_nodeManager, SIGNAL(sigNodeActivated(KisNodeSP)), SLOT(slotForgetAboutSavedNodeBeforeEditSelectionMode()));
    }
 
    kisview->actionManager()->
            addAction(m_showGlobalSelectionMask->objectName(),
                      m_showGlobalSelectionMask);
 
    connect(m_wdgLayerBox->bnAdd, SIGNAL(clicked()), this, SLOT(slotAddLayerBnClicked()));
 
    connectActionToButton(kisview, m_wdgLayerBox->bnDuplicate, "duplicatelayer");
 
    KisActionManager *actionManager = kisview->actionManager();
 
    KisAction *action = actionManager->createAction("RenameCurrentLayer");
    Q_ASSERT(action);
    connect(action, SIGNAL(triggered()), this, SLOT(slotRenameCurrentNode()));
 
    m_propertiesAction = actionManager->createAction("layer_properties");
    Q_ASSERT(m_propertiesAction);
    new SyncButtonAndAction(m_propertiesAction, m_wdgLayerBox->bnProperties, this);
    connect(m_propertiesAction, SIGNAL(triggered()), this, SLOT(slotPropertiesClicked()));
 
    connect(m_opLayerMenu, SIGNAL(aboutToShow()), this, SLOT(slotLayerOpMenuOpened()));
 
    // It's necessary to clear the layer operations menu when it closes, else
    // the color selector can't be shared with the right-click context menu
    connect(m_opLayerMenu, SIGNAL(aboutToHide()), this, SLOT(slotLayerOpMenuClosed()));
 
    m_removeAction = actionManager->createAction("remove_layer");
    Q_ASSERT(m_removeAction);
    new SyncButtonAndAction(m_removeAction, m_wdgLayerBox->bnDelete, this);
    connect(m_removeAction, SIGNAL(triggered()), this, SLOT(slotRmClicked()));
 
    action = actionManager->createAction("move_layer_up");
    Q_ASSERT(action);
    new SyncButtonAndAction(action, m_wdgLayerBox->bnRaise, this);
    connect(action, SIGNAL(triggered()), this, SLOT(slotRaiseClicked()));
 
    action = actionManager->createAction("move_layer_down");
    Q_ASSERT(action);
    new SyncButtonAndAction(action, m_wdgLayerBox->bnLower, this);
    connect(action, SIGNAL(triggered()), this, SLOT(slotLowerClicked()));
 
    m_changeCloneSourceAction = actionManager->createAction("set-copy-from");
    Q_ASSERT(m_changeCloneSourceAction);
    connect(m_changeCloneSourceAction, &KisAction::triggered,
            this, &LayerBox::slotChangeCloneSourceClicked);
 
    m_layerToggleSolo = actionManager->createAction("toggle_layer_soloing");
    connect(m_layerToggleSolo, SIGNAL(triggered(bool)), this, SLOT(toggleActiveLayerSolo()));
}

References KisViewManager::actionManager(), connectActionToButton(), KisActionManager::createAction(), m_changeCloneSourceAction, m_layerToggleSolo, m_nodeManager, m_opLayerMenu, m_propertiesAction, m_removeAction, m_showGlobalSelectionMask, m_wdgLayerBox, KisViewManager::nodeManager(), slotAddLayerBnClicked(), slotChangeCloneSourceClicked(), slotForgetAboutSavedNodeBeforeEditSelectionMode(), slotLayerOpMenuClosed(), slotLayerOpMenuOpened(), slotLowerClicked(), slotPropertiesClicked(), slotRaiseClicked(), slotRenameCurrentNode(), slotRmClicked(), and toggleActiveLayerSolo().

showEvent()

void LayerBox::showEvent ( QShowEvent * event )

overrideprotected

Definition at line 650 of file LayerBox.cpp.

{
    QDockWidget::showEvent(event);
 
    if (m_canvas) {
        m_nodeModel->setIdleTaskManager(m_canvas->viewManager()->idleTasksManager());
    }
}

References m_canvas, and m_nodeModel.

slotAddLayerBnClicked

void LayerBox::slotAddLayerBnClicked ( )

privateslot

Definition at line 467 of file LayerBox.cpp.

{
    if (m_canvas) {
        KisNodeList nodes = m_nodeManager->selectedNodes();
 
        if (nodes.size() == 1) {
            KisAction *action = m_canvas->viewManager()->actionManager()->actionByName("add_new_paint_layer");
            action->trigger();
        } else {
            KisAction *action = m_canvas->viewManager()->actionManager()->actionByName("create_quick_group");
            action->trigger();
        }
    }
}

References m_canvas, and m_nodeManager.

slotAdjustCurrentBeforeRemoveRows

void LayerBox::slotAdjustCurrentBeforeRemoveRows ( const QModelIndex & parent, int first, int last )

privateslot

Qt has changed its behavior when deleting an item. Previously the selection priority was on the next item in the list, and now it has changed to the previous item. Here we just adjust the selected item after the node removal.

This method is called right before the Qt's beginRemoveRows() is called, that is we make sure that Qt will never have to adjust the position of the removed cursor.

See bug: https://bugs.kde.org/show_bug.cgi?id=345601

Definition at line 1072 of file LayerBox.cpp.

{
    QModelIndex currentIndex = m_wdgLayerBox->listLayers->currentIndex();
    QAbstractItemModel *model = m_filteringModel;
 
    if (currentIndex.isValid() && parent == currentIndex.parent()
            && currentIndex.row() >= start && currentIndex.row() <= end) {
        QModelIndex old = currentIndex;
 
        if (model && end < model->rowCount(parent) - 1) // there are rows left below the change
            currentIndex = model->index(end + 1, old.column(), parent);
        else if (model && start > 0) // there are rows left above the change
            currentIndex = model->index(start - 1, old.column(), parent);
        else // there are no rows left in the table
            currentIndex = QModelIndex();
 
        if (currentIndex.isValid() && currentIndex != old) {
            m_wdgLayerBox->listLayers->setCurrentIndex(currentIndex);
        }
    }
}

References m_filteringModel, and m_wdgLayerBox.

slotChangeCloneSourceClicked

void LayerBox::slotChangeCloneSourceClicked ( )

privateslot

Definition at line 858 of file LayerBox.cpp.

{
    if (!m_canvas) return;
    m_nodeManager->changeCloneSource();
}

References m_canvas, and m_nodeManager.

slotCollapsed

void LayerBox::slotCollapsed ( const QModelIndex & index )

privateslot

Definition at line 886 of file LayerBox.cpp.

{
    KisNodeSP node = m_filteringModel->nodeFromIndex(index);
    if (node) {
        node->setCollapsed(true);
    }
}

References m_filteringModel, and KisBaseNode::setCollapsed().

slotColorLabelChanged

void LayerBox::slotColorLabelChanged ( int index )

privateslot

Definition at line 1135 of file LayerBox.cpp.

{
    KisNodeList selectedNodes = m_nodeManager->selectedNodes();
 
    Q_FOREACH(KisNodeSP selectedNode, selectedNodes) {
        //Always apply label to selected nodes..
        selectedNode->setColorLabelIndex(label);
 
        //Apply label only to unlabelled children..
        KisNodeList children = selectedNode->childNodes(QStringList(), KoProperties());
 
        auto applyLabelFunc =
                [label](KisNodeSP child) {
            if (child->colorLabelIndex() == 0) {
                child->setColorLabelIndex(label);
            }
        };
 
        Q_FOREACH(KisNodeSP child, children) {
            KisLayerUtils::recursiveApplyNodes(child, applyLabelFunc);
        }
    }
}

References KisNode::childNodes(), m_nodeManager, KisLayerUtils::recursiveApplyNodes(), and KisBaseNode::setColorLabelIndex().

slotCompositeOpChanged

void LayerBox::slotCompositeOpChanged ( int index )

privateslot

Definition at line 864 of file LayerBox.cpp.

{
    Q_UNUSED(index);
    if (!m_canvas) return;
 
    QString compositeOp = m_wdgLayerBox->cmbComposite->selectedCompositeOp().id();
    m_nodeManager->nodeCompositeOpChanged(m_nodeManager->activeColorSpace()->compositeOp(compositeOp));
}

References m_canvas, m_nodeManager, and m_wdgLayerBox.

slotContextMenuRequested

void LayerBox::slotContextMenuRequested ( const QPoint & pos, const QModelIndex & index )

privateslot

Definition at line 807 of file LayerBox.cpp.

{
    KisNodeList nodes = m_nodeManager->selectedNodes();
    KisNodeSP activeNode = m_nodeManager->activeNode();
    if (nodes.isEmpty() || !activeNode) return;
 
    if (m_canvas) {
        QMenu menu;
        updateLayerOpMenu(index, menu);
        menu.exec(pos);
    }
}

References m_canvas, m_nodeManager, and updateLayerOpMenu().

slotEditGlobalSelection

void LayerBox::slotEditGlobalSelection ( bool showSelections )

privateslot

Definition at line 956 of file LayerBox.cpp.

{
    KisNodeSP lastActiveNode = m_nodeManager->activeNode();
    KisNodeSP activateNode = lastActiveNode;
    KisSelectionMaskSP globalSelectionMask;
 
    if (!showSelections) {
        activateNode =
            m_savedNodeBeforeEditSelectionMode ?
                KisNodeSP(m_savedNodeBeforeEditSelectionMode) :
                findNonHidableNode(activateNode);
    }
 
    m_nodeModel->setShowGlobalSelection(showSelections);
 
    globalSelectionMask = m_image->rootLayer()->selectionMask();
 
    // try to find deactivated, but visible masks
    if (!globalSelectionMask) {
        KoProperties properties;
        properties.setProperty("visible", true);
        QList<KisNodeSP> masks = m_image->rootLayer()->childNodes(QStringList("KisSelectionMask"), properties);
        if (!masks.isEmpty()) {
            globalSelectionMask = dynamic_cast<KisSelectionMask*>(masks.first().data());
        }
    }
 
    // try to find at least any selection mask
    if (!globalSelectionMask) {
        KoProperties properties;
        QList<KisNodeSP> masks = m_image->rootLayer()->childNodes(QStringList("KisSelectionMask"), properties);
        if (!masks.isEmpty()) {
            globalSelectionMask = dynamic_cast<KisSelectionMask*>(masks.first().data());
        }
    }
 
    if (globalSelectionMask) {
        if (showSelections) {
            activateNode = globalSelectionMask;
        }
    }
 
    if (activateNode != lastActiveNode) {
        m_nodeManager->slotNonUiActivatedNode(activateNode);
    } else if (lastActiveNode) {
        setCurrentNode(lastActiveNode);
    }
 
    if (showSelections && !globalSelectionMask) {
        KisProcessingApplicator applicator(m_image, 0,
                                           KisProcessingApplicator::NONE,
                                           KisImageSignalVector(),
                                           kundo2_i18n("Quick Selection Mask"));
 
        applicator.applyCommand(
            new KisLayerUtils::KeepNodesSelectedCommand(
                m_nodeManager->selectedNodes(), KisNodeList(),
                lastActiveNode, 0, m_image, false),
            KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
        applicator.applyCommand(new KisSetEmptyGlobalSelectionCommand(m_image),
                                KisStrokeJobData::SEQUENTIAL,
                                KisStrokeJobData::EXCLUSIVE);
        applicator.applyCommand(new KisLayerUtils::SelectGlobalSelectionMask(m_image),
                                KisStrokeJobData::SEQUENTIAL,
                                KisStrokeJobData::EXCLUSIVE);
 
        applicator.end();
    } else if (!showSelections &&
               globalSelectionMask &&
               globalSelectionMask->selection()->selectedRect().isEmpty()) {
 
        KisProcessingApplicator applicator(m_image, 0,
                                           KisProcessingApplicator::NONE,
                                           KisImageSignalVector(),
                                           kundo2_i18n("Cancel Quick Selection Mask"));
        applicator.applyCommand(new KisSetGlobalSelectionCommand(m_image, 0), KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
        applicator.end();
    }
 
    if (showSelections) {
        m_savedNodeBeforeEditSelectionMode = lastActiveNode;
    }
}

References KisProcessingApplicator::applyCommand(), KisNode::childNodes(), KisProcessingApplicator::end(), KisStrokeJobData::EXCLUSIVE, findNonHidableNode(), kundo2_i18n(), m_image, m_nodeManager, m_nodeModel, m_savedNodeBeforeEditSelectionMode, KisProcessingApplicator::NONE, KisImage::rootLayer(), KisSelection::selectedRect(), KisMask::selection, KisLayer::selectionMask(), KisStrokeJobData::SEQUENTIAL, setCurrentNode(), and KoProperties::setProperty().

slotExpanded

void LayerBox::slotExpanded ( const QModelIndex & index )

privateslot

Definition at line 894 of file LayerBox.cpp.

{
    KisNodeSP node = m_filteringModel->nodeFromIndex(index);
    if (node) {
        node->setCollapsed(false);
    }
}

References m_filteringModel, and KisBaseNode::setCollapsed().

slotForgetAboutSavedNodeBeforeEditSelectionMode

void LayerBox::slotForgetAboutSavedNodeBeforeEditSelectionMode ( )

privateslot

Definition at line 1293 of file LayerBox.cpp.

{
    m_savedNodeBeforeEditSelectionMode = 0;
}

References m_savedNodeBeforeEditSelectionMode.

slotImageTimeChanged

void LayerBox::slotImageTimeChanged ( int time )

privateslot

Definition at line 1171 of file LayerBox.cpp.

{
    Q_UNUSED(time);
    updateUI();
}

References updateUI().

slotLayerOpMenuClosed

void LayerBox::slotLayerOpMenuClosed ( )

privateslot

Definition at line 852 of file LayerBox.cpp.

{
    if (!m_canvas) return;
    m_opLayerMenu->clear();
}

References m_canvas, and m_opLayerMenu.

slotLayerOpMenuOpened

void LayerBox::slotLayerOpMenuOpened ( )

privateslot

Definition at line 846 of file LayerBox.cpp.

{
    if (!m_canvas) return;
    updateLayerOpMenu(m_wdgLayerBox->listLayers->currentIndex(), *m_opLayerMenu);
}

References m_canvas, m_opLayerMenu, m_wdgLayerBox, and updateLayerOpMenu().

slotLowerClicked

void LayerBox::slotLowerClicked ( )

privateslot

Definition at line 832 of file LayerBox.cpp.

{
    if (!m_canvas) return;
    m_nodeManager->lowerNode();
}

References m_canvas, and m_nodeManager.

slotModelReset

void LayerBox::slotModelReset ( )

privateslot

Definition at line 763 of file LayerBox.cpp.

{
    if(m_nodeModel->hasDummiesFacade()) {
        QItemSelection selection;
        Q_FOREACH (const KisNodeSP node, m_nodeManager->selectedNodes()) {
            const QModelIndex &idx = m_filteringModel->indexFromNode(node);
            if(idx.isValid()){
                QItemSelectionRange selectionRange(idx);
                selection << selectionRange;
            }
        }
 
        m_wdgLayerBox->listLayers->selectionModel()->select(selection, QItemSelectionModel::ClearAndSelect);
    }
 
    updateUI();
}

References m_filteringModel, m_nodeManager, m_nodeModel, m_wdgLayerBox, and updateUI().

slotNodeCollapsedChanged

void LayerBox::slotNodeCollapsedChanged ( )

privateslot

Definition at line 911 of file LayerBox.cpp.

{
    if (m_nodeModel->hasDummiesFacade()) {
        expandNodesRecursively(m_image->rootLayer(), m_filteringModel, m_wdgLayerBox->listLayers);
    }
}

References expandNodesRecursively(), m_filteringModel, m_image, m_nodeModel, m_wdgLayerBox, and KisImage::rootLayer().

slotNodeManagerChangedSelection

void LayerBox::slotNodeManagerChangedSelection ( const QList< KisNodeSP > & nodes )

privateslot

Definition at line 1107 of file LayerBox.cpp.

{
    if (!m_nodeManager) return;
 
    QModelIndexList newSelection;
    Q_FOREACH(KisNodeSP node, nodes) {
        newSelection << m_filteringModel->indexFromNode(node);
    }
 
    QItemSelectionModel *model = m_wdgLayerBox->listLayers->selectionModel();
 
    if (KritaUtils::compareListsUnordered(newSelection, model->selectedRows())) {
        return;
    }
 
    QItemSelection selection;
    Q_FOREACH(const QModelIndex &idx, newSelection) {
        selection.select(idx, idx);
    }
 
    model->select(selection, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
}

References KritaUtils::compareListsUnordered(), m_filteringModel, m_nodeManager, and m_wdgLayerBox.

slotOpacityChanged

void LayerBox::slotOpacityChanged ( )

privateslot

Definition at line 873 of file LayerBox.cpp.

{
    if (!m_canvas) return;
    m_nodeManager->setNodeOpacity(m_changedOpacityNode, convertOpacityToInt(m_newOpacity));
}

References convertOpacityToInt(), m_canvas, m_changedOpacityNode, m_newOpacity, and m_nodeManager.

slotOpacitySliderMoved

void LayerBox::slotOpacitySliderMoved ( qreal opacity )

privateslot

Definition at line 879 of file LayerBox.cpp.

{
    m_newOpacity = opacity;
    m_changedOpacityNode = m_activeNode;
    m_nodeOpacityCompressor.start();
}

References m_activeNode, m_changedOpacityNode, m_newOpacity, m_nodeOpacityCompressor, and KisSignalCompressor::start().

slotPropertiesClicked

void LayerBox::slotPropertiesClicked ( )

privateslot

Definition at line 838 of file LayerBox.cpp.

{
    if (!m_canvas) return;
    if (KisNodeSP active = m_nodeManager->activeNode()) {
        m_nodeManager->nodeProperties(active);
    }
}

References m_canvas, and m_nodeManager.

slotRaiseClicked

void LayerBox::slotRaiseClicked ( )

privateslot

Definition at line 826 of file LayerBox.cpp.

{
    if (!m_canvas) return;
    m_nodeManager->raiseNode();
}

References m_canvas, and m_nodeManager.

slotRenameCurrentNode

void LayerBox::slotRenameCurrentNode ( )

privateslot

Definition at line 1130 of file LayerBox.cpp.

{
    m_wdgLayerBox->listLayers->edit(m_wdgLayerBox->listLayers->currentIndex());
}

References m_wdgLayerBox.

slotRmClicked

void LayerBox::slotRmClicked ( )

privateslot

Definition at line 820 of file LayerBox.cpp.

{
    if (!m_canvas) return;
    m_nodeManager->removeNode();
}

References m_canvas, and m_nodeManager.

slotSelectOpaque

void LayerBox::slotSelectOpaque ( )

privateslot

Definition at line 902 of file LayerBox.cpp.

{
    if (!m_canvas) return;
    QAction *action = m_canvas->viewManager()->actionManager()->actionByName("selectopaque");
    if (action) {
        action->trigger();
    }
}

References m_canvas.

slotSetCompositeOp

void LayerBox::slotSetCompositeOp ( const KoCompositeOp * compositeOp )

privateslot

Definition at line 781 of file LayerBox.cpp.

{
    KoID opId = KoCompositeOpRegistry::instance().getKoID(compositeOp->id());
 
    m_wdgLayerBox->cmbComposite->blockSignals(true);
    m_wdgLayerBox->cmbComposite->selectCompositeOp(opId);
    m_wdgLayerBox->cmbComposite->blockSignals(false);
}

References KoCompositeOpRegistry::getKoID(), KoCompositeOp::id, KoCompositeOpRegistry::instance(), and m_wdgLayerBox.

slotSetOpacity

void LayerBox::slotSetOpacity ( double opacity )

privateslot

Definition at line 791 of file LayerBox.cpp.

{
    Q_ASSERT(opacity >= 0 && opacity <= 100);
    m_wdgLayerBox->doubleOpacity->blockSignals(true);
    m_wdgLayerBox->doubleOpacity->setValue(opacity);
    m_wdgLayerBox->doubleOpacity->blockSignals(false);
}

References m_wdgLayerBox.

slotUpdateIcons

void LayerBox::slotUpdateIcons ( )

privateslot

Definition at line 1298 of file LayerBox.cpp.

                               {
    m_wdgLayerBox->bnAdd->setIcon(KisIconUtils::loadIcon("addlayer"));
    m_wdgLayerBox->bnRaise->setIcon(KisIconUtils::loadIcon("arrowup"));
    m_wdgLayerBox->bnDelete->setIcon(KisIconUtils::loadIcon("deletelayer"));
    m_wdgLayerBox->bnLower->setIcon(KisIconUtils::loadIcon("arrowdown"));
    m_wdgLayerBox->bnProperties->setIcon(KisIconUtils::loadIcon("properties"));
    m_wdgLayerBox->bnDuplicate->setIcon(KisIconUtils::loadIcon("duplicatelayer"));
    m_wdgLayerBox->configureLayerDockerToolbar->setIcon(KisIconUtils::loadIcon("view-choose"));
 
    // call child function about needing to update icons
    m_wdgLayerBox->listLayers->slotUpdateIcons();
}

References KisIconUtils::loadIcon(), and m_wdgLayerBox.

slotUpdateLayerInfoTextOpacity

void LayerBox::slotUpdateLayerInfoTextOpacity ( )

privateslot

Definition at line 1365 of file LayerBox.cpp.

{
    KisConfig cfg(false);
    if (infoTextOpacitySlider->value() == cfg.layerInfoTextOpacity()) {
        return;
    }
    cfg.setLayerInfoTextOpacity(infoTextOpacitySlider->value());
    m_wdgLayerBox->listLayers->slotConfigurationChanged();
    m_wdgLayerBox->listLayers->viewport()->update();
}

References infoTextOpacitySlider, KisConfig::layerInfoTextOpacity(), m_wdgLayerBox, and KisConfig::setLayerInfoTextOpacity().

slotUpdateLayerInfoTextStyle

void LayerBox::slotUpdateLayerInfoTextStyle ( )

privateslot

Definition at line 1346 of file LayerBox.cpp.

{
    KisConfig cfg(false);
    if (infoTextCombobox->currentIndex() == cfg.layerInfoTextStyle()) {
        return;
    }
    cfg.setLayerInfoTextStyle((KisConfig::LayerInfoTextStyle)infoTextCombobox->currentIndex());
    m_wdgLayerBox->listLayers->slotConfigurationChanged();
    m_wdgLayerBox->listLayers->viewport()->update();
    if (infoTextCombobox->currentIndex() == 0) {
        infoTextOpacitySlider->setDisabled(true);
        infoTextInlineChkbox->setDisabled(true);
    }
    else {
        infoTextOpacitySlider->setDisabled(false);
        infoTextInlineChkbox->setDisabled(false);
    }
}

References infoTextCombobox, infoTextInlineChkbox, infoTextOpacitySlider, KisConfig::layerInfoTextStyle(), m_wdgLayerBox, and KisConfig::setLayerInfoTextStyle().

slotUpdateOpacitySlider

void LayerBox::slotUpdateOpacitySlider ( quint8 value )

privateslot

Definition at line 799 of file LayerBox.cpp.

                                                   {
    double percentage = value * 100.0 / 255.0;
 
    m_wdgLayerBox->doubleOpacity->blockSignals(true);
    m_wdgLayerBox->doubleOpacity->setValue(percentage);
    m_wdgLayerBox->doubleOpacity->blockSignals(false);
}

References m_wdgLayerBox, and value().

slotUpdateThumbnailIconSize

void LayerBox::slotUpdateThumbnailIconSize ( )

privateslot

Definition at line 1327 of file LayerBox.cpp.

{
    KisConfig cfg(false);
    cfg.setLayerThumbnailSize(thumbnailSizeSlider->value());
 
    m_nodeModel->setPreferredThumnalSize(thumbnailSizeSlider->value());
    m_wdgLayerBox->listLayers->slotConfigurationChanged();
}

References m_nodeModel, m_wdgLayerBox, KisConfig::setLayerThumbnailSize(), and thumbnailSizeSlider.

slotUpdateTreeIndentation

void LayerBox::slotUpdateTreeIndentation ( )

privateslot

Definition at line 1336 of file LayerBox.cpp.

{
    KisConfig cfg(false);
    if (indentationSlider->value() == cfg.layerTreeIndentation()) {
        return;
    }
    cfg.setLayerTreeIndentation(indentationSlider->value());
    m_wdgLayerBox->listLayers->slotConfigurationChanged();
}

References indentationSlider, KisConfig::layerTreeIndentation(), m_wdgLayerBox, and KisConfig::setLayerTreeIndentation().

slotUpdateUseInlineLayerInfoText

void LayerBox::slotUpdateUseInlineLayerInfoText ( )

privateslot

Definition at line 1376 of file LayerBox.cpp.

{
    KisConfig cfg(false);
    if (infoTextInlineChkbox->isChecked() == cfg.useInlineLayerInfoText()) {
        return;
    }
    cfg.setUseInlineLayerInfoText(infoTextInlineChkbox->isChecked());
    m_wdgLayerBox->listLayers->slotConfigurationChanged();
    m_wdgLayerBox->listLayers->viewport()->update();
}

References infoTextInlineChkbox, m_wdgLayerBox, KisConfig::setUseInlineLayerInfoText(), and KisConfig::useInlineLayerInfoText().

slotUpdateUseLayerSelectionCheckbox

void LayerBox::slotUpdateUseLayerSelectionCheckbox ( )

privateslot

Definition at line 1388 of file LayerBox.cpp.

{
    KisConfig cfg(false);
    if (layerSelectionCheckBox->isChecked() == cfg.useLayerSelectionCheckbox()) {
        return;
    }
    cfg.setUseLayerSelectionCheckbox(layerSelectionCheckBox->isChecked());
    m_wdgLayerBox->listLayers->slotConfigurationChanged();
    m_wdgLayerBox->listLayers->viewport()->update();
}

References layerSelectionCheckBox, m_wdgLayerBox, KisConfig::setUseLayerSelectionCheckbox(), and KisConfig::useLayerSelectionCheckbox().

toggleActiveLayerSolo

void LayerBox::toggleActiveLayerSolo ( )

privateslot

Definition at line 1311 of file LayerBox.cpp.

                                     {
    NodeView* view = m_wdgLayerBox->listLayers;
    if (!view)
        return;
 
    KisNodeSP node = m_nodeManager->activeNode();
    if (!node)
        return;
 
    QModelIndex index = m_filteringModel->indexFromNode(node);
    if (!index.isValid())
        return;
 
    view->toggleSolo(index);
}

References m_filteringModel, m_nodeManager, m_wdgLayerBox, and NodeView::toggleSolo().

unsetCanvas()

void LayerBox::unsetCanvas ( )

overridevirtual

Re-implement to notify the observer that its canvas is no longer among the living. The daisies, it is pushing up. This means you don't have to disconnect, it's dead.

The old canvas should be deleted already, so if you stored a pointer to it, don't touch!

Note that currently there is a bug where in certain specific circumstances unsetCanvas can be called when it shouldn't, see for example KWStatisticsDocker for a workaround for this problem.

Implements KoCanvasObserverBase.

Definition at line 634 of file LayerBox.cpp.

{
    setEnabled(false);
    if (m_canvas) {
        m_newLayerMenu->clear();
    }
 
    m_filteringModel->unsetDummiesFacade();
    disconnect(m_image, 0, this, 0);
    disconnect(m_nodeManager, 0, this, 0);
    disconnect(m_nodeModel, 0, m_nodeManager, 0);
    m_nodeManager->slotSetSelectedNodes(KisNodeList());
 
    m_canvas = 0;
}

References m_canvas, m_filteringModel, m_image, m_newLayerMenu, m_nodeManager, and m_nodeModel.

updateAvailableLabels

void LayerBox::updateAvailableLabels ( )

privateslot

Definition at line 1159 of file LayerBox.cpp.

{
    if (!m_image) return;
    layerFilterWidget->updateColorLabels(m_image->root());
}

References layerFilterWidget, m_image, KisNodeFacade::root, and KisLayerFilterWidget::updateColorLabels().

updateLayerFiltering

void LayerBox::updateLayerFiltering ( )

privateslot

Definition at line 1165 of file LayerBox.cpp.

{
    m_filteringModel->setAcceptedLabels(layerFilterWidget->getActiveColors());
    m_filteringModel->setTextFilter(layerFilterWidget->getTextFilter());
}

References KisLayerFilterWidget::getActiveColors(), KisLayerFilterWidget::getTextFilter(), layerFilterWidget, and m_filteringModel.

updateLayerOpMenu

void LayerBox::updateLayerOpMenu ( const QModelIndex & index, QMenu & menu )

privateslot

Definition at line 1177 of file LayerBox.cpp.

                                                                      {
 
    KisNodeList nodes = m_nodeManager->selectedNodes();
    KisNodeSP activeNode = m_nodeManager->activeNode();
    const bool singleNode = nodes.size() == 1;
 
    if (index.isValid()) {
        menu.addAction(m_propertiesAction);
 
        KisLayerSP singleLayer = dynamic_cast<KisLayer*>(activeNode.data());
 
        if (singleLayer) {
            addActionToMenu(&menu, "layer_style");
 
            if (singleLayer->layerStyle()) {
                addActionToMenu(&menu, "copy_layer_style");
            }
 
            if (KisClipboard::instance()->hasLayerStyles()) {
                addActionToMenu(&menu, "paste_layer_style");
            }
        }
 
        Q_FOREACH(KisNodeSP node, nodes) {
            if (node && node->inherits("KisCloneLayer")) {
                menu.addAction(m_changeCloneSourceAction);
                break;
            }
        }
 
        {
            KisSignalsBlocker b(m_colorSelector->colorLabelSelector());
            m_colorSelector->colorLabelSelector()->setCurrentIndex(singleNode ? activeNode->colorLabelIndex() : -1);
        }
 
        menu.addAction(m_colorSelectorAction);
 
        menu.addSeparator();
 
        addActionToMenu(&menu, "cut_layer_clipboard");
        addActionToMenu(&menu, "copy_layer_clipboard");
        addActionToMenu(&menu, "paste_layer_from_clipboard");
        menu.addAction(m_removeAction);
        addActionToMenu(&menu, "duplicatelayer");
        addActionToMenu(&menu, "merge_layer");
        addActionToMenu(&menu, "new_from_visible");
 
        if (singleNode) {
            addActionToMenu(&menu, "flatten_image");
            addActionToMenu(&menu, "flatten_layer");
        }
 
        menu.addSeparator();
        QMenu *selectMenu = menu.addMenu(i18n("&Select"));
        addActionToMenu(selectMenu, "select_all_layers");
        addActionToMenu(selectMenu, "select_visible_layers");
        addActionToMenu(selectMenu, "select_invisible_layers");
        addActionToMenu(selectMenu, "select_locked_layers");
        addActionToMenu(selectMenu, "select_unlocked_layers");
        QMenu *groupMenu = menu.addMenu(i18nc("A group of layers", "&Group"));
        addActionToMenu(groupMenu, "create_quick_group");
        addActionToMenu(groupMenu, "create_quick_clipping_group");
        addActionToMenu(groupMenu, "quick_ungroup");
        QMenu *locksMenu = menu.addMenu(i18n("&Toggle Locks && Visibility"));
        addActionToMenu(locksMenu, "toggle_layer_visibility");
        addActionToMenu(locksMenu, "toggle_layer_lock");
        addActionToMenu(locksMenu, "toggle_layer_inherit_alpha");
        addActionToMenu(locksMenu, "toggle_layer_alpha_lock");
 
        if (singleNode) {
            QMenu *addLayerMenu = menu.addMenu(i18n("&Add"));
            addActionToMenu(addLayerMenu, "add_new_transparency_mask");
            addActionToMenu(addLayerMenu, "add_new_filter_mask");
            addActionToMenu(addLayerMenu, "add_new_fast_color_overlay_mask");
            addActionToMenu(addLayerMenu, "add_new_colorize_mask");
            addActionToMenu(addLayerMenu, "add_new_transform_mask");
            addActionToMenu(addLayerMenu, "add_new_selection_mask");
            addLayerMenu->addSeparator();
            addActionToMenu(addLayerMenu, "add_new_clone_layer");
 
            QMenu *convertToMenu = menu.addMenu(i18n("&Convert"));
            addActionToMenu(convertToMenu, "convert_to_paint_layer");
            addActionToMenu(convertToMenu, "convert_to_transparency_mask");
            addActionToMenu(convertToMenu, "convert_to_filter_mask");
            addActionToMenu(convertToMenu, "convert_to_selection_mask");
            addActionToMenu(convertToMenu, "convert_to_file_layer");
            addActionToMenu(convertToMenu, "convert_group_to_animated");
            addActionToMenu(convertToMenu, "layercolorspaceconversion");
 
            QMenu *splitAlphaMenu = menu.addMenu(i18n("S&plit Alpha"));
            addActionToMenu(splitAlphaMenu, "split_alpha_into_mask");
            addActionToMenu(splitAlphaMenu, "split_alpha_write");
            addActionToMenu(splitAlphaMenu, "split_alpha_save_merged");
        } else {
            QMenu *addLayerMenu = menu.addMenu(i18n("&Add"));
            addActionToMenu(addLayerMenu, "add_new_clone_layer");
        }
 
        menu.addSeparator();
 
        addActionToMenu(&menu, "pin_to_timeline");
 
 
        if (singleNode) {
            KisNodeSP node = m_filteringModel->nodeFromIndex(index);
            if (node && !node->inherits("KisTransformMask")) {
                addActionToMenu(&menu, "isolate_active_layer");
                addActionToMenu(&menu, "isolate_active_group");
            }
 
            addActionToMenu(&menu, "selectopaque");
 
        }
    }
}

References addActionToMenu(), KisBaseNode::colorLabelIndex(), KisSharedPtr< T >::data(), KisClipboard::instance(), KisLayer::layerStyle, m_changeCloneSourceAction, m_colorSelector, m_colorSelectorAction, m_filteringModel, m_nodeManager, m_propertiesAction, and m_removeAction.

updateUI

void LayerBox::updateUI ( )

privateslot

the composite op works in the color space of the parent layer, not the active one.

Definition at line 670 of file LayerBox.cpp.

{
    if (!m_canvas) return;
    if (!m_nodeManager) return;
 
    KisNodeSP activeNode = m_nodeManager->activeNode();
 
    if (activeNode != m_activeNode) {
        m_activeNodeConnections.clear();
        m_activeNode = activeNode;
 
        if (activeNode) {
            KisPaintDeviceSP parentLayerDevice = activeNode->parent() ? activeNode->parent()->original() : 0;
            if (parentLayerDevice) {
                // update blending modes availability
                m_activeNodeConnections.addConnection(
                     parentLayerDevice, SIGNAL(colorSpaceChanged(const KoColorSpace*)),
                     this, SLOT(updateUI()));
            }
 
            m_activeNodeConnections.addConnection(
                    activeNode, SIGNAL(opacityChanged(quint8)),
                    this, SLOT(slotUpdateOpacitySlider(quint8)));
        }
    }
 
    m_wdgLayerBox->bnRaise->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->nextSibling()
                                                                                       || (activeNode->parent() && activeNode->parent() != m_image->root())));
    m_wdgLayerBox->bnLower->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->prevSibling()
                                                                                       || (activeNode->parent() && activeNode->parent() != m_image->root())));
 
    m_wdgLayerBox->doubleOpacity->setEnabled(activeNode && activeNode->isEditable(false));
 
    m_wdgLayerBox->cmbComposite->setEnabled(activeNode && activeNode->isEditable(false));
 
    if (activeNode) {
        if (activeNode->inherits("KisColorizeMask") || activeNode->inherits("KisLayer")) {
 
            m_wdgLayerBox->doubleOpacity->setEnabled(true);
 
            if (!m_wdgLayerBox->doubleOpacity->isDragging()) {
                slotSetOpacity(activeNode->opacity() * 100.0 / 255);
            }
 
            const KoCompositeOp* compositeOp = activeNode->compositeOp();
            if (compositeOp) {
                m_wdgLayerBox->cmbComposite->validate(compositeOp->colorSpace());
                slotSetCompositeOp(compositeOp);
            } else {
                m_wdgLayerBox->cmbComposite->setEnabled(false);
            }
 
            const KisGroupLayer *group = qobject_cast<const KisGroupLayer*>(activeNode.data());
            bool compositeSelectionActive = !(group && group->passThroughMode());
 
            m_wdgLayerBox->cmbComposite->setEnabled(compositeSelectionActive);
        } else if (activeNode->inherits("KisMask")) {
            m_wdgLayerBox->cmbComposite->setEnabled(false);
            m_wdgLayerBox->doubleOpacity->setEnabled(false);
        }
    }
}

References KisSignalAutoConnectionsStore::addConnection(), KisSignalAutoConnectionsStore::clear(), KoCompositeOp::colorSpace, KisBaseNode::compositeOp, KisSharedPtr< T >::data(), KisBaseNode::isEditable(), m_activeNode, m_activeNodeConnections, m_canvas, m_image, m_nodeManager, m_wdgLayerBox, KisNode::nextSibling(), KisBaseNode::opacity(), KisBaseNode::original(), KisNode::parent, KisGroupLayer::passThroughMode, KisNode::prevSibling(), KisNodeFacade::root, slotSetCompositeOp(), slotSetOpacity(), slotUpdateOpacitySlider(), and updateUI().

Member Data Documentation

indentationSlider

QSlider* LayerBox::indentationSlider

private

Definition at line 180 of file LayerBox.h.

infoTextCombobox

QComboBox* LayerBox::infoTextCombobox

private

Definition at line 181 of file LayerBox.h.

infoTextInlineChkbox

QCheckBox* LayerBox::infoTextInlineChkbox

private

Definition at line 183 of file LayerBox.h.

infoTextOpacitySlider

KisSliderSpinBox* LayerBox::infoTextOpacitySlider

private

Definition at line 182 of file LayerBox.h.

layerFilterWidget

KisLayerFilterWidget* LayerBox::layerFilterWidget

private

Definition at line 178 of file LayerBox.h.

layerSelectionCheckBox

QCheckBox* LayerBox::layerSelectionCheckBox {nullptr}

private

Definition at line 184 of file LayerBox.h.

{nullptr};

m_activeNode

KisNodeSP LayerBox::m_activeNode

private

Definition at line 186 of file LayerBox.h.

m_activeNodeConnections

KisSignalAutoConnectionsStore LayerBox::m_activeNodeConnections

private

Definition at line 188 of file LayerBox.h.

m_canvas

QPointer<KisCanvas2> LayerBox::m_canvas

private

Definition at line 153 of file LayerBox.h.

m_changeCloneSourceAction

KisAction* LayerBox::m_changeCloneSourceAction

private

Definition at line 169 of file LayerBox.h.

m_changedOpacityNode

KisNodeSP LayerBox::m_changedOpacityNode

private

Definition at line 165 of file LayerBox.h.

m_colorLabelCompressor

KisSignalCompressor LayerBox::m_colorLabelCompressor

private

Definition at line 172 of file LayerBox.h.

m_colorSelector

QPointer<KisColorLabelSelectorWidgetMenuWrapper> LayerBox::m_colorSelector

private

Definition at line 161 of file LayerBox.h.

m_colorSelectorAction

QPointer<QWidgetAction> LayerBox::m_colorSelectorAction

private

Definition at line 162 of file LayerBox.h.

m_filteringModel

QPointer<KisNodeFilterProxyModel> LayerBox::m_filteringModel

private

Definition at line 159 of file LayerBox.h.

m_image

KisImageWSP LayerBox::m_image

private

Definition at line 157 of file LayerBox.h.

m_infoTextOpacityCompressor

KisSignalCompressor LayerBox::m_infoTextOpacityCompressor

private

Definition at line 175 of file LayerBox.h.

m_layerToggleSolo

KisAction* LayerBox::m_layerToggleSolo

private

Definition at line 170 of file LayerBox.h.

m_newLayerMenu

QMenu* LayerBox::m_newLayerMenu

private

Definition at line 155 of file LayerBox.h.

m_newOpacity

int LayerBox::m_newOpacity

private

Definition at line 164 of file LayerBox.h.

m_nodeManager

QPointer<KisNodeManager> LayerBox::m_nodeManager

private

Definition at line 160 of file LayerBox.h.

m_nodeModel

QPointer<KisNodeModel> LayerBox::m_nodeModel

private

Definition at line 158 of file LayerBox.h.

m_nodeOpacityCompressor

KisSignalCompressor LayerBox::m_nodeOpacityCompressor

private

Definition at line 176 of file LayerBox.h.

m_opLayerMenu

QMenu* LayerBox::m_opLayerMenu

private

Definition at line 156 of file LayerBox.h.

m_propertiesAction

KisAction* LayerBox::m_propertiesAction

private

Definition at line 168 of file LayerBox.h.

m_removeAction

KisAction* LayerBox::m_removeAction

private

Definition at line 167 of file LayerBox.h.

m_savedNodeBeforeEditSelectionMode

KisNodeWSP LayerBox::m_savedNodeBeforeEditSelectionMode

private

Definition at line 187 of file LayerBox.h.

m_selectionActionsAdapter

QScopedPointer<KisSelectionActionsAdapter> LayerBox::m_selectionActionsAdapter

private

Definition at line 154 of file LayerBox.h.

m_showGlobalSelectionMask

KisAction* LayerBox::m_showGlobalSelectionMask

private

Definition at line 171 of file LayerBox.h.

m_thumbnailSizeCompressor

KisSignalCompressor LayerBox::m_thumbnailSizeCompressor

private

Definition at line 173 of file LayerBox.h.

m_treeIndentationCompressor

KisSignalCompressor LayerBox::m_treeIndentationCompressor

private

Definition at line 174 of file LayerBox.h.

m_wdgLayerBox

Ui_WdgLayerBox* LayerBox::m_wdgLayerBox

private

Definition at line 163 of file LayerBox.h.

thumbnailSizeSlider

QSlider* LayerBox::thumbnailSizeSlider

private

Definition at line 179 of file LayerBox.h.

---

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

• plugins/dockers/layerdocker/LayerBox.h
• plugins/dockers/layerdocker/LayerBox.cpp