#include <WGColorSelectorDock.h>

Inheritance diagram for WGColorSelectorDock:

Public Types
enum	ColorSpaceSource { LayerColorSpace , ImageColorSpace , FixedColorSpace }

Public Member Functions
KisUniqueColorSet *	colorHistoryModel () 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 ()

bool	eventFilter (QObject obj, QEvent ev) 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

bool	m_colorHistoryFromDocument {false}

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

KisUniqueColorSet *	m_documentColorHistoryModel {0}

std::unique_ptr< KisUniqueColorSet >	m_fallbackColorHistoryModel

KisGamutMaskToolbar *	m_gamutToolbar

KisUniqueColorSet *	m_globalColorHistoryModel {0}

WGColorPatches *	m_history {0}

QWidget *	m_mainWidget

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 41 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)
    , m_mainWidget(new QWidget())
{
    setWindowTitle(i18n("Wide Gamut Color Selector"));
 
    QWidget *mainWidget = m_mainWidget;
    mainWidget->installEventFilter(this);
 
    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_fallbackColorHistoryModel.reset(new KisUniqueColorSet());
    m_globalColorHistoryModel = m_fallbackColorHistoryModel.get();
    m_documentColorHistoryModel = nullptr;
 
    m_history = new WGColorPatches(m_displayConfig, m_globalColorHistoryModel, 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, WGColorPatches::History, KisIconUtils::loadIcon(), m_colorChangeCompressor, m_colorModelFG, m_commonColors, m_commonColorSet, m_configButton, m_displayConfig, m_documentColorHistoryModel, m_fallbackColorHistoryModel, m_gamutToolbar, m_globalColorHistoryModel, m_history, m_mainWidget, 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

◆ colorHistoryModel()

KisUniqueColorSet * WGColorSelectorDock::colorHistoryModel ( ) const

Definition at line 164 of file WGColorSelectorDock.cpp.

{
    return m_colorHistoryFromDocument && m_documentColorHistoryModel ? m_documentColorHistoryModel
                                                                     : m_globalColorHistoryModel;
}

References m_colorHistoryFromDocument, m_documentColorHistoryModel, and m_globalColorHistoryModel.

◆ colorModel()

const KisVisualColorModel & WGColorSelectorDock::colorModel ( ) const

Definition at line 124 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 243 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 134 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.

◆ eventFilter()

bool WGColorSelectorDock::eventFilter	(	QObject *	obj,
		QEvent *	ev )

overrideprotected

Definition at line 514 of file WGColorSelectorDock.cpp.

{
    Q_UNUSED(obj);
 
    // Get the leave event of the inner widget, for when the docker is borrowed and doesn't properly handle leave events
    if (e->type() == QEvent::Leave) {
        m_colorTooltip->hide();
    }
 
    return false;
}

References m_colorTooltip.

◆ selectingBackground()

bool WGColorSelectorDock::selectingBackground ( ) const

Definition at line 143 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 170 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_globalColorHistoryModel = resourceProvider->colorHistoryModel();
        m_documentColorHistoryModel = m_canvas->imageView()->document()->colorHistoryModel();
 
        m_history->setColorHistoryModel(colorHistoryModel());
        m_actionManager->updateColorHistoryModel();
 
        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 KisCanvasResourceProvider::colorHistoryModel(), colorHistoryModel(), KisGamutMaskToolbar::connectMaskSignals(), disconnectFromCanvas(), m_actionManager, m_canvas, m_commonColorSet, m_displayConfig, m_documentColorHistoryModel, m_gamutToolbar, m_globalColorHistoryModel, m_history, m_selector, WGActionManager::setCanvas(), WGColorPatches::setColorHistoryModel(), KisVisualColorSelector::setDisplayRenderer(), WGCommonColorSet::setImage(), slotCanvasResourceChanged(), slotDisplayConfigurationChanged(), slotFGColorUsed(), and WGActionManager::updateColorHistoryModel().

◆ 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 148 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 238 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 478 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 439 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(m_mainWidget);
        }
    }
}

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

◆ slotColorSelected

void WGColorSelectorDock::slotColorSelected ( const KoColor & color )

privateslot

Definition at line 398 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 417 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 302 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_colorHistoryFromDocument = cfg.get(WGConfig::colorHistoryFromDocument);
    m_history->updateSettings();
    m_history->setColorHistoryModel(colorHistoryModel());
    m_actionManager->updateColorHistoryModel();
 
    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::colorHistoryFromDocument, colorHistoryModel(), WGConfig::colorSpaceSource, WGConfig::commonColorsAutoUpdate, FixedColorSpace, WGQuickSettingsWidget::loadConfiguration(), m_actionManager, m_canvas, m_colorHistoryFromDocument, 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(), WGColorPatches::setColorHistoryModel(), KisVisualColorSelector::setConfiguration(), KisVisualColorSelector::setProofColors(), KisVisualColorSelector::setRenderMode(), slotDisplayConfigurationChanged(), slotOpenSettings(), WGActionManager::updateColorHistoryModel(), updateLayout(), WGColorPatches::updateSettings(), and WGShadeSelector::updateSettings().

◆ slotDisplayConfigurationChanged

void WGColorSelectorDock::slotDisplayConfigurationChanged ( )

privateslot

Definition at line 365 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 453 of file WGColorSelectorDock.cpp.

{
    QColor lastCol = m_displayConfig->displayConverter()->toQColor(color);
    m_colorTooltip->setLastUsedColor(lastCol);
    m_actionManager->setLastUsedColor(color);
    if (m_colorHistoryFromDocument) {
        m_documentColorHistoryModel->addColor(color);
    } else {
        m_globalColorHistoryModel->addColor(color);
    }
}

References KisUniqueColorSet::addColor(), m_actionManager, m_colorHistoryFromDocument, m_colorTooltip, m_displayConfig, m_documentColorHistoryModel, m_globalColorHistoryModel, WGActionManager::setLastUsedColor(), and WGColorPreviewToolTip::setLastUsedColor().

◆ slotOpenSettings

void WGColorSelectorDock::slotOpenSettings ( )

privateslot

Definition at line 499 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 465 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 509 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 225 of file WGColorSelectorDock.cpp.

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

References m_actionManager, m_canvas, m_commonColorSet, m_displayConfig, m_documentColorHistoryModel, m_globalColorHistoryModel, m_history, m_selector, WGActionManager::setCanvas(), WGColorPatches::setColorHistoryModel(), KisVisualColorSelector::setDisplayRenderer(), and WGCommonColorSet::setImage().

◆ updateLayout()

void WGColorSelectorDock::updateLayout ( )

protected

Definition at line 251 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 99 of file WGColorSelectorDock.h.

99{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_colorHistoryFromDocument

bool WGColorSelectorDock::m_colorHistoryFromDocument {false}

private

Definition at line 96 of file WGColorSelectorDock.h.

96{false};

◆ m_colorModelBG

KisVisualColorModelSP WGColorSelectorDock::m_colorModelBG

private

Definition at line 108 of file WGColorSelectorDock.h.

◆ m_colorModelFG

KisVisualColorModelSP WGColorSelectorDock::m_colorModelFG

private

Definition at line 107 of file WGColorSelectorDock.h.

◆ m_colorTooltip

WGColorPreviewToolTip* WGColorSelectorDock::m_colorTooltip {0}

private

Definition at line 100 of file WGColorSelectorDock.h.

100{0};

◆ m_commonColors

WGColorPatches* WGColorSelectorDock::m_commonColors {0}

private

Definition at line 103 of file WGColorSelectorDock.h.

103{0};

◆ m_commonColorSet

WGCommonColorSet* WGColorSelectorDock::m_commonColorSet {0}

private

Definition at line 98 of file WGColorSelectorDock.h.

98{0};

◆ m_configButton

QToolButton* WGColorSelectorDock::m_configButton {0}

private

Definition at line 106 of file WGColorSelectorDock.h.

106{0};

◆ m_CSSource

ColorSpaceSource WGColorSelectorDock::m_CSSource {LayerColorSpace}

private

Definition at line 110 of file WGColorSelectorDock.h.

110{LayerColorSpace};

◆ m_customCS

const KoColorSpace* WGColorSelectorDock::m_customCS {0}

private

Definition at line 109 of file WGColorSelectorDock.h.

109{0};

◆ m_displayConfig

WGSelectorDisplayConfigSP WGColorSelectorDock::m_displayConfig

private

Definition at line 84 of file WGColorSelectorDock.h.

◆ m_documentColorHistoryModel

KisUniqueColorSet* WGColorSelectorDock::m_documentColorHistoryModel {0}

private

Definition at line 94 of file WGColorSelectorDock.h.

94{0};

◆ m_fallbackColorHistoryModel

std::unique_ptr<KisUniqueColorSet> WGColorSelectorDock::m_fallbackColorHistoryModel

private

Definition at line 95 of file WGColorSelectorDock.h.

◆ m_gamutToolbar

KisGamutMaskToolbar* WGColorSelectorDock::m_gamutToolbar

private

Definition at line 97 of file WGColorSelectorDock.h.

◆ m_globalColorHistoryModel

KisUniqueColorSet* WGColorSelectorDock::m_globalColorHistoryModel {0}

private

Definition at line 93 of file WGColorSelectorDock.h.

93{0};

◆ m_history

WGColorPatches* WGColorSelectorDock::m_history {0}

private

Definition at line 102 of file WGColorSelectorDock.h.

102{0};

◆ m_mainWidget

QWidget* WGColorSelectorDock::m_mainWidget

private

Definition at line 114 of file WGColorSelectorDock.h.

◆ m_mainWidgetLayout

QBoxLayout* WGColorSelectorDock::m_mainWidgetLayout {0}

private

Definition at line 86 of file WGColorSelectorDock.h.

86{0};

◆ m_pendingBgUpdate

bool WGColorSelectorDock::m_pendingBgUpdate {false}

private

Definition at line 112 of file WGColorSelectorDock.h.

112{false};

◆ m_pendingFgUpdate

bool WGColorSelectorDock::m_pendingFgUpdate {false}

private

Definition at line 111 of file WGColorSelectorDock.h.

111{false};

◆ m_quickSettingAction

QWidgetAction* WGColorSelectorDock::m_quickSettingAction {0}

private

Definition at line 104 of file WGColorSelectorDock.h.

104{0};

◆ m_quickSettings

WGQuickSettingsWidget* WGColorSelectorDock::m_quickSettings {0}

private

Definition at line 105 of file WGColorSelectorDock.h.

105{0};

◆ m_selector

KisVisualColorSelector* WGColorSelectorDock::m_selector {0}

private

Definition at line 90 of file WGColorSelectorDock.h.

90{0};

◆ m_selectorAreaLayout

QBoxLayout* WGColorSelectorDock::m_selectorAreaLayout {0}

private

Definition at line 87 of file WGColorSelectorDock.h.

87{0};

◆ m_shadeSelector

WGShadeSelector* WGColorSelectorDock::m_shadeSelector {0}

private

Definition at line 101 of file WGColorSelectorDock.h.

101{0};

◆ m_toggle

KisColorSourceToggle* WGColorSelectorDock::m_toggle {0}

private

Definition at line 91 of file WGColorSelectorDock.h.

91{0};

◆ m_verticalElementsLayout

QBoxLayout* WGColorSelectorDock::m_verticalElementsLayout {0}

private

Definition at line 88 of file WGColorSelectorDock.h.

88{0};

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

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

Public Types

Public Member Functions

Protected Member Functions

Private Slots

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ ColorSpaceSource

Constructor & Destructor Documentation

◆ WGColorSelectorDock()

Member Function Documentation

◆ colorHistoryModel()

◆ colorModel()

◆ disconnectFromCanvas()

◆ displayColorConverter()

◆ eventFilter()

◆ selectingBackground()

◆ setCanvas()

◆ setChannelValues()

◆ setViewManager()

◆ slotCanvasResourceChanged

◆ slotColorInteraction

◆ slotColorSelected

◆ slotColorSourceToggled

◆ slotConfigurationChanged

◆ slotDisplayConfigurationChanged

◆ slotFGColorUsed

◆ slotOpenSettings

◆ slotSetNewColors

◆ slotShowGamutMaskToolbar

◆ unsetCanvas()

◆ updateLayout()

Member Data Documentation

◆ m_actionManager

◆ m_canvas

◆ m_colorChangeCompressor

◆ m_colorHistoryFromDocument

◆ m_colorModelBG

◆ m_colorModelFG

◆ m_colorTooltip

◆ m_commonColors

◆ m_commonColorSet

◆ m_configButton

◆ m_CSSource

◆ m_customCS

◆ m_displayConfig

◆ m_documentColorHistoryModel

◆ m_fallbackColorHistoryModel

◆ m_gamutToolbar

◆ m_globalColorHistoryModel

◆ m_history

◆ m_mainWidget

◆ m_mainWidgetLayout

◆ m_pendingBgUpdate

◆ m_pendingFgUpdate

◆ m_quickSettingAction

◆ m_quickSettings

◆ m_selector

◆ m_selectorAreaLayout

◆ m_shadeSelector

◆ m_toggle

◆ m_verticalElementsLayout