ArtisticColorSelectorDock Class Reference

#include <artisticcolorselector_dock.h>

Inheritance diagram for ArtisticColorSelectorDock:

Public Member Functions
	ArtisticColorSelectorDock ()
QString	observerName () override
void	setCanvas (KoCanvasBase *canvas) override
void	setViewManager (KisViewManager *kisview) override
void	unsetCanvas () override
	~ArtisticColorSelectorDock () 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 ()

Private Slots
void	slotBgColorChanged (const KisColor &color)
void	slotCanvasResourceChanged (int key, const QVariant &value)
void	slotColorSpaceSelected ()
void	slotFgColorChanged (const KisColor &color)
void	slotGamutMaskDeactivate ()
void	slotGamutMaskPreviewUpdate ()
void	slotGamutMaskSet (KoGamutMaskSP mask)
void	slotGamutMaskToggle (bool value)
void	slotGamutMaskUnset ()
void	slotPreferenceChanged ()
void	slotResetDefaultSettings ()
void	slotSelectorSettingsChanged ()

Private Attributes
KisCanvas2 *	m_canvas
QButtonGroup *	m_hsxButtons
QIcon	m_iconMaskOff
QIcon	m_iconMaskOn
QPixmap	m_infinityPixmap
ARCSSettingsUI *	m_preferencesUI
KisCanvasResourceProvider *	m_resourceProvider
KoGamutMaskSP	m_selectedMask
ArtisticColorSelectorUI *	m_selectorUI
WheelPreferencesPopupUI *	m_wheelPrefsUI

Additional Inherited Members

Detailed Description

Definition at line 31 of file artisticcolorselector_dock.h.

Constructor & Destructor Documentation

ArtisticColorSelectorDock()

ArtisticColorSelectorDock::ArtisticColorSelectorDock

(

)

Definition at line 65 of file artisticcolorselector_dock.cpp.

    : QDockWidget(i18n("Artistic Color Selector"))
    , m_canvas(nullptr)
    , m_resourceProvider(0)
    , m_selectedMask(nullptr)
{
    setEnabled(false);
 
    m_hsxButtons    = new QButtonGroup();
    m_preferencesUI = new ARCSSettingsUI();
    m_wheelPrefsUI  = new WheelPreferencesPopupUI();
    m_selectorUI    = new ArtisticColorSelectorUI();
 
    QPixmap hueStepsPixmap = KisIconUtils::loadIcon("wheel-sectors").pixmap(16,16);
    QPixmap saturationStepsPixmap = KisIconUtils::loadIcon("wheel-rings").pixmap(16,16);
    QPixmap valueScaleStepsPixmap = KisIconUtils::loadIcon("wheel-light").pixmap(16,16);
    QIcon infinityIcon = KisIconUtils::loadIcon("infinity");
    m_infinityPixmap = infinityIcon.pixmap(16,16);
 
    m_selectorUI->colorSelector->loadSettings();
 
    m_selectorUI->bnWheelPrefs->setIcon(KisIconUtils::loadIcon("wheel-sectors"));
    m_selectorUI->bnWheelPrefs->setPopupWidget(m_wheelPrefsUI);
    m_selectorUI->bnWheelPrefs->setArrowVisible(false);
 
    m_selectorUI->bnDockerPrefs->setPopupWidget(m_preferencesUI);
    m_selectorUI->bnDockerPrefs->setIcon(KisIconUtils::loadIcon("configure-thicker"));
    m_selectorUI->bnDockerPrefs->setArrowVisible(false);
 
    //preferences
    m_hsxButtons->addButton(m_preferencesUI->bnHsy, KisColor::HSY);
    m_hsxButtons->addButton(m_preferencesUI->bnHsi, KisColor::HSI);
    m_hsxButtons->addButton(m_preferencesUI->bnHsl, KisColor::HSL);
    m_hsxButtons->addButton(m_preferencesUI->bnHsv, KisColor::HSV);
 
    m_wheelPrefsUI->bnInverseSat->setChecked(m_selectorUI->colorSelector->isSaturationInverted());
 
    m_wheelPrefsUI->labelHueSteps->setPixmap(hueStepsPixmap);
    m_wheelPrefsUI->labelSaturationSteps->setPixmap(saturationStepsPixmap);
    m_wheelPrefsUI->labelValueScaleSteps->setPixmap(valueScaleStepsPixmap);
 
    m_wheelPrefsUI->numHueSteps->setRange(MIN_NUM_UI_HUE_PIECES, MAX_NUM_HUE_PIECES);
    m_wheelPrefsUI->numSaturationSteps->setRange(MIN_NUM_SATURATION_RINGS, MAX_NUM_SATURATION_RINGS);
    m_wheelPrefsUI->numValueScaleSteps->setRange(MIN_NUM_UI_LIGHT_PIECES, MAX_NUM_LIGHT_PIECES);
 
    m_wheelPrefsUI->bnInfHueSteps->setIcon(infinityIcon);
    m_wheelPrefsUI->bnInfValueScaleSteps->setIcon(infinityIcon);
 
    m_wheelPrefsUI->bnInfHueSteps->setToolTip(i18n("Continuous Mode"));
    m_wheelPrefsUI->bnInfValueScaleSteps->setToolTip(i18n("Continuous Mode"));
 
    int selectorHueSteps = m_selectorUI->colorSelector->getNumPieces();
    if (selectorHueSteps == 1) {
        m_wheelPrefsUI->bnInfHueSteps->setChecked(true);
    } else {
        m_wheelPrefsUI->bnInfHueSteps->setChecked(false);
    }
    m_wheelPrefsUI->numHueSteps->setValue(selectorHueSteps);
 
    m_wheelPrefsUI->numSaturationSteps->setValue(m_selectorUI->colorSelector->getNumRings());
 
    int selectorValueScaleSteps = m_selectorUI->colorSelector->getNumLightPieces();
    if (selectorValueScaleSteps == 1) {
        m_wheelPrefsUI->bnInfValueScaleSteps->setChecked(true);
    } else {
        m_wheelPrefsUI->bnInfValueScaleSteps->setChecked(false);
    }
    m_wheelPrefsUI->numValueScaleSteps->setValue(m_selectorUI->colorSelector->getNumLightPieces());
 
    m_preferencesUI->bnDefInfHueSteps->setIcon(infinityIcon);
    m_preferencesUI->bnDefInfValueScaleSteps->setIcon(infinityIcon);
 
    m_preferencesUI->labelDefHueSteps->setPixmap(hueStepsPixmap);
    m_preferencesUI->labelDefSaturationSteps->setPixmap(saturationStepsPixmap);
    m_preferencesUI->labelDefValueScaleSteps->setPixmap(valueScaleStepsPixmap);
 
    m_preferencesUI->defaultHueSteps->setRange(MIN_NUM_HUE_PIECES, MAX_NUM_HUE_PIECES);
    m_preferencesUI->defaultSaturationSteps->setRange(MIN_NUM_SATURATION_RINGS, MAX_NUM_SATURATION_RINGS);
    m_preferencesUI->defaultValueScaleSteps->setRange(MIN_NUM_LIGHT_PIECES, MAX_NUM_LIGHT_PIECES);
 
    m_preferencesUI->defaultHueSteps->setValue(m_selectorUI->colorSelector->getDefaultHueSteps());
    m_preferencesUI->defaultSaturationSteps->setValue(m_selectorUI->colorSelector->getDefaultSaturationSteps());
    m_preferencesUI->defaultValueScaleSteps->setValue(m_selectorUI->colorSelector->getDefaultValueScaleSteps());
 
    m_preferencesUI->showBgColor->setChecked(m_selectorUI->colorSelector->getShowBgColor());
    m_preferencesUI->showValueScaleNumbers->setChecked(m_selectorUI->colorSelector->getShowValueScaleNumbers());
 
    m_preferencesUI->enforceGamutMask->setChecked(m_selectorUI->colorSelector->enforceGamutMask());
    m_preferencesUI->permissiveGamutMask->setChecked(!m_selectorUI->colorSelector->enforceGamutMask());
 
    m_preferencesUI->spLumaR->setValue(m_selectorUI->colorSelector->lumaR());
    m_preferencesUI->spLumaG->setValue(m_selectorUI->colorSelector->lumaG());
    m_preferencesUI->spLumaB->setValue(m_selectorUI->colorSelector->lumaB());
    m_preferencesUI->spLumaGamma->setValue(m_selectorUI->colorSelector->lumaGamma());
 
    switch(m_selectorUI->colorSelector->getColorSpace())
    {
        case KisColor::HSV: { m_preferencesUI->bnHsv->setChecked(true); } break;
        case KisColor::HSI: { m_preferencesUI->bnHsi->setChecked(true); } break;
        case KisColor::HSL: { m_preferencesUI->bnHsl->setChecked(true); } break;
        case KisColor::HSY: { m_preferencesUI->bnHsy->setChecked(true); } break;
    }
 
    if (m_selectorUI->colorSelector->getColorSpace() == KisColor::HSY) {
        m_preferencesUI->lumaCoefficientBox->show();
    } else {
        m_preferencesUI->lumaCoefficientBox->hide();
    }
 
    connect(m_wheelPrefsUI->numValueScaleSteps  , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
    connect(m_wheelPrefsUI->numHueSteps         , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
    connect(m_wheelPrefsUI->numSaturationSteps  , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
    connect(m_wheelPrefsUI->bnInverseSat        , SIGNAL(clicked(bool))                          , SLOT(slotPreferenceChanged()));
    connect(m_wheelPrefsUI->bnInfHueSteps       , SIGNAL(clicked(bool))                           , SLOT(slotPreferenceChanged()));
    connect(m_wheelPrefsUI->bnInfValueScaleSteps, SIGNAL(clicked(bool))                           , SLOT(slotPreferenceChanged()));
    connect(m_wheelPrefsUI->bnDefault           , SIGNAL(clicked(bool))                          , SLOT(slotResetDefaultSettings()));
 
    connect(m_preferencesUI->defaultHueSteps    , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
    connect(m_preferencesUI->defaultSaturationSteps, SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
    connect(m_preferencesUI->defaultValueScaleSteps, SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
    connect(m_preferencesUI->bnDefInfHueSteps       , SIGNAL(clicked(bool))                           , SLOT(slotPreferenceChanged()));
    connect(m_preferencesUI->bnDefInfValueScaleSteps, SIGNAL(clicked(bool))                           , SLOT(slotPreferenceChanged()));
 
    connect(m_preferencesUI->showBgColor        , SIGNAL(toggled(bool))                      , SLOT(slotPreferenceChanged()));
    connect(m_preferencesUI->showValueScaleNumbers, SIGNAL(toggled(bool))                      , SLOT(slotPreferenceChanged()));
    connect(m_preferencesUI->enforceGamutMask   , SIGNAL(toggled(bool))                      , SLOT(slotPreferenceChanged()));
 
    connect(m_preferencesUI->spLumaR   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
    connect(m_preferencesUI->spLumaG   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
    connect(m_preferencesUI->spLumaB   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
    connect(m_preferencesUI->spLumaGamma   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
 
    connect(m_selectorUI->colorSelector         , SIGNAL(sigFgColorChanged(KisColor))     , SLOT(slotFgColorChanged(KisColor)));
    connect(m_selectorUI->colorSelector         , SIGNAL(sigBgColorChanged(KisColor))     , SLOT(slotBgColorChanged(KisColor)));
 
    connect(m_hsxButtons                        , SIGNAL(idClicked(int))                     , SLOT(slotColorSpaceSelected()));
 
    setWidget(m_selectorUI);
}

References connect(), KisColor::HSI, KisColor::HSL, KisColor::HSV, KisColor::HSY, KisIconUtils::loadIcon(), m_hsxButtons, m_infinityPixmap, m_preferencesUI, m_selectorUI, m_wheelPrefsUI, MAX_NUM_HUE_PIECES, MAX_NUM_LIGHT_PIECES, MAX_NUM_SATURATION_RINGS, MIN_NUM_HUE_PIECES, MIN_NUM_LIGHT_PIECES, MIN_NUM_SATURATION_RINGS, MIN_NUM_UI_HUE_PIECES, MIN_NUM_UI_LIGHT_PIECES, slotBgColorChanged(), slotColorSpaceSelected(), slotFgColorChanged(), slotPreferenceChanged(), and slotResetDefaultSettings().

~ArtisticColorSelectorDock()

ArtisticColorSelectorDock::~ArtisticColorSelectorDock ( )

override

Definition at line 205 of file artisticcolorselector_dock.cpp.

{
    m_selectorUI->colorSelector->saveSettings();
    delete m_hsxButtons;
}

References m_hsxButtons, and m_selectorUI.

Member Function Documentation

observerName()

QString ArtisticColorSelectorDock::observerName ( )

inlineoverridevirtual

Reimplemented from KoCanvasObserverBase.

Definition at line 38 of file artisticcolorselector_dock.h.

{ return "ArtisticColorSelectorDock"; }

setCanvas()

void ArtisticColorSelectorDock::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 378 of file artisticcolorselector_dock.cpp.

{
    if (!canvas) {
        return;
    }
 
    m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
    if (m_canvas) {
        m_canvas->disconnectCanvasObserver(this);
    }
 
    if (m_canvas) {
        connect(m_canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
                SLOT(slotCanvasResourceChanged(int,QVariant)), Qt::UniqueConnection);
 
        connect(m_canvas->displayColorConverter(), SIGNAL(displayConfigurationChanged()),
                SLOT(slotSelectorSettingsChanged()), Qt::UniqueConnection);
 
        m_selectorUI->colorSelector->setColorConverter(m_canvas->displayColorConverter());
        setEnabled(true);
    }
}

References connect(), KisCanvas2::disconnectCanvasObserver(), KisCanvas2::displayColorConverter, m_canvas, m_selectorUI, KoCanvasBase::resourceManager, slotCanvasResourceChanged(), and slotSelectorSettingsChanged().

setViewManager()

void ArtisticColorSelectorDock::setViewManager ( KisViewManager * kisview )

overridevirtual

Implements KisMainwindowObserver.

Definition at line 211 of file artisticcolorselector_dock.cpp.

{
    m_resourceProvider = kisview->canvasResourceProvider();
    m_selectorUI->colorSelector->setFgColor(m_resourceProvider->resourceManager()->foregroundColor());
    m_selectorUI->colorSelector->setBgColor(m_resourceProvider->resourceManager()->backgroundColor());
 
    connect(m_resourceProvider, SIGNAL(sigGamutMaskChanged(KoGamutMaskSP)),
            this, SLOT(slotGamutMaskSet(KoGamutMaskSP)), Qt::UniqueConnection);
 
    connect(m_resourceProvider, SIGNAL(sigGamutMaskUnset()),
            this, SLOT(slotGamutMaskUnset()), Qt::UniqueConnection);
 
    connect(m_resourceProvider, SIGNAL(sigGamutMaskPreviewUpdate()),
            this, SLOT(slotGamutMaskPreviewUpdate()), Qt::UniqueConnection);
 
    connect(m_resourceProvider, SIGNAL(sigGamutMaskDeactivated()),
            this, SLOT(slotGamutMaskDeactivate()), Qt::UniqueConnection);
 
    m_selectorUI->gamutMaskToolbar->connectMaskSignals(m_resourceProvider);
}

References KoCanvasResourceProvider::backgroundColor(), KisViewManager::canvasResourceProvider(), connect(), KoCanvasResourceProvider::foregroundColor(), m_resourceProvider, m_selectorUI, KisCanvasResourceProvider::resourceManager(), slotGamutMaskDeactivate(), slotGamutMaskPreviewUpdate(), slotGamutMaskSet(), and slotGamutMaskUnset().

slotBgColorChanged

void ArtisticColorSelectorDock::slotBgColorChanged ( const KisColor & color )

privateslot

Definition at line 248 of file artisticcolorselector_dock.cpp.

{
    m_resourceProvider->resourceManager()->setBackgroundColor(
        KoColor(color.toKoColor(), m_resourceProvider->resourceManager()->backgroundColor().colorSpace())
    );
}

References KoCanvasResourceProvider::backgroundColor(), KoColor::colorSpace(), m_resourceProvider, KisCanvasResourceProvider::resourceManager(), KoCanvasResourceProvider::setBackgroundColor(), and KisColor::toKoColor().

slotCanvasResourceChanged

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

privateslot

Definition at line 232 of file artisticcolorselector_dock.cpp.

{
    if(key == KoCanvasResource::ForegroundColor)
        m_selectorUI->colorSelector->setFgColor(value.value<KoColor>());
 
    if(key == KoCanvasResource::BackgroundColor)
        m_selectorUI->colorSelector->setBgColor(value.value<KoColor>());
}

References KoCanvasResource::BackgroundColor, KoCanvasResource::ForegroundColor, m_selectorUI, and value().

slotColorSpaceSelected

void ArtisticColorSelectorDock::slotColorSpaceSelected ( )

privateslot

Definition at line 255 of file artisticcolorselector_dock.cpp.

{
    KisColor::Type type = static_cast<KisColor::Type>(
                m_hsxButtons->id(m_hsxButtons->checkedButton()));
 
    m_selectorUI->colorSelector->setColorSpace(type);
 
    if (type == KisColor::HSY) {
        m_preferencesUI->lumaCoefficientBox->show();
    } else {
        m_preferencesUI->lumaCoefficientBox->hide();
    }
 
    m_selectorUI->colorSelector->setLumaCoefficients(
                m_preferencesUI->spLumaR->value(),
                m_preferencesUI->spLumaG->value(),
                m_preferencesUI->spLumaB->value(),
                m_preferencesUI->spLumaGamma->value()
                );
}

References KisColor::HSY, m_hsxButtons, m_preferencesUI, and m_selectorUI.

slotFgColorChanged

void ArtisticColorSelectorDock::slotFgColorChanged ( const KisColor & color )

privateslot

Definition at line 241 of file artisticcolorselector_dock.cpp.

{
    m_resourceProvider->resourceManager()->setForegroundColor(
        KoColor(color.toKoColor(), m_resourceProvider->resourceManager()->foregroundColor().colorSpace())
    );
}

References KoColor::colorSpace(), KoCanvasResourceProvider::foregroundColor(), m_resourceProvider, KisCanvasResourceProvider::resourceManager(), KoCanvasResourceProvider::setForegroundColor(), and KisColor::toKoColor().

slotGamutMaskDeactivate

void ArtisticColorSelectorDock::slotGamutMaskDeactivate ( )

privateslot

Definition at line 442 of file artisticcolorselector_dock.cpp.

{
    slotGamutMaskToggle(false);
}

References slotGamutMaskToggle().

slotGamutMaskPreviewUpdate

void ArtisticColorSelectorDock::slotGamutMaskPreviewUpdate ( )

privateslot

Definition at line 437 of file artisticcolorselector_dock.cpp.

{
    m_selectorUI->colorSelector->setDirty();
}

References m_selectorUI.

slotGamutMaskSet

void ArtisticColorSelectorDock::slotGamutMaskSet ( KoGamutMaskSP mask )

privateslot

Definition at line 409 of file artisticcolorselector_dock.cpp.

{
    if (!mask) {
        return;
    }
 
    m_selectedMask = mask;
 
    if (m_selectedMask) {
        m_selectorUI->colorSelector->setGamutMask(m_selectedMask);
        slotGamutMaskToggle(true);
    } else {
        slotGamutMaskToggle(false);
    }
}

References m_selectedMask, m_selectorUI, and slotGamutMaskToggle().

slotGamutMaskToggle

void ArtisticColorSelectorDock::slotGamutMaskToggle ( bool value )

privateslot

Definition at line 367 of file artisticcolorselector_dock.cpp.

{
    bool b = (!m_selectedMask) ? false : checked;
 
    if (b == true) {
        m_selectorUI->colorSelector->setGamutMask(m_selectedMask);
    }
 
    m_selectorUI->colorSelector->setGamutMaskOn(b);
}

References m_selectedMask, and m_selectorUI.

slotGamutMaskUnset

void ArtisticColorSelectorDock::slotGamutMaskUnset ( )

privateslot

Definition at line 425 of file artisticcolorselector_dock.cpp.

{
    if (!m_selectedMask) {
        return;
    }
 
    m_selectedMask = nullptr;
 
    slotGamutMaskToggle(false);
    m_selectorUI->colorSelector->setGamutMask(m_selectedMask);
}

References m_selectedMask, m_selectorUI, and slotGamutMaskToggle().

slotPreferenceChanged

void ArtisticColorSelectorDock::slotPreferenceChanged ( )

privateslot

Definition at line 276 of file artisticcolorselector_dock.cpp.

{
    int hueSteps = DEFAULT_HUE_STEPS;
    if (m_wheelPrefsUI->bnInfHueSteps->isChecked()) {
        m_wheelPrefsUI->numHueSteps->setEnabled(false);
        hueSteps = 1;
    } else {
        m_wheelPrefsUI->numHueSteps->setEnabled(true);
        hueSteps = m_wheelPrefsUI->numHueSteps->value();
    }
    m_selectorUI->colorSelector->setNumPieces(hueSteps);
 
    m_selectorUI->colorSelector->setNumRings(m_wheelPrefsUI->numSaturationSteps->value());
 
    int valueScaleSteps;
    if (m_wheelPrefsUI->bnInfValueScaleSteps->isChecked()) {
        m_wheelPrefsUI->numValueScaleSteps->setEnabled(false);
        valueScaleSteps = 1;
    } else {
        valueScaleSteps = m_wheelPrefsUI->numValueScaleSteps->value();
        m_wheelPrefsUI->numValueScaleSteps->setEnabled(true);
    }
    m_selectorUI->colorSelector->setNumLightPieces(valueScaleSteps);
 
    int defHueSteps;
    if (m_preferencesUI->bnDefInfHueSteps->isChecked()) {
        m_preferencesUI->defaultHueSteps->setEnabled(false);
        defHueSteps = 1;
    } else {
        m_preferencesUI->defaultHueSteps->setEnabled(true);
        defHueSteps = m_preferencesUI->defaultHueSteps->value();
    }
    m_selectorUI->colorSelector->setDefaultHueSteps(defHueSteps);
 
    m_selectorUI->colorSelector->setDefaultSaturationSteps(m_preferencesUI->defaultSaturationSteps->value());
 
    int defValueScaleSteps;
    if (m_preferencesUI->bnDefInfValueScaleSteps->isChecked()) {
        m_preferencesUI->defaultValueScaleSteps->setEnabled(false);
        defValueScaleSteps = 1;
    } else {
        m_preferencesUI->defaultValueScaleSteps->setEnabled(true);
        defValueScaleSteps = m_preferencesUI->defaultValueScaleSteps->value();
    }
    m_selectorUI->colorSelector->setDefaultValueScaleSteps(defValueScaleSteps);
 
    m_selectorUI->colorSelector->setShowBgColor(m_preferencesUI->showBgColor->isChecked());
    m_selectorUI->colorSelector->setShowValueScaleNumbers(m_preferencesUI->showValueScaleNumbers->isChecked());
    m_selectorUI->colorSelector->setEnforceGamutMask(m_preferencesUI->enforceGamutMask->isChecked());
 
    m_selectorUI->colorSelector->setInverseSaturation(m_wheelPrefsUI->bnInverseSat->isChecked());
}

References DEFAULT_HUE_STEPS, m_preferencesUI, m_selectorUI, and m_wheelPrefsUI.

slotResetDefaultSettings

void ArtisticColorSelectorDock::slotResetDefaultSettings ( )

privateslot

Definition at line 329 of file artisticcolorselector_dock.cpp.

{
    quint32 hueSteps = m_selectorUI->colorSelector->getDefaultHueSteps();
    quint32 saturationSteps = m_selectorUI->colorSelector->getDefaultSaturationSteps();
    quint32 valueScaleSteps = m_selectorUI->colorSelector->getDefaultValueScaleSteps();
 
    m_selectorUI->colorSelector->setNumRings(saturationSteps);
    m_wheelPrefsUI->numSaturationSteps->blockSignals(true);
    m_wheelPrefsUI->numSaturationSteps->setValue(saturationSteps);
    m_wheelPrefsUI->numSaturationSteps->blockSignals(false);
 
    m_selectorUI->colorSelector->setNumPieces(hueSteps);
    m_wheelPrefsUI->numHueSteps->blockSignals(true);
    m_wheelPrefsUI->numHueSteps->setValue(hueSteps);
    m_wheelPrefsUI->numHueSteps->blockSignals(false);
 
    if (hueSteps == 1) {
        m_wheelPrefsUI->numHueSteps->setEnabled(false);
        m_wheelPrefsUI->bnInfHueSteps->setChecked(true);
    } else {
        m_wheelPrefsUI->numHueSteps->setEnabled(true);
        m_wheelPrefsUI->bnInfHueSteps->setChecked(false);
    }
 
    m_selectorUI->colorSelector->setNumLightPieces(valueScaleSteps);
    m_wheelPrefsUI->numValueScaleSteps->blockSignals(true);
    m_wheelPrefsUI->numValueScaleSteps->setValue(valueScaleSteps);
    m_wheelPrefsUI->numValueScaleSteps->blockSignals(false);
 
    if (valueScaleSteps == 1) {
        m_wheelPrefsUI->numValueScaleSteps->setEnabled(false);
        m_wheelPrefsUI->bnInfValueScaleSteps->setChecked(true);
    } else {
        m_wheelPrefsUI->numValueScaleSteps->setEnabled(true);
        m_wheelPrefsUI->bnInfValueScaleSteps->setChecked(false);
    }
}

References m_selectorUI, and m_wheelPrefsUI.

slotSelectorSettingsChanged

void ArtisticColorSelectorDock::slotSelectorSettingsChanged ( )

privateslot

Definition at line 447 of file artisticcolorselector_dock.cpp.

{
    m_selectorUI->colorSelector->setDirty();
}

References m_selectorUI.

unsetCanvas()

void ArtisticColorSelectorDock::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 402 of file artisticcolorselector_dock.cpp.

{
    setEnabled(false);
    m_canvas = nullptr;
    m_selectorUI->colorSelector->setColorConverter(KisDisplayColorConverter::dumbConverterInstance());
}

References KisDisplayColorConverter::dumbConverterInstance(), m_canvas, and m_selectorUI.

Member Data Documentation

m_canvas

KisCanvas2* ArtisticColorSelectorDock::m_canvas

private

Definition at line 58 of file artisticcolorselector_dock.h.

m_hsxButtons

QButtonGroup* ArtisticColorSelectorDock::m_hsxButtons

private

Definition at line 60 of file artisticcolorselector_dock.h.

m_iconMaskOff

QIcon ArtisticColorSelectorDock::m_iconMaskOff

private

Definition at line 66 of file artisticcolorselector_dock.h.

m_iconMaskOn

QIcon ArtisticColorSelectorDock::m_iconMaskOn

private

Definition at line 67 of file artisticcolorselector_dock.h.

m_infinityPixmap

QPixmap ArtisticColorSelectorDock::m_infinityPixmap

private

Definition at line 69 of file artisticcolorselector_dock.h.

m_preferencesUI

ARCSSettingsUI* ArtisticColorSelectorDock::m_preferencesUI

private

Definition at line 62 of file artisticcolorselector_dock.h.

m_resourceProvider

KisCanvasResourceProvider* ArtisticColorSelectorDock::m_resourceProvider

private

Definition at line 59 of file artisticcolorselector_dock.h.

m_selectedMask

KoGamutMaskSP ArtisticColorSelectorDock::m_selectedMask

private

Definition at line 64 of file artisticcolorselector_dock.h.

m_selectorUI

ArtisticColorSelectorUI* ArtisticColorSelectorDock::m_selectorUI

private

Definition at line 61 of file artisticcolorselector_dock.h.

m_wheelPrefsUI

WheelPreferencesPopupUI* ArtisticColorSelectorDock::m_wheelPrefsUI

private

Definition at line 63 of file artisticcolorselector_dock.h.

---

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

• plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h
• plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp