WGColorSelectorDock Class Reference

#include <WGColorSelectorDock.h>

Inheritance diagram for WGColorSelectorDock:

Public Types
enum	ColorSpaceSource { LayerColorSpace , ImageColorSpace , FixedColorSpace }

Public Member Functions
KisUniqueColorSet *	colorHistory () const
const KisVisualColorModel &	colorModel () const
KisDisplayColorConverter *	displayColorConverter (bool rawPointer=false) const
bool	selectingBackground () const
void	setChannelValues (const QVector4D &values)
	Set new channel values; takes effect immediately!
	WGColorSelectorDock ()
Public Member Functions inherited from KisMainwindowObserver
	KisMainwindowObserver ()
	~KisMainwindowObserver () override
Public Member Functions inherited from KoCanvasObserverBase
	KoCanvasObserverBase ()
KoCanvasBase *	observedCanvas () const
virtual QString	observerName ()
void	setObservedCanvas (KoCanvasBase *canvas)
void	unsetObservedCanvas ()
virtual	~KoCanvasObserverBase ()

Protected Member Functions
void	disconnectFromCanvas ()
void	leaveEvent (QEvent *event) override
void	setCanvas (KoCanvasBase *canvas) override
void	setViewManager (KisViewManager *viewManager) override
void	unsetCanvas () override
void	updateLayout ()

Private Slots
void	slotCanvasResourceChanged (int key, const QVariant &value)
void	slotColorInteraction (bool active)
void	slotColorSelected (const KoColor &color)
void	slotColorSourceToggled (bool selectingBg)
void	slotConfigurationChanged ()
void	slotDisplayConfigurationChanged ()
void	slotFGColorUsed (const KoColor &color)
void	slotOpenSettings ()
void	slotSetNewColors ()
void	slotShowGamutMaskToolbar (bool show)

Private Attributes
WGActionManager *	m_actionManager {0}
QPointer< KisCanvas2 >	m_canvas
KisSignalCompressor *	m_colorChangeCompressor
KisUniqueColorSet *	m_colorHistory
KisVisualColorModelSP	m_colorModelBG
KisVisualColorModelSP	m_colorModelFG
WGColorPreviewToolTip *	m_colorTooltip {0}
WGColorPatches *	m_commonColors {0}
WGCommonColorSet *	m_commonColorSet {0}
QToolButton *	m_configButton {0}
ColorSpaceSource	m_CSSource {LayerColorSpace}
const KoColorSpace *	m_customCS {0}
WGSelectorDisplayConfigSP	m_displayConfig
KisGamutMaskToolbar *	m_gamutToolbar
WGColorPatches *	m_history {0}
QBoxLayout *	m_mainWidgetLayout {0}
bool	m_pendingBgUpdate {false}
bool	m_pendingFgUpdate {false}
QWidgetAction *	m_quickSettingAction {0}
WGQuickSettingsWidget *	m_quickSettings {0}
KisVisualColorSelector *	m_selector {0}
QBoxLayout *	m_selectorAreaLayout {0}
WGShadeSelector *	m_shadeSelector {0}
KisColorSourceToggle *	m_toggle {0}
QBoxLayout *	m_verticalElementsLayout {0}

Detailed Description

Definition at line 38 of file WGColorSelectorDock.h.

Member Enumeration Documentation

ColorSpaceSource

enum WGColorSelectorDock::ColorSpaceSource

Enumerator
LayerColorSpace
ImageColorSpace
FixedColorSpace

Definition at line 42 of file WGColorSelectorDock.h.

                          {
        LayerColorSpace,
        ImageColorSpace,
        FixedColorSpace
    };

Constructor & Destructor Documentation

WGColorSelectorDock()

WGColorSelectorDock::WGColorSelectorDock

(

)

Definition at line 40 of file WGColorSelectorDock.cpp.

    : QDockWidget()
    , m_displayConfig(new WGSelectorDisplayConfig)
    , m_colorChangeCompressor(new KisSignalCompressor(100 /* ms */, KisSignalCompressor::POSTPONE, this))
    , m_actionManager(new WGActionManager(this))
    , m_colorTooltip(new WGColorPreviewToolTip(this))
    , m_colorModelBG(new KisVisualColorModel)
{
    setWindowTitle(i18n("Wide Gamut Color Selector"));
 
    QWidget *mainWidget = new QWidget();
    m_mainWidgetLayout = new QVBoxLayout(mainWidget);
    m_verticalElementsLayout = new QHBoxLayout();
    m_selectorAreaLayout = new QBoxLayout(QBoxLayout::TopToBottom);
 
    m_selector = new KisVisualColorSelector(mainWidget);
    m_selector->setMinimumSliderWidth(12);
    connect(m_selector, SIGNAL(sigNewColor(KoColor)), SLOT(slotColorSelected(KoColor)));
    connect(m_selector, SIGNAL(sigInteraction(bool)), SLOT(slotColorInteraction(bool)));
    connect(m_colorChangeCompressor, SIGNAL(timeout()), SLOT(slotSetNewColors()));
    m_colorModelFG = m_selector->selectorModel();
 
    // Header
    QWidget *headerWidget = new QWidget(mainWidget);
    QHBoxLayout *headerLayout = new QHBoxLayout(headerWidget);
 
    m_toggle = new KisColorSourceToggle(mainWidget);
    connect(m_toggle, SIGNAL(toggled(bool)), SLOT(slotColorSourceToggled(bool)));
    headerLayout->addWidget(m_toggle);
    m_gamutToolbar = new KisGamutMaskToolbar(this);
    m_gamutToolbar->setContentsMargins(0, 0, 0, 5);
    m_gamutToolbar->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
    headerLayout->addWidget(m_gamutToolbar);
    headerLayout->addStretch();
    headerLayout->setContentsMargins(0, 0, 0, 0);
 
    connect(m_selector, SIGNAL(sigGamutMaskSupportChanged(bool)), SLOT(slotShowGamutMaskToolbar(bool)));
 
    m_configButton = new QToolButton(this);
    m_configButton->setIcon(KisIconUtils::loadIcon("view-choose"));
    m_configButton->setAutoRaise(true);
    m_configButton->setPopupMode(QToolButton::InstantPopup);
    headerLayout->addWidget(m_configButton);
 
    m_mainWidgetLayout->addWidget(headerWidget);
    m_mainWidgetLayout->addLayout(m_verticalElementsLayout);
    m_verticalElementsLayout->addLayout(m_selectorAreaLayout);
 
    m_selectorAreaLayout->addWidget(m_selector);
 
    KisVisualColorModelSP model = m_selector->selectorModel();
    m_shadeSelector = new WGShadeSelector(m_displayConfig, model, this);
    m_selectorAreaLayout->addWidget(m_shadeSelector);
    connect(m_shadeSelector, SIGNAL(sigColorInteraction(bool)), SLOT(slotColorInteraction(bool)));
 
    // eventually it should made be a global history, not specific to any plugin
    m_colorHistory = new KisUniqueColorSet(this);
 
    m_history = new WGColorPatches(m_displayConfig, m_colorHistory, mainWidget);
    m_history->setPreset(WGColorPatches::History);
    connect(m_history, SIGNAL(sigColorChanged(KoColor)), SLOT(slotColorSelected(KoColor)));
    connect(m_history, SIGNAL(sigColorInteraction(bool)), SLOT(slotColorInteraction(bool)));
 
    // Common Colors (Colors from Image)
    m_commonColorSet = new WGCommonColorSet(this);
 
    m_commonColors = new WGColorPatches(m_displayConfig, m_commonColorSet, mainWidget);
    m_commonColors->setPreset(WGColorPatches::CommonColors);
    connect(m_commonColors, SIGNAL(sigColorChanged(KoColor)), SLOT(slotColorSelected(KoColor)));
    connect(m_commonColors, SIGNAL(sigColorInteraction(bool)), SLOT(slotColorInteraction(bool)));
 
    connect(WGConfig::notifier(), SIGNAL(configChanged()), SLOT(slotConfigurationChanged()));
 
    setWidget(mainWidget);
    slotConfigurationChanged();
    setEnabled(false);
}

References WGColorPatches::CommonColors, connect(), WGColorPatches::History, KisIconUtils::loadIcon(), m_colorChangeCompressor, m_colorHistory, m_colorModelFG, m_commonColors, m_commonColorSet, m_configButton, m_displayConfig, m_gamutToolbar, m_history, m_mainWidgetLayout, m_selector, m_selectorAreaLayout, m_shadeSelector, m_toggle, m_verticalElementsLayout, WGConfig::notifier(), KisVisualColorSelector::selectorModel(), KisVisualColorSelector::setMinimumSliderWidth(), WGColorPatches::setPreset(), slotColorInteraction(), slotColorSelected(), slotColorSourceToggled(), slotConfigurationChanged(), slotSetNewColors(), and slotShowGamutMaskToolbar().

Member Function Documentation

colorHistory()

KisUniqueColorSet * WGColorSelectorDock::colorHistory ( ) const

inline

Definition at line 51 of file WGColorSelectorDock.h.

{ return m_colorHistory; }

References m_colorHistory.

colorModel()

const KisVisualColorModel & WGColorSelectorDock::colorModel

(

)

const

Definition at line 118 of file WGColorSelectorDock.cpp.

{
    // currently always return foreground model;
    // do lazy conversion to current HSX model if required
    if (selectingBackground() && m_colorModelBG->isHSXModel()) {
        m_colorModelFG->setRGBColorModel(m_colorModelBG->colorModel());
    }
    return *(m_colorModelFG);
}

References m_colorModelBG, m_colorModelFG, and selectingBackground().

disconnectFromCanvas()

void WGColorSelectorDock::disconnectFromCanvas ( )

protected

Definition at line 227 of file WGColorSelectorDock.cpp.

{
    m_canvas->disconnectCanvasObserver(this);
    m_canvas->displayColorConverter()->displayRendererInterface()->disconnect(this);
    m_canvas->imageView()->resourceProvider()->disconnect(m_selector);
    m_canvas = 0;
}

References m_canvas, and m_selector.

displayColorConverter()

KisDisplayColorConverter * WGColorSelectorDock::displayColorConverter

(

bool

rawPointer = false

)

const

Definition at line 128 of file WGColorSelectorDock.cpp.

{
    KisDisplayColorConverter *converter = nullptr;
    if (m_canvas) {
        converter = m_canvas->displayColorConverter();
    }
    return (rawPointer || converter) ?  converter : KisDisplayColorConverter::dumbConverterInstance();
}

References KisDisplayColorConverter::dumbConverterInstance(), and m_canvas.

leaveEvent()

void WGColorSelectorDock::leaveEvent ( QEvent * event )

overrideprotected

Definition at line 158 of file WGColorSelectorDock.cpp.

{
    Q_UNUSED(event)
    m_colorTooltip->hide();
}

References m_colorTooltip.

selectingBackground()

bool WGColorSelectorDock::selectingBackground

(

)

const

Definition at line 137 of file WGColorSelectorDock.cpp.

{
    return m_toggle->isChecked();
}

References m_toggle.

setCanvas()

void WGColorSelectorDock::setCanvas ( KoCanvasBase * canvas )

overrideprotectedvirtual

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 164 of file WGColorSelectorDock.cpp.

{
    if (m_canvas.data() == canvas)
    {
        // not sure why setCanvas gets called 3 times for new canvas, just skip
        return;
    }
    if (m_canvas) {
        disconnectFromCanvas();
    }
    m_actionManager->setCanvas(qobject_cast<KisCanvas2*>(canvas), m_canvas);
    m_canvas = qobject_cast<KisCanvas2*>(canvas);
    // TODO: unset display converters if canvas is null
    if (m_canvas) {
        KoColorDisplayRendererInterface *dri = m_canvas->displayColorConverter()->displayRendererInterface();
        KisCanvasResourceProvider *resourceProvider = m_canvas->imageView()->resourceProvider();
        m_selector->setDisplayRenderer(dri);
        m_displayConfig->setDisplayConverter(m_canvas->displayColorConverter());
        m_commonColorSet->setImage(m_canvas->image());
        //m_toggle->setBackgroundColor(dri->toQColor(color));
        connect(dri, SIGNAL(displayConfigurationChanged()), this, SLOT(slotDisplayConfigurationChanged()));
        connect(m_canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
                this, SLOT(slotCanvasResourceChanged(int,QVariant)));
        connect(resourceProvider, SIGNAL(sigFGColorUsed(KoColor)),
                this, SLOT(slotFGColorUsed(KoColor)), Qt::UniqueConnection);
 
        // Gamut Mask
        connect(resourceProvider, SIGNAL(sigGamutMaskChanged(KoGamutMaskSP)),
                m_selector, SLOT(slotGamutMaskChanged(KoGamutMaskSP)), Qt::UniqueConnection);
 
        connect(resourceProvider, SIGNAL(sigGamutMaskPreviewUpdate()),
                m_selector, SLOT(slotGamutMaskPreviewUpdate()), Qt::UniqueConnection);
 
        connect(resourceProvider, SIGNAL(sigGamutMaskUnset()),
                m_selector, SLOT(slotGamutMaskUnset()), Qt::UniqueConnection);
 
        connect(resourceProvider, SIGNAL(sigGamutMaskDeactivated()),
                m_selector, SLOT(slotGamutMaskUnset()), Qt::UniqueConnection);
 
        m_gamutToolbar->connectMaskSignals(resourceProvider);
 
        // quirk note: displayConfigurationChanged signal gets sent *before* the new canvas gets
        // passed, through the display converter of the now inactive canvas! So we need to repeat...
        slotDisplayConfigurationChanged();
    }
    setEnabled(canvas != 0);
}

References connect(), KisGamutMaskToolbar::connectMaskSignals(), disconnectFromCanvas(), m_actionManager, m_canvas, m_commonColorSet, m_displayConfig, m_gamutToolbar, m_selector, WGActionManager::setCanvas(), KisVisualColorSelector::setDisplayRenderer(), WGCommonColorSet::setImage(), slotCanvasResourceChanged(), slotDisplayConfigurationChanged(), and slotFGColorUsed().

setChannelValues()

void WGColorSelectorDock::setChannelValues

(

const QVector4D &

values

)

Set new channel values; takes effect immediately!

This is intended for synchronization when color gets adjusted outside of the docker, like in WGActionManager

Parameters

values

Definition at line 142 of file WGColorSelectorDock.cpp.

{
    // currently always set foreground color
    if (!m_canvas) {
        return;
    }
 
    // This could be nicer...if setting active model, this triggers slotColorSelected()
    // and leaves timer running with NOP, otherwise the resource update is detected as
    // external event and updates UI.
    m_colorModelFG->slotSetChannelValues(values);
 
    m_canvas->resourceManager()->setForegroundColor(m_colorModelFG->currentColor());
    m_pendingFgUpdate = false;
}

References m_canvas, m_colorModelFG, and m_pendingFgUpdate.

setViewManager()

void WGColorSelectorDock::setViewManager ( KisViewManager * viewManager )

overrideprotectedvirtual

Implements KisMainwindowObserver.

Definition at line 222 of file WGColorSelectorDock.cpp.

{
    m_actionManager->registerActions(viewManager);
}

References m_actionManager, and WGActionManager::registerActions().

slotCanvasResourceChanged

void WGColorSelectorDock::slotCanvasResourceChanged ( int key, const QVariant & value )

privateslot

Definition at line 453 of file WGColorSelectorDock.cpp.

{
    switch (key) {
    case KoCanvasResource::ForegroundColor:
        if (!m_pendingFgUpdate) {
            KoColor color = value.value<KoColor>();
            m_toggle->setForegroundColor(displayColorConverter()->toQColor(color));
            m_colorModelFG->slotSetColor(color);
        }
        break;
    case KoCanvasResource::BackgroundColor:
        if (!m_pendingBgUpdate) {
            KoColor color = value.value<KoColor>();
            m_toggle->setBackgroundColor(displayColorConverter()->toQColor(color));
            m_colorModelBG->slotSetColor(color);
        }
    default:
        break;
    }
}

References KoCanvasResource::BackgroundColor, displayColorConverter(), KoCanvasResource::ForegroundColor, m_colorModelBG, m_colorModelFG, m_pendingBgUpdate, m_pendingFgUpdate, m_toggle, KisColorSourceToggle::setBackgroundColor(), KisColorSourceToggle::setForegroundColor(), KisDisplayColorConverter::toQColor(), and value().

slotColorInteraction

void WGColorSelectorDock::slotColorInteraction ( bool active )

privateslot

Definition at line 418 of file WGColorSelectorDock.cpp.

{
    if (active) {
        QColor baseCol = m_displayConfig->displayConverter()->toQColor(m_selector->getCurrentColor());
        m_colorTooltip->setCurrentColor(baseCol);
        m_colorTooltip->setPreviousColor(baseCol);
        if (sender() == m_shadeSelector) {
            m_colorTooltip->show(m_shadeSelector);
        } else {
            m_colorTooltip->show(this);
        }
    }
}

References KisVisualColorSelector::getCurrentColor(), m_colorTooltip, m_displayConfig, m_selector, m_shadeSelector, WGColorPreviewToolTip::setCurrentColor(), WGColorPreviewToolTip::setPreviousColor(), and WGColorPreviewToolTip::show().

slotColorSelected

void WGColorSelectorDock::slotColorSelected ( const KoColor & color )

privateslot

Definition at line 377 of file WGColorSelectorDock.cpp.

{
    QColor displayCol = displayColorConverter()->toQColor(color, m_displayConfig->previewInPaintingCS());
    m_colorTooltip->setCurrentColor(displayCol);
    if (selectingBackground()) {
        m_toggle->setBackgroundColor(displayCol);
        m_pendingBgUpdate = true;
        m_colorChangeCompressor->start();
    }
    else {
        m_toggle->setForegroundColor(displayCol);
        m_pendingFgUpdate = true;
        m_colorChangeCompressor->start();
    }
    if (sender() != m_selector) {
        m_selector->slotSetColor(color);
    }
}

References displayColorConverter(), m_colorChangeCompressor, m_colorTooltip, m_displayConfig, m_pendingBgUpdate, m_pendingFgUpdate, m_selector, m_toggle, selectingBackground(), KisColorSourceToggle::setBackgroundColor(), WGColorPreviewToolTip::setCurrentColor(), KisColorSourceToggle::setForegroundColor(), KisVisualColorSelector::slotSetColor(), KisSignalCompressor::start(), and KisDisplayColorConverter::toQColor().

slotColorSourceToggled

void WGColorSelectorDock::slotColorSourceToggled ( bool selectingBg )

privateslot

Definition at line 396 of file WGColorSelectorDock.cpp.

{
    if (selectingBg) {
        if (m_colorModelFG->isHSXModel()) {
            m_colorModelBG->setRGBColorModel(m_colorModelFG->colorModel());
        }
        m_selector->setSelectorModel(m_colorModelBG);
        m_shadeSelector->setModel(m_colorModelBG);
    }
    else {
        if (m_colorModelBG->isHSXModel()) {
            m_colorModelFG->setRGBColorModel(m_colorModelBG->colorModel());
        }
        m_selector->setSelectorModel(m_colorModelFG);
        m_shadeSelector->setModel(m_colorModelFG);
    }
    // currently, only the color space of the active model is updated, so it may be outdated
    if (m_canvas) {
        slotDisplayConfigurationChanged();
    }
}

References m_canvas, m_colorModelBG, m_colorModelFG, m_selector, m_shadeSelector, WGShadeSelector::setModel(), KisVisualColorSelector::setSelectorModel(), and slotDisplayConfigurationChanged().

slotConfigurationChanged

void WGColorSelectorDock::slotConfigurationChanged ( )

privateslot

Definition at line 286 of file WGColorSelectorDock.cpp.

{
    WGConfig::Accessor cfg;
    m_selector->setRenderMode(cfg.get(WGConfig::selectorRenderMode));
    m_selector->selectorModel()->setRGBColorModel(cfg.get(WGConfig::rgbColorModel));
    KisColorSelectorConfiguration selectorCfg = cfg.colorSelectorConfiguration();
    m_selector->setConfiguration(&selectorCfg);
    m_CSSource = cfg.get(WGConfig::colorSpaceSource);
    if (m_CSSource == FixedColorSpace) {
        m_customCS = cfg.customSelectionColorSpace();
    }
    bool proofColors = cfg.get(WGConfig::proofToPaintingColors);
    m_selector->setProofColors(proofColors);
    m_displayConfig->setPreviewInPaintingCS(proofColors);
    m_shadeSelector->updateSettings();
    m_history->updateSettings();
    m_commonColors->updateSettings();
    m_commonColorSet->setAutoUpdate(cfg.get(WGConfig::commonColorsAutoUpdate));
    // Quick settings menu
    if (cfg.get(WGConfig::quickSettingsEnabled)) {
        if (!m_configButton->menu()) {
            m_configButton->disconnect(this);
            QMenu *configureMenu = new QMenu(this);
            m_quickSettings = new WGQuickSettingsWidget(this, m_selector);
            // prevents hover indicator being stuck on other menu entries
            m_quickSettings->setMouseTracking(true);
            m_quickSettingAction = new QWidgetAction(this);
            m_quickSettingAction->setDefaultWidget(m_quickSettings);
 
            configureMenu->addAction(m_quickSettingAction);
            QAction *cfgAction = configureMenu->addAction(i18nc("Wide Gamut Color Selector", "Configure..."));
            connect(cfgAction, SIGNAL(triggered(bool)), SLOT(slotOpenSettings()));
            m_configButton->setMenu(configureMenu);
        } else {
            // WORKAROUND: force geometry update by re-adding action, all other attempts failed...
            QMenu *menu = m_configButton->menu();
            menu->removeAction(m_quickSettingAction);
            menu->insertAction(menu->actions().constFirst(), m_quickSettingAction);
        }
        m_quickSettings->loadConfiguration();
    } else {
        if (m_configButton->menu()) {
            m_configButton->menu()->deleteLater();
            m_configButton->setMenu(0);
            delete m_quickSettingAction;
            m_quickSettingAction = 0;
            m_quickSettings = 0;
        }
        connect(m_configButton, SIGNAL(clicked(bool)), SLOT(slotOpenSettings()), Qt::UniqueConnection);
    }
 
    updateLayout();
 
    if (m_canvas) {
        slotDisplayConfigurationChanged();
    }
}

References WGConfig::colorSpaceSource, WGConfig::commonColorsAutoUpdate, connect(), FixedColorSpace, WGQuickSettingsWidget::loadConfiguration(), m_canvas, m_commonColors, m_commonColorSet, m_configButton, m_CSSource, m_customCS, m_displayConfig, m_history, m_quickSettingAction, m_quickSettings, m_selector, m_shadeSelector, WGConfig::proofToPaintingColors, WGConfig::quickSettingsEnabled, WGConfig::rgbColorModel, KisVisualColorSelector::selectorModel(), WGConfig::selectorRenderMode, WGCommonColorSet::setAutoUpdate(), KisVisualColorSelector::setConfiguration(), KisVisualColorSelector::setProofColors(), KisVisualColorSelector::setRenderMode(), slotDisplayConfigurationChanged(), slotOpenSettings(), updateLayout(), WGColorPatches::updateSettings(), and WGShadeSelector::updateSettings().

slotDisplayConfigurationChanged

void WGColorSelectorDock::slotDisplayConfigurationChanged ( )

privateslot

Definition at line 344 of file WGColorSelectorDock.cpp.

{
    if (!m_canvas) {
        return;
    }
 
    const KoColorSpace *selectionCS = nullptr;
 
    // Note: displayConfigurationChanged is also emitted on image color space changes,
    // so there's no need to handle extra signals, although it's a bit convoluted
    if (m_CSSource == ImageColorSpace) {
        selectionCS  = m_canvas->image()->colorSpace();
    } else if (m_CSSource == FixedColorSpace) {
        selectionCS = m_customCS;
    } else {
        selectionCS = m_canvas->displayColorConverter()->nodeColorSpace();
    }
 
    // TODO: use m_viewManager->canvasResourceProvider()->fgColor();
    KoColor fgColor = m_canvas->resourceManager()->foregroundColor();
    KoColor bgColor = m_canvas->resourceManager()->backgroundColor();
 
    bool proof = m_displayConfig->previewInPaintingCS();
    m_toggle->setForegroundColor(displayColorConverter()->toQColor(fgColor, proof));
    m_toggle->setBackgroundColor(displayColorConverter()->toQColor(bgColor, proof));
    KisVisualColorModelSP activeModel = m_selector->selectorModel();
 
    if (selectionCS && selectionCS != activeModel->colorSpace()) {
        activeModel->slotSetColorSpace(selectionCS);
        activeModel->slotSetColor(activeModel == m_colorModelFG ? fgColor : bgColor);
    }
}

References displayColorConverter(), FixedColorSpace, ImageColorSpace, m_canvas, m_colorModelFG, m_CSSource, m_customCS, m_displayConfig, m_selector, m_toggle, KisVisualColorSelector::selectorModel(), KisColorSourceToggle::setBackgroundColor(), and KisColorSourceToggle::setForegroundColor().

slotFGColorUsed

void WGColorSelectorDock::slotFGColorUsed ( const KoColor & color )

privateslot

Definition at line 432 of file WGColorSelectorDock.cpp.

{
    QColor lastCol = m_displayConfig->displayConverter()->toQColor(color);
    m_colorTooltip->setLastUsedColor(lastCol);
    m_actionManager->setLastUsedColor(color);
    m_colorHistory->addColor(color);
}

References KisUniqueColorSet::addColor(), m_actionManager, m_colorHistory, m_colorTooltip, m_displayConfig, WGActionManager::setLastUsedColor(), and WGColorPreviewToolTip::setLastUsedColor().

slotOpenSettings

void WGColorSelectorDock::slotOpenSettings ( )

privateslot

Definition at line 474 of file WGColorSelectorDock.cpp.

{
    if (!m_canvas) return;
 
    WGColorSelectorSettingsDialog settings;
    if (settings.exec() == QDialog::Accepted) {
        //WGConfig::notifier()->notifyConfigChanged();
    }
}

References m_canvas.

slotSetNewColors

void WGColorSelectorDock::slotSetNewColors ( )

privateslot

Definition at line 440 of file WGColorSelectorDock.cpp.

{
    //KIS_SAFE_ASSERT_RECOVER_RETURN(m_pendingFgUpdate || m_pendingBgUpdate);
    if (m_pendingFgUpdate) {
        m_canvas->resourceManager()->setForegroundColor(m_colorModelFG->currentColor());
        m_pendingFgUpdate = false;
    }
    if (m_pendingBgUpdate) {
        m_canvas->resourceManager()->setBackgroundColor(m_colorModelBG->currentColor());
        m_pendingBgUpdate = false;
    }
}

References m_canvas, m_colorModelBG, m_colorModelFG, m_pendingBgUpdate, and m_pendingFgUpdate.

slotShowGamutMaskToolbar

void WGColorSelectorDock::slotShowGamutMaskToolbar ( bool show )

privateslot

Definition at line 484 of file WGColorSelectorDock.cpp.

{
    m_gamutToolbar->setVisible(show);
}

References m_gamutToolbar.

unsetCanvas()

void WGColorSelectorDock::unsetCanvas ( )

overrideprotectedvirtual

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 212 of file WGColorSelectorDock.cpp.

{
    setEnabled(false);
    m_actionManager->setCanvas(0, 0);
    m_displayConfig->setDisplayConverter(0);
    m_selector->setDisplayRenderer(0);
    m_commonColorSet->setImage(KisImageSP());
    m_canvas = 0;
}

References m_actionManager, m_canvas, m_commonColorSet, m_displayConfig, m_selector, WGActionManager::setCanvas(), KisVisualColorSelector::setDisplayRenderer(), and WGCommonColorSet::setImage().

updateLayout()

void WGColorSelectorDock::updateLayout ( )

protected

Definition at line 235 of file WGColorSelectorDock.cpp.

{
    WGConfig::Accessor cfg;
 
    bool historyEnabled = cfg.get(WGConfig::colorHistoryEnabled);
    Qt::Orientation historyOrientation = cfg.get(WGConfig::colorHistory.orientation);
 
    m_verticalElementsLayout->removeWidget(m_history);
    m_verticalElementsLayout->removeWidget(m_commonColors);
    m_mainWidgetLayout->removeWidget(m_history);
    m_mainWidgetLayout->removeWidget(m_commonColors);
 
    if (historyEnabled) {
        if (historyOrientation == Qt::Vertical) {
            m_verticalElementsLayout->addWidget(m_history);
        }
        else {
            m_mainWidgetLayout->addWidget(m_history);
        }
        m_history->show();
    }
    else {
        m_history->hide();
    }
 
    bool commonColorsEnabled = cfg.get(WGConfig::commonColorsEnabled);
    Qt::Orientation commonColorsOrientation = cfg.get(WGConfig::commonColors.orientation);
 
    if (commonColorsEnabled) {
        if (commonColorsOrientation == Qt::Vertical) {
            m_verticalElementsLayout->addWidget(m_commonColors);
        }
        else {
            m_mainWidgetLayout->addWidget(m_commonColors);
        }
        m_commonColors->show();
    }
    else {
        m_commonColors->hide();
    }
 
    bool shadeSelectorEnabled = cfg.get(WGConfig::minimalShadeSelectorEnabled);
    if (shadeSelectorEnabled) {
        m_shadeSelector->show();
    }
    else {
        m_shadeSelector->hide();
    }
 
}

References WGConfig::colorHistory, WGConfig::colorHistoryEnabled, WGConfig::commonColors, WGConfig::commonColorsEnabled, m_commonColors, m_history, m_mainWidgetLayout, m_shadeSelector, m_verticalElementsLayout, and WGConfig::minimalShadeSelectorEnabled.

Member Data Documentation

m_actionManager

WGActionManager* WGColorSelectorDock::m_actionManager {0}

private

Definition at line 96 of file WGColorSelectorDock.h.

{0};

m_canvas

QPointer<KisCanvas2> WGColorSelectorDock::m_canvas

private

Definition at line 83 of file WGColorSelectorDock.h.

m_colorChangeCompressor

KisSignalCompressor* WGColorSelectorDock::m_colorChangeCompressor

private

Definition at line 92 of file WGColorSelectorDock.h.

m_colorHistory

KisUniqueColorSet* WGColorSelectorDock::m_colorHistory

private

Definition at line 93 of file WGColorSelectorDock.h.

m_colorModelBG

KisVisualColorModelSP WGColorSelectorDock::m_colorModelBG

private

Definition at line 105 of file WGColorSelectorDock.h.

m_colorModelFG

KisVisualColorModelSP WGColorSelectorDock::m_colorModelFG

private

Definition at line 104 of file WGColorSelectorDock.h.

m_colorTooltip

WGColorPreviewToolTip* WGColorSelectorDock::m_colorTooltip {0}

private

Definition at line 97 of file WGColorSelectorDock.h.

{0};

m_commonColors

WGColorPatches* WGColorSelectorDock::m_commonColors {0}

private

Definition at line 100 of file WGColorSelectorDock.h.

{0};

m_commonColorSet

WGCommonColorSet* WGColorSelectorDock::m_commonColorSet {0}

private

Definition at line 95 of file WGColorSelectorDock.h.

{0};

m_configButton

QToolButton* WGColorSelectorDock::m_configButton {0}

private

Definition at line 103 of file WGColorSelectorDock.h.

{0};

m_CSSource

ColorSpaceSource WGColorSelectorDock::m_CSSource {LayerColorSpace}

private

Definition at line 107 of file WGColorSelectorDock.h.

{LayerColorSpace};

m_customCS

const KoColorSpace* WGColorSelectorDock::m_customCS {0}

private

Definition at line 106 of file WGColorSelectorDock.h.

{0};

m_displayConfig

WGSelectorDisplayConfigSP WGColorSelectorDock::m_displayConfig

private

Definition at line 84 of file WGColorSelectorDock.h.

m_gamutToolbar

KisGamutMaskToolbar* WGColorSelectorDock::m_gamutToolbar

private

Definition at line 94 of file WGColorSelectorDock.h.

m_history

WGColorPatches* WGColorSelectorDock::m_history {0}

private

Definition at line 99 of file WGColorSelectorDock.h.

{0};

m_mainWidgetLayout

QBoxLayout* WGColorSelectorDock::m_mainWidgetLayout {0}

private

Definition at line 86 of file WGColorSelectorDock.h.

{0};

m_pendingBgUpdate

bool WGColorSelectorDock::m_pendingBgUpdate {false}

private

Definition at line 109 of file WGColorSelectorDock.h.

{false};

m_pendingFgUpdate

bool WGColorSelectorDock::m_pendingFgUpdate {false}

private

Definition at line 108 of file WGColorSelectorDock.h.

{false};

m_quickSettingAction

QWidgetAction* WGColorSelectorDock::m_quickSettingAction {0}

private

Definition at line 101 of file WGColorSelectorDock.h.

{0};

m_quickSettings

WGQuickSettingsWidget* WGColorSelectorDock::m_quickSettings {0}

private

Definition at line 102 of file WGColorSelectorDock.h.

{0};

m_selector

KisVisualColorSelector* WGColorSelectorDock::m_selector {0}

private

Definition at line 90 of file WGColorSelectorDock.h.

{0};

m_selectorAreaLayout

QBoxLayout* WGColorSelectorDock::m_selectorAreaLayout {0}

private

Definition at line 87 of file WGColorSelectorDock.h.

{0};

m_shadeSelector

WGShadeSelector* WGColorSelectorDock::m_shadeSelector {0}

private

Definition at line 98 of file WGColorSelectorDock.h.

{0};

m_toggle

KisColorSourceToggle* WGColorSelectorDock::m_toggle {0}

private

Definition at line 91 of file WGColorSelectorDock.h.

{0};

m_verticalElementsLayout

QBoxLayout* WGColorSelectorDock::m_verticalElementsLayout {0}

private

Definition at line 88 of file WGColorSelectorDock.h.

{0};

---

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

• plugins/dockers/widegamutcolorselector/WGColorSelectorDock.h
• plugins/dockers/widegamutcolorselector/WGColorSelectorDock.cpp