WGActionManager Class Reference

#include <WGActionManager.h>

Inheritance diagram for WGActionManager:

Public Member Functions
void	registerActions (KisViewManager *viewManager)
void	setCanvas (KisCanvas2 *canvas, KisCanvas2 *oldCanvas)
void	setLastUsedColor (const KoColor &col)
void	updateColorHistoryModel ()
	WGActionManager (WGColorSelectorDock *parentDock=nullptr)
	~WGActionManager () override

Private Slots
void	slotChannelValuesChanged ()
void	slotColorInteraction (bool active)
void	slotColorPatchInteraction (bool active)
void	slotColorSelected (const KoColor &color)
void	slotConfigChanged ()
void	slotDecreaseLightness ()
void	slotDecreaseSaturation ()
void	slotIncreaseLightness ()
void	slotIncreaseSaturation ()
void	slotPopupClosed (WGSelectorPopup *popup)
void	slotSelectorConfigChanged ()
void	slotShiftHueCCW ()
void	slotShiftHueCW ()
void	slotShowColorHistoryPopup ()
void	slotShowColorSelectorPopup ()
void	slotShowMyPaintSelectorPopup ()
void	slotShowShadeSelectorPopup ()
void	slotUpdateDocker ()

Private Member Functions
void	loadColorSelectorSettings (WGConfig::Accessor &cfg)
void	modifyHSX (int channel, float amount)
void	showPopup (WGSelectorPopup *popup)
void	updateWidgetSize (QWidget *widget, int size)

Private Attributes
KisSignalCompressor *	m_colorChangeCompressor
WGSelectorPopup *	m_colorHistoryPopup {0}
KisVisualColorModelSP	m_colorModel
KisVisualColorSelector *	m_colorSelector {0}
WGSelectorPopup *	m_colorSelectorPopup {0}
WGColorPreviewToolTip *	m_colorTooltip
WGSelectorPopup *	m_currentPopup {0}
WGSelectorDisplayConfigSP	m_displayConfig
WGColorSelectorDock *	m_docker {0}
bool	m_isSynchronizing {false}
KoColor	m_lastUsedColor
WGMyPaintShadeSelector *	m_myPaintSelector {0}
WGSelectorPopup *	m_myPaintSelectorPopup {0}
WGShadeSelector *	m_shadeSelector {0}
WGSelectorPopup *	m_shadeSelectorPopup {0}

Detailed Description

Definition at line 30 of file WGActionManager.h.

Constructor & Destructor Documentation

WGActionManager()

WGActionManager::WGActionManager ( WGColorSelectorDock * parentDock = nullptr )

explicit

Definition at line 30 of file WGActionManager.cpp.

    : QObject(parentDock)
    , m_docker(parentDock)
    , m_displayConfig(new WGSelectorDisplayConfig)
    , m_colorTooltip(new WGColorPreviewToolTip)
    , m_colorChangeCompressor(new KisSignalCompressor(100 /* ms */, KisSignalCompressor::POSTPONE, this))
    , m_colorModel(new KisVisualColorModel)
{
    m_lastUsedColor.setOpacity(quint8(0));
    connect(m_colorChangeCompressor, SIGNAL(timeout()), SLOT(slotUpdateDocker()));
    connect(m_colorModel.data(), SIGNAL(sigChannelValuesChanged(QVector4D,quint32)), SLOT(slotChannelValuesChanged()));
    connect(WGConfig::notifier(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
    connect(WGConfig::notifier(), SIGNAL(selectorConfigChanged()), SLOT(slotSelectorConfigChanged()));
    slotConfigChanged();
}

References m_colorChangeCompressor, m_colorModel, m_lastUsedColor, WGConfig::notifier(), KoColor::setOpacity(), slotChannelValuesChanged(), slotConfigChanged(), slotSelectorConfigChanged(), and slotUpdateDocker().

~WGActionManager()

WGActionManager::~WGActionManager ( )

override

Definition at line 46 of file WGActionManager.cpp.

{
    delete m_colorSelectorPopup;
    delete m_shadeSelectorPopup;
    delete m_myPaintSelectorPopup;
    delete m_colorHistoryPopup;
}

References m_colorHistoryPopup, m_colorSelectorPopup, m_myPaintSelectorPopup, and m_shadeSelectorPopup.

Member Function Documentation

loadColorSelectorSettings()

void WGActionManager::loadColorSelectorSettings ( WGConfig::Accessor & cfg )

private

Definition at line 131 of file WGActionManager.cpp.

{
    m_colorSelector->setRenderMode(cfg.get(WGConfig::selectorRenderMode));
    slotSelectorConfigChanged();
}

References m_colorSelector, WGConfig::selectorRenderMode, KisVisualColorSelector::setRenderMode(), and slotSelectorConfigChanged().

modifyHSX()

void WGActionManager::modifyHSX ( int channel, float amount )

private

Definition at line 137 of file WGActionManager.cpp.

{
    if (channel < 0 || channel > 2) {
        return;
    }
    if (m_docker->colorModel().isHSXModel()) {
        QVector4D channelValues = m_docker->colorModel().channelValues();
        channelValues[channel] = qBound(0.0f, channelValues[channel] + amount, 1.0f);
        m_docker->setChannelValues(channelValues);
    }
}

References KisVisualColorModel::channelValues(), WGColorSelectorDock::colorModel(), KisVisualColorModel::isHSXModel(), m_docker, and WGColorSelectorDock::setChannelValues().

registerActions()

void WGActionManager::registerActions

(

KisViewManager *

viewManager

)

Definition at line 64 of file WGActionManager.cpp.

{
    KisActionManager *actionManager = viewManager->actionManager();
    KisAction *action;
    action = actionManager->createAction("show_wg_color_selector");
    connect(action, SIGNAL(triggered()), SLOT(slotShowColorSelectorPopup()));
    action = actionManager->createAction("show_wg_shade_selector");
    connect(action, SIGNAL(triggered()), SLOT(slotShowShadeSelectorPopup()));
    action = actionManager->createAction("show_wg_mypaint_selector");
    connect(action, SIGNAL(triggered()), SLOT(slotShowMyPaintSelectorPopup()));
    action = actionManager->createAction("show_wg_color_history");
    connect(action, SIGNAL(triggered()), SLOT(slotShowColorHistoryPopup()));
    action = actionManager->createAction("wgcs_lighten_color");
    connect(action, SIGNAL(triggered(bool)), SLOT(slotIncreaseLightness()));
    action = actionManager->createAction("wgcs_darken_color");
    connect(action, SIGNAL(triggered(bool)), SLOT(slotDecreaseLightness()));
    action = actionManager->createAction("wgcs_increase_saturation");
    connect(action, SIGNAL(triggered(bool)), SLOT(slotIncreaseSaturation()));
    action = actionManager->createAction("wgcs_decrease_saturation");
    connect(action, SIGNAL(triggered(bool)), SLOT(slotDecreaseSaturation()));
    action = actionManager->createAction("wgcs_shift_hue_clockwise");
    connect(action, SIGNAL(triggered(bool)), SLOT(slotShiftHueCW()));
    action = actionManager->createAction("wgcs_shift_hue_counterclockwise");
    connect(action, SIGNAL(triggered(bool)), SLOT(slotShiftHueCCW()));
}

References KisViewManager::actionManager(), KisActionManager::createAction(), slotDecreaseLightness(), slotDecreaseSaturation(), slotIncreaseLightness(), slotIncreaseSaturation(), slotShiftHueCCW(), slotShiftHueCW(), slotShowColorHistoryPopup(), slotShowColorSelectorPopup(), slotShowMyPaintSelectorPopup(), and slotShowShadeSelectorPopup().

setCanvas()

void WGActionManager::setCanvas	(	KisCanvas2 *	canvas,
		KisCanvas2 *	oldCanvas )

Definition at line 54 of file WGActionManager.cpp.

{
    Q_UNUSED(oldCanvas);
    KisDisplayColorConverter *converter = canvas ? canvas->displayColorConverter() : 0;
    m_displayConfig->setDisplayConverter(converter);
    if (m_colorSelector) {
        m_colorSelector->setDisplayRenderer(m_displayConfig->displayConverter()->displayRendererInterface());
    }
}

References KisCanvas2::displayColorConverter, m_colorSelector, m_displayConfig, and KisVisualColorSelector::setDisplayRenderer().

setLastUsedColor()

void WGActionManager::setLastUsedColor

(

const KoColor &

col

)

Definition at line 90 of file WGActionManager.cpp.

{
    m_lastUsedColor = col;
}

References m_lastUsedColor.

showPopup()

void WGActionManager::showPopup ( WGSelectorPopup * popup )

private

Definition at line 110 of file WGActionManager.cpp.

{
    // preparations
    m_isSynchronizing = true;
    if (m_currentPopup) {
        m_currentPopup->hide();
        m_currentPopup = 0;
    }
    const KisVisualColorModel &dockerModel = m_docker->colorModel();
    m_colorModel->copyState(dockerModel);
    m_colorTooltip->setLastUsedColor(m_displayConfig->displayConverter()->toQColor(m_lastUsedColor));
    QColor baseCol = m_displayConfig->displayConverter()->toQColor(m_colorModel->currentColor());
    m_colorTooltip->setCurrentColor(baseCol);
    m_colorTooltip->setPreviousColor(baseCol);
    m_isSynchronizing = false;
 
    m_currentPopup = popup;
    popup->slotShowPopup();
    m_colorTooltip->show(popup);
}

References WGColorSelectorDock::colorModel(), m_colorModel, m_colorTooltip, m_currentPopup, m_displayConfig, m_docker, m_isSynchronizing, m_lastUsedColor, WGColorPreviewToolTip::setCurrentColor(), WGColorPreviewToolTip::setLastUsedColor(), WGColorPreviewToolTip::setPreviousColor(), WGColorPreviewToolTip::show(), and WGSelectorPopup::slotShowPopup().

slotChannelValuesChanged

void WGActionManager::slotChannelValuesChanged ( )

privateslot

Definition at line 307 of file WGActionManager.cpp.

{
    // FIXME: KoColorDisplayRendererInterface's displayConfigurationChanged()
    // signal (e.g. layer switches) makes the color model Q_EMIT new channel values
    // and this would overwrite the color resources with outdated data!
    // so make sure a popup is actually active
    if (!m_isSynchronizing && m_currentPopup) {
        m_colorChangeCompressor->start();
        QColor color = m_displayConfig->displayConverter()->toQColor(m_colorModel->currentColor());
        m_colorTooltip->setCurrentColor(color);
    }
}

References m_colorChangeCompressor, m_colorModel, m_colorTooltip, m_currentPopup, m_displayConfig, m_isSynchronizing, WGColorPreviewToolTip::setCurrentColor(), and KisSignalCompressor::start().

slotColorInteraction

void WGActionManager::slotColorInteraction ( bool active )

privateslot

Definition at line 320 of file WGActionManager.cpp.

{
    if (active) {
        QColor baseCol = m_displayConfig->displayConverter()->toQColor(m_colorModel->currentColor());
        m_colorTooltip->setCurrentColor(baseCol);
        m_colorTooltip->setPreviousColor(baseCol);
    }
}

References m_colorModel, m_colorTooltip, m_displayConfig, WGColorPreviewToolTip::setCurrentColor(), and WGColorPreviewToolTip::setPreviousColor().

slotColorPatchInteraction

void WGActionManager::slotColorPatchInteraction ( bool active )

privateslot

Definition at line 329 of file WGActionManager.cpp.

{
    KoCanvasBase *canvas = m_docker->observedCanvas();
    if (active && canvas) {
        KoColor fgColor = canvas->resourceManager()->foregroundColor();
        QColor baseCol = m_docker->displayColorConverter()->toQColor(fgColor);
        m_colorTooltip->setCurrentColor(baseCol);
        m_colorTooltip->setPreviousColor(baseCol);
    }
}

References WGColorSelectorDock::displayColorConverter(), m_colorTooltip, m_docker, KoCanvasObserverBase::observedCanvas(), KoCanvasBase::resourceManager, WGColorPreviewToolTip::setCurrentColor(), WGColorPreviewToolTip::setPreviousColor(), and KisDisplayColorConverter::toQColor().

slotColorSelected

void WGActionManager::slotColorSelected ( const KoColor & color )

privateslot

Definition at line 342 of file WGActionManager.cpp.

{
    // CAVEAT: currently, the color history does not allow background color setting
    if (!m_docker->observedCanvas()) {
        return;
    }
    m_docker->observedCanvas()->resourceManager()->setForegroundColor(color);
    QColor previewCol = m_docker->displayColorConverter()->toQColor(color);
    m_colorTooltip->setCurrentColor(previewCol);
 
}

References WGColorSelectorDock::displayColorConverter(), m_colorTooltip, m_docker, KoCanvasObserverBase::observedCanvas(), KoCanvasBase::resourceManager, WGColorPreviewToolTip::setCurrentColor(), and KisDisplayColorConverter::toQColor().

slotConfigChanged

void WGActionManager::slotConfigChanged ( )

privateslot

Definition at line 149 of file WGActionManager.cpp.

{
    WGConfig::Accessor cfg;
    int popupSize = cfg.get(WGConfig::popupSize);
    bool proofColors = cfg.get(WGConfig::proofToPaintingColors);
    m_displayConfig->setPreviewInPaintingCS(proofColors);
 
    if (m_colorSelector) {
        loadColorSelectorSettings(cfg);
        m_colorSelector->setProofColors(proofColors);
        updateWidgetSize(m_colorSelector, popupSize);
    }
    if (m_shadeSelector) {
        m_shadeSelector->updateSettings();
        updateWidgetSize(m_shadeSelector, popupSize);
    }
    if (m_myPaintSelector) {
        m_myPaintSelector->updateSettings();
        updateWidgetSize(m_myPaintSelector, popupSize);
    }
    if (m_colorHistoryPopup) {
        WGSelectorWidgetBase *selector = m_colorHistoryPopup->selectorWidget();
        KIS_ASSERT(selector);
        selector->updateSettings();
        updateWidgetSize(selector, popupSize);
    }
}

References KIS_ASSERT, loadColorSelectorSettings(), m_colorHistoryPopup, m_colorSelector, m_displayConfig, m_myPaintSelector, m_shadeSelector, WGConfig::popupSize, WGConfig::proofToPaintingColors, WGSelectorPopup::selectorWidget(), KisVisualColorSelector::setProofColors(), WGSelectorWidgetBase::updateSettings(), WGShadeSelector::updateSettings(), and updateWidgetSize().

slotDecreaseLightness

void WGActionManager::slotDecreaseLightness ( )

privateslot

Definition at line 282 of file WGActionManager.cpp.

{
    modifyHSX(2, -0.1f);
}

References modifyHSX().

slotDecreaseSaturation

void WGActionManager::slotDecreaseSaturation ( )

privateslot

Definition at line 292 of file WGActionManager.cpp.

{
    modifyHSX(1, -0.1f);
}

References modifyHSX().

slotIncreaseLightness

void WGActionManager::slotIncreaseLightness ( )

privateslot

Definition at line 277 of file WGActionManager.cpp.

{
    modifyHSX(2, 0.1f);
}

References modifyHSX().

slotIncreaseSaturation

void WGActionManager::slotIncreaseSaturation ( )

privateslot

Definition at line 287 of file WGActionManager.cpp.

{
    modifyHSX(1, 0.1f);
}

References modifyHSX().

slotPopupClosed

void WGActionManager::slotPopupClosed ( WGSelectorPopup * popup )

privateslot

Definition at line 186 of file WGActionManager.cpp.

{
    if (popup == m_currentPopup) {
        m_currentPopup = 0;
        m_colorTooltip->hide();
    }
}

References m_colorTooltip, and m_currentPopup.

slotSelectorConfigChanged

void WGActionManager::slotSelectorConfigChanged ( )

privateslot

Definition at line 177 of file WGActionManager.cpp.

{
    if (m_colorSelector) {
        WGConfig::Accessor cfg;
        KisColorSelectorConfiguration selectorConf = cfg.colorSelectorConfiguration();
        m_colorSelector->setConfiguration(&selectorConf);
    }
}

References m_colorSelector, and KisVisualColorSelector::setConfiguration().

slotShiftHueCCW

void WGActionManager::slotShiftHueCCW ( )

privateslot

Definition at line 302 of file WGActionManager.cpp.

{
    modifyHSX(0, -0.1f);
}

References modifyHSX().

slotShiftHueCW

void WGActionManager::slotShiftHueCW ( )

privateslot

Definition at line 297 of file WGActionManager.cpp.

{
    modifyHSX(0, 0.1f);
}

References modifyHSX().

slotShowColorHistoryPopup

void WGActionManager::slotShowColorHistoryPopup ( )

privateslot

Definition at line 258 of file WGActionManager.cpp.

{
    if (!m_colorHistoryPopup) {
        m_colorHistoryPopup = new WGSelectorPopup;
        // when settings or a document changes, the model is switched in updateColorHistoryModel()
        WGColorPatches *history = new WGColorPatches(m_displayConfig, m_docker->colorHistoryModel());
        history->setUiMode(WGSelectorWidgetBase::PopupMode);
        history->setPreset(WGColorPatches::History);
        history->updateSettings();
        updateWidgetSize(history, WGConfig::Accessor().get(WGConfig::popupSize));
        m_colorHistoryPopup->setSelectorWidget(history);
        connect(m_colorHistoryPopup, SIGNAL(sigPopupClosed(WGSelectorPopup*)),
                SLOT(slotPopupClosed(WGSelectorPopup*)));
        connect(history, SIGNAL(sigColorInteraction(bool)), SLOT(slotColorPatchInteraction(bool)));
        connect(history, SIGNAL(sigColorChanged(KoColor)), SLOT(slotColorSelected(KoColor)));
    }
    showPopup(m_colorHistoryPopup);
}

References WGColorSelectorDock::colorHistoryModel(), get(), WGColorPatches::History, m_colorHistoryPopup, m_displayConfig, m_docker, WGSelectorWidgetBase::PopupMode, WGConfig::popupSize, WGColorPatches::setPreset(), WGSelectorPopup::setSelectorWidget(), WGSelectorWidgetBase::setUiMode(), showPopup(), slotColorPatchInteraction(), slotColorSelected(), slotPopupClosed(), WGColorPatches::updateSettings(), and updateWidgetSize().

slotShowColorSelectorPopup

void WGActionManager::slotShowColorSelectorPopup ( )

privateslot

Definition at line 194 of file WGActionManager.cpp.

{
    if (!m_colorSelectorPopup) {
        WGConfig::Accessor cfg;
        m_colorSelectorPopup = new WGSelectorPopup();
        m_colorSelector = new KisVisualColorSelector(m_colorSelectorPopup, m_colorModel);
        m_colorSelector->setDisplayRenderer(m_displayConfig->displayConverter()->displayRendererInterface());
        updateWidgetSize(m_colorSelector, cfg.get(WGConfig::popupSize));
        m_colorSelectorPopup->setSelectorWidget(m_colorSelector);
        connect(m_colorSelectorPopup, SIGNAL(sigPopupClosed(WGSelectorPopup*)),
                SLOT(slotPopupClosed(WGSelectorPopup*)));
        connect(m_colorSelector, SIGNAL(sigInteraction(bool)), SLOT(slotColorInteraction(bool)));
 
        loadColorSelectorSettings(cfg);
    }
 
    // update gamut mask
    KisCanvas2 *canvas = qobject_cast<KisCanvas2*>(m_docker->observedCanvas());
    if (canvas) {
        KisCanvasResourceProvider *resourceProvider = canvas->imageView()->resourceProvider();
        if (resourceProvider->gamutMaskActive()) {
            m_colorSelector->slotGamutMaskChanged(resourceProvider->currentGamutMask());
        }
        else {
            m_colorSelector->slotGamutMaskUnset();
        }
    }
 
    showPopup(m_colorSelectorPopup);
}

References KisCanvasResourceProvider::currentGamutMask(), KisCanvasResourceProvider::gamutMaskActive(), KisCanvas2::imageView(), loadColorSelectorSettings(), m_colorModel, m_colorSelector, m_colorSelectorPopup, m_displayConfig, m_docker, KoCanvasObserverBase::observedCanvas(), WGConfig::popupSize, KisVisualColorSelector::setDisplayRenderer(), WGSelectorPopup::setSelectorWidget(), showPopup(), slotColorInteraction(), KisVisualColorSelector::slotGamutMaskChanged(), KisVisualColorSelector::slotGamutMaskUnset(), slotPopupClosed(), and updateWidgetSize().

slotShowMyPaintSelectorPopup

void WGActionManager::slotShowMyPaintSelectorPopup ( )

privateslot

Definition at line 241 of file WGActionManager.cpp.

{
    if (!m_myPaintSelectorPopup) {
        m_myPaintSelectorPopup = new WGSelectorPopup();
        m_myPaintSelector = new WGMyPaintShadeSelector(m_displayConfig, m_myPaintSelectorPopup,
                                                       WGSelectorWidgetBase::PopupMode);
        updateWidgetSize(m_myPaintSelector, WGConfig::Accessor().get(WGConfig::popupSize));
        m_myPaintSelector->setModel(m_colorModel);
        m_myPaintSelectorPopup->setSelectorWidget(m_myPaintSelector);
        connect(m_myPaintSelectorPopup, SIGNAL(sigPopupClosed(WGSelectorPopup*)),
                SLOT(slotPopupClosed(WGSelectorPopup*)));
        connect(m_myPaintSelector, SIGNAL(sigColorInteraction(bool)), SLOT(slotColorInteraction(bool)));
    }
 
    showPopup(m_myPaintSelectorPopup);
}

References get(), m_colorModel, m_displayConfig, m_myPaintSelector, m_myPaintSelectorPopup, WGSelectorWidgetBase::PopupMode, WGConfig::popupSize, WGMyPaintShadeSelector::setModel(), WGSelectorPopup::setSelectorWidget(), showPopup(), slotColorInteraction(), slotPopupClosed(), and updateWidgetSize().

slotShowShadeSelectorPopup

void WGActionManager::slotShowShadeSelectorPopup ( )

privateslot

Definition at line 225 of file WGActionManager.cpp.

{
    if (!m_shadeSelectorPopup) {
        m_shadeSelectorPopup = new WGSelectorPopup();
        m_shadeSelector = new WGShadeSelector(m_displayConfig, m_colorModel, m_shadeSelectorPopup);
        m_shadeSelector->updateSettings();
        updateWidgetSize(m_shadeSelector, WGConfig::Accessor().get(WGConfig::popupSize));
        m_shadeSelectorPopup->setSelectorWidget(m_shadeSelector);
        connect(m_shadeSelectorPopup, SIGNAL(sigPopupClosed(WGSelectorPopup*)),
                SLOT(slotPopupClosed(WGSelectorPopup*)));
        connect(m_shadeSelector, SIGNAL(sigColorInteraction(bool)), SLOT(slotColorInteraction(bool)));
    }
 
    showPopup(m_shadeSelectorPopup);
}

References get(), m_colorModel, m_displayConfig, m_shadeSelector, m_shadeSelectorPopup, WGConfig::popupSize, WGSelectorPopup::setSelectorWidget(), showPopup(), slotColorInteraction(), slotPopupClosed(), WGShadeSelector::updateSettings(), and updateWidgetSize().

slotUpdateDocker

void WGActionManager::slotUpdateDocker ( )

privateslot

Definition at line 354 of file WGActionManager.cpp.

{
    m_docker->setChannelValues(m_colorModel->channelValues());
}

References m_colorModel, m_docker, and WGColorSelectorDock::setChannelValues().

updateColorHistoryModel()

void WGActionManager::updateColorHistoryModel

(

)

Definition at line 359 of file WGActionManager.cpp.

{
    if (!m_colorHistoryPopup) return;
 
    WGColorPatches *history = dynamic_cast<WGColorPatches*>(m_colorHistoryPopup->selectorWidget());
    if (history) {
        history->setColorHistoryModel(m_docker->colorHistoryModel());
    }
}

References WGColorSelectorDock::colorHistoryModel(), m_colorHistoryPopup, m_docker, WGSelectorPopup::selectorWidget(), and WGColorPatches::setColorHistoryModel().

updateWidgetSize()

void WGActionManager::updateWidgetSize ( QWidget * widget, int size )

private

Definition at line 95 of file WGActionManager.cpp.

{
    QSizePolicy hsp = widget->sizePolicy();
    if (hsp.horizontalPolicy() != QSizePolicy::Fixed) {
        widget->setFixedWidth(size);
    } else {
        widget->setFixedWidth(QWIDGETSIZE_MAX); // looks weird, but that really resets min size to 0...
    }
    if (hsp.verticalPolicy() != QSizePolicy::Fixed) {
        widget->setFixedHeight(size);
    } else {
        widget->setFixedHeight(QWIDGETSIZE_MAX);
    }
}

Member Data Documentation

m_colorChangeCompressor

KisSignalCompressor* WGActionManager::m_colorChangeCompressor

private

Definition at line 72 of file WGActionManager.h.

m_colorHistoryPopup

WGSelectorPopup* WGActionManager::m_colorHistoryPopup {0}

private

Definition at line 77 of file WGActionManager.h.

{0};

m_colorModel

KisVisualColorModelSP WGActionManager::m_colorModel

private

Definition at line 81 of file WGActionManager.h.

m_colorSelector

KisVisualColorSelector* WGActionManager::m_colorSelector {0}

private

Definition at line 78 of file WGActionManager.h.

{0};

m_colorSelectorPopup

WGSelectorPopup* WGActionManager::m_colorSelectorPopup {0}

private

Definition at line 74 of file WGActionManager.h.

{0};

m_colorTooltip

WGColorPreviewToolTip* WGActionManager::m_colorTooltip

private

Definition at line 71 of file WGActionManager.h.

m_currentPopup

WGSelectorPopup* WGActionManager::m_currentPopup {0}

private

Definition at line 73 of file WGActionManager.h.

{0};

m_displayConfig

WGSelectorDisplayConfigSP WGActionManager::m_displayConfig

private

Definition at line 70 of file WGActionManager.h.

m_docker

WGColorSelectorDock* WGActionManager::m_docker {0}

private

Definition at line 69 of file WGActionManager.h.

{0};

m_isSynchronizing

bool WGActionManager::m_isSynchronizing {false}

private

Definition at line 83 of file WGActionManager.h.

{false};

m_lastUsedColor

KoColor WGActionManager::m_lastUsedColor

private

Definition at line 82 of file WGActionManager.h.

m_myPaintSelector

WGMyPaintShadeSelector* WGActionManager::m_myPaintSelector {0}

private

Definition at line 80 of file WGActionManager.h.

{0};

m_myPaintSelectorPopup

WGSelectorPopup* WGActionManager::m_myPaintSelectorPopup {0}

private

Definition at line 76 of file WGActionManager.h.

{0};

m_shadeSelector

WGShadeSelector* WGActionManager::m_shadeSelector {0}

private

Definition at line 79 of file WGActionManager.h.

{0};

m_shadeSelectorPopup

WGSelectorPopup* WGActionManager::m_shadeSelectorPopup {0}

private

Definition at line 75 of file WGActionManager.h.

{0};

---

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

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