KisVisualColorSelector Class Reference

The KisVisualColorSelector class. More...

#include <KisVisualColorSelector.h>

Inheritance diagram for KisVisualColorSelector:

Classes
struct	Private

Public Types
enum	RenderMode { StaticBackground , DynamicBackground , CompositeBackground }

Public Slots
void	setDisplayRenderer (const KoColorDisplayRendererInterface *displayRenderer) override
void	slotConfigurationChanged ()
void	slotGamutMaskChanged (KoGamutMaskSP mask)
void	slotGamutMaskPreviewUpdate ()
void	slotGamutMaskUnset ()
void	slotSetColor (const KoColor &c) override
void	slotSetColorSpace (const KoColorSpace *cs) override
Public Slots inherited from KisColorSelectorInterface
virtual void	slotSetColor (const KoColor &c)=0
virtual void	slotSetColorSpace (const KoColorSpace *cs)
	slotSetColorSpace Set the color space the selector should cover

Signals
void	sigGamutMaskSupportChanged (bool supported)
	sigGamutMaskSupportChanged Signals whether gamut masks are supported by the current selector shape.
void	sigInteraction (bool active)
	sigInteraction is emitted whenever mouse interaction status changes
Signals inherited from KisColorSelectorInterface
void	sigNewColor (const KoColor &c)

Public Member Functions
KoGamutMask *	activeGamutMask () const
bool	autoAdjustExposure () const
	Get the state of automatic exposure adjustment. If enabled, the selector will set new maximum channel values on the selectorModel whenever the set display renderer signals a configuration change. The default value is true.
const KisColorSelectorConfiguration &	configuration () const
const KoColorDisplayRendererInterface *	displayRenderer () const
KoColor	getCurrentColor () const override
	KisVisualColorSelector (QWidget *parent=0, KisVisualColorModelSP model=KisVisualColorModelSP())
	KisVisualColorSelector constructor.
QSize	minimumSizeHint () const override
bool	proofColors () const
RenderMode	renderMode () const
KisVisualColorModelSP	selectorModel () const
void	setAcceptTabletEvents (bool on)
void	setAutoAdjustExposure (bool enabled)
void	setConfig (bool forceCircular, bool forceSelfUpdate) override
	setConfig
void	setConfiguration (const KisColorSelectorConfiguration *config)
	Explicitly set the shape configuration. Accepts all valid combinations of Advanced Color Selector, however parameters will be converted to HSV equivalent since color model is independent.
void	setMinimumSliderWidth (int width)
void	setProofColors (bool enabled)
void	setRenderMode (RenderMode mode)
void	setSelectorModel (KisVisualColorModelSP model)
void	setSliderPosition (Qt::Edge edge)
	Set the slider position for slider + square and slider + wheel configurations.
	~KisVisualColorSelector () override
Public Member Functions inherited from KisColorSelectorInterface
	KisColorSelectorInterface (QWidget *parent=0)
virtual void	setDisplayRenderer (const KoColorDisplayRendererInterface *displayRenderer)
	~KisColorSelectorInterface () override

Protected Member Functions
void	resizeEvent (QResizeEvent *) override

Private Slots
void	slotChannelValuesChanged (const QVector4D &values, quint32 channelFlags)
void	slotColorModelChanged ()
void	slotColorSpaceChanged ()
void	slotCursorMoved (QPointF pos)
void	slotDisplayConfigurationChanged ()
void	slotReloadConfiguration ()

Private Member Functions
QVector4D	calculateMaxChannelValues ()
void	loadACSConfig ()
void	rebuildSelector ()
void	switchDisplayRenderer (const KoColorDisplayRendererInterface *displayRenderer)
bool	useHorizontalSlider ()

Static Private Member Functions
static KisColorSelectorConfiguration	validatedConfiguration (const KisColorSelectorConfiguration &cfg)

Private Attributes
const QScopedPointer< Private >	m_d

Detailed Description

The KisVisualColorSelector class.

This gives a color selector box that draws gradients and everything.

Unlike other color selectors, this one draws the full gamut of the given colorspace.

Definition at line 30 of file KisVisualColorSelector.h.

Member Enumeration Documentation

RenderMode

enum KisVisualColorSelector::RenderMode

Enumerator
StaticBackground
DynamicBackground
CompositeBackground

Definition at line 35 of file KisVisualColorSelector.h.

                    {
        StaticBackground,
        DynamicBackground,
        CompositeBackground
    };

Constructor & Destructor Documentation

KisVisualColorSelector()

KisVisualColorSelector::KisVisualColorSelector ( QWidget * parent = 0, KisVisualColorModelSP model = KisVisualColorModelSP() )

explicit

KisVisualColorSelector constructor.

Parameters

parent	The parent widget.
model	The color model to work with. If not provided, a new one will be created.

Definition at line 50 of file KisVisualColorSelector.cpp.

    : KisColorSelectorInterface(parent)
    , m_d(new Private)
{
    m_d->acs_config = validatedConfiguration(KisColorSelectorConfiguration());
    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 
    loadACSConfig();
    if (model) {
        setSelectorModel(model);
    } else {
        setSelectorModel(KisVisualColorModelSP(new KisVisualColorModel));
        m_d->selectorModel->slotLoadACSConfig();
    }
 
    m_d->updateTimer = new KisSignalCompressor(100 /* ms */, KisSignalCompressor::POSTPONE);
    connect(m_d->updateTimer, SIGNAL(timeout()), SLOT(slotReloadConfiguration()), Qt::UniqueConnection);
}

References connect(), loadACSConfig(), m_d, KisSignalCompressor::POSTPONE, setSelectorModel(), slotReloadConfiguration(), and validatedConfiguration().

~KisVisualColorSelector()

KisVisualColorSelector::~KisVisualColorSelector ( )

override

Definition at line 69 of file KisVisualColorSelector.cpp.

{
    delete m_d->updateTimer;
}

References m_d.

Member Function Documentation

activeGamutMask()

KoGamutMask * KisVisualColorSelector::activeGamutMask

(

)

const

Definition at line 221 of file KisVisualColorSelector.cpp.

{
    return m_d->gamutMask.data();
}

References m_d.

autoAdjustExposure()

bool KisVisualColorSelector::autoAdjustExposure

(

)

const

Get the state of automatic exposure adjustment. If enabled, the selector will set new maximum channel values on the selectorModel whenever the set display renderer signals a configuration change. The default value is true.

Returns

the current state

Definition at line 183 of file KisVisualColorSelector.cpp.

{
    return m_d->autoAdjustExposure;
}

References m_d.

calculateMaxChannelValues()

QVector4D KisVisualColorSelector::calculateMaxChannelValues ( )

private

Definition at line 623 of file KisVisualColorSelector.cpp.

{
    // Note: This calculation only makes sense for HDR color spaces
    QVector4D maxChannelValues = QVector4D(1, 1, 1, 1);
    const QList<KoChannelInfo *> channels = m_d->selectorModel->colorSpace()->channels();
 
    for (int i = 0; i < channels.size(); i++) {
        const KoChannelInfo *channel = channels.at(i);
        if (channel->channelType() != KoChannelInfo::ALPHA) {
            quint32 logical = channel->displayPosition();
            if (logical > m_d->selectorModel->colorSpace()->alphaPos()) {
                --logical;
            }
            maxChannelValues[logical] = displayRenderer()->maxVisibleFloatValue(channel);
        }
    }
 
    return maxChannelValues;
}

References KoChannelInfo::ALPHA, KoChannelInfo::channelType(), KoChannelInfo::displayPosition(), displayRenderer(), m_d, and KoColorDisplayRendererInterface::maxVisibleFloatValue().

configuration()

const KisColorSelectorConfiguration & KisVisualColorSelector::configuration

(

)

const

Definition at line 113 of file KisVisualColorSelector.cpp.

{
    return m_d->acs_config;
}

References m_d.

displayRenderer()

const KoColorDisplayRendererInterface * KisVisualColorSelector::displayRenderer

(

)

const

Definition at line 162 of file KisVisualColorSelector.cpp.

{
    return m_d->displayRenderer ? m_d->displayRenderer : KoDumbColorDisplayRenderer::instance();
}

References KoDumbColorDisplayRenderer::instance(), and m_d.

getCurrentColor()

KoColor KisVisualColorSelector::getCurrentColor ( ) const

overridevirtual

Implements KisColorSelectorInterface.

Definition at line 145 of file KisVisualColorSelector.cpp.

{
    if (m_d->selectorModel) {
        return m_d->selectorModel->currentColor();
    }
    return KoColor();
}

References m_d.

loadACSConfig()

void KisVisualColorSelector::loadACSConfig ( )

private

Definition at line 643 of file KisVisualColorSelector.cpp.

{
    KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
    KisColorSelectorConfiguration raw_config = KisColorSelectorConfiguration::fromString(
                cfg.readEntry("colorSelectorConfiguration", KisColorSelectorConfiguration().toString()));
    m_d->acs_config = validatedConfiguration(raw_config);
}

References KisColorSelectorConfiguration::fromString(), m_d, and validatedConfiguration().

minimumSizeHint()

QSize KisVisualColorSelector::minimumSizeHint ( ) const

override

Definition at line 74 of file KisVisualColorSelector.cpp.

{
    return QSize(75, 75);
}

proofColors()

bool KisVisualColorSelector::proofColors

(

)

const

Definition at line 193 of file KisVisualColorSelector.cpp.

{
    return m_d->proofColors;
}

References m_d.

rebuildSelector()

void KisVisualColorSelector::rebuildSelector ( )

private

Definition at line 360 of file KisVisualColorSelector.cpp.

{
    qDeleteAll(m_d->widgetlist);
    m_d->widgetlist.clear();
 
    if (!m_d->selectorModel || m_d->selectorModel->colorModel() == KisVisualColorModel::None) {
        return;
    }
 
    m_d->colorChannelCount = m_d->selectorModel->colorChannelCount();
 
    bool supportsGamutMask = false;
 
    //recreate all the widgets.
 
    if (m_d->colorChannelCount == 1) {
 
        KisVisualColorSelectorShape *bar;
 
        if (m_d->circular) {
            bar = new KisVisualEllipticalSelectorShape(this, KisVisualColorSelectorShape::onedimensional,
                                                       0, 0, 20, KisVisualEllipticalSelectorShape::borderMirrored);
        }
        else {
            bar = new KisVisualRectangleSelectorShape(this, KisVisualColorSelectorShape::onedimensional,
                                                      0, 0, 20);
        }
 
        connect(bar, SIGNAL(sigCursorMoved(QPointF)), SLOT(slotCursorMoved(QPointF)));
        m_d->widgetlist.append(bar);
    }
    else if (m_d->colorChannelCount == 3) {
        int channel1 = 0;
        int channel2 = 1;
        int channel3 = 2;
 
        switch(m_d->acs_config.subTypeParameter)
        {
        case KisColorSelectorConfiguration::H:
        case KisColorSelectorConfiguration::Hluma:
            channel1 = 0;
            break;
        case KisColorSelectorConfiguration::hsvS:
            channel1 = 1;
            break;
        case KisColorSelectorConfiguration::V:
            channel1 = 2;
            break;
        default:
            Q_ASSERT_X(false, "", "Invalid acs_config.subTypeParameter");
        }
 
        switch(m_d->acs_config.mainTypeParameter)
        {
        case KisColorSelectorConfiguration::hsvSH:
            channel2 = 0;
            channel3 = 1;
            break;
        case KisColorSelectorConfiguration::VH:
            channel2 = 0;
            channel3 = 2;
            break;
        case KisColorSelectorConfiguration::SV:
            channel2 = 1;
            channel3 = 2;
            break;
        default:
            Q_ASSERT_X(false, "", "Invalid acs_config.mainTypeParameter");
        }
 
        KisVisualColorSelectorShape *bar;
        if (m_d->acs_config.subType == KisColorSelectorConfiguration::Ring) {
            bar = new KisVisualEllipticalSelectorShape(this,
                                                       KisVisualColorSelectorShape::onedimensional,
                                                       channel1, channel1, 20,
                                                       KisVisualEllipticalSelectorShape::border);
        }
        else if (m_d->acs_config.subType == KisColorSelectorConfiguration::Slider && m_d->circular == false) {
            KisVisualRectangleSelectorShape::singelDTypes orientation = useHorizontalSlider() ?
                        KisVisualRectangleSelectorShape::horizontal : KisVisualRectangleSelectorShape::vertical;
 
            bar = new KisVisualRectangleSelectorShape(this,
                                                      KisVisualColorSelectorShape::onedimensional,
                                                      channel1, channel1, 20, orientation);
        }
        else if (m_d->acs_config.subType == KisColorSelectorConfiguration::Slider && m_d->circular == true) {
            bar = new KisVisualEllipticalSelectorShape(this,
                                                       KisVisualColorSelectorShape::onedimensional,
                                                       channel1, channel1,
                                                       20, KisVisualEllipticalSelectorShape::borderMirrored);
        } else {
            // Accessing bar below would crash since it's not initialized.
            // Hopefully this can never happen.
            warnUI << "Invalid subType, cannot initialize KisVisualColorSelectorShape";
            Q_ASSERT_X(false, "", "Invalid subType, cannot initialize KisVisualColorSelectorShape");
            return;
        }
 
        m_d->widgetlist.append(bar);
 
        KisVisualColorSelectorShape *block;
        if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Triangle) {
            if (m_d->selectorModel->colorModel() == KisVisualColorModel::HSV) {
                block = new KisVisualTriangleSelectorShape(this, KisVisualColorSelectorShape::twodimensional,
                                                           channel2, channel3);
            } else {
                block = new KisVisualDiamondSelectorShape(this, KisVisualColorSelectorShape::twodimensional,
                                                           channel2, channel3);
            }
        }
        else if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Square) {
            block = new KisVisualRectangleSelectorShape(this, KisVisualColorSelectorShape::twodimensional,
                                                        channel2, channel3);
        }
        else {
            block = new KisVisualEllipticalSelectorShape(this, KisVisualColorSelectorShape::twodimensional,
                                                         channel2, channel3);
        }
 
        supportsGamutMask = block->supportsGamutMask();
 
        connect(bar, SIGNAL(sigCursorMoved(QPointF)), SLOT(slotCursorMoved(QPointF)));
        connect(block, SIGNAL(sigCursorMoved(QPointF)), SLOT(slotCursorMoved(QPointF)));
        m_d->widgetlist.append(block);
    }
    else if (m_d->colorChannelCount == 4) {
        KisVisualRectangleSelectorShape *block =  new KisVisualRectangleSelectorShape(this, KisVisualRectangleSelectorShape::twodimensional, 0, 1);
        KisVisualRectangleSelectorShape *block2 =  new KisVisualRectangleSelectorShape(this, KisVisualRectangleSelectorShape::twodimensional, 2, 3);
        connect(block, SIGNAL(sigCursorMoved(QPointF)), SLOT(slotCursorMoved(QPointF)));
        connect(block2, SIGNAL(sigCursorMoved(QPointF)), SLOT(slotCursorMoved(QPointF)));
        m_d->widgetlist.append(block);
        m_d->widgetlist.append(block2);
    }
 
    m_d->initialized = true;
    // make sure we call "our" resize function
    KisVisualColorSelector::resizeEvent(0);
 
    for (KisVisualColorSelectorShape *shape : std::as_const(m_d->widgetlist)) {
        shape->setAcceptTabletEvents(m_d->acceptTabletEvents);
        // if this widget is currently visible, new children are hidden by default
        shape->show();
    }
 
    // finally update widgets with new channel values
    slotChannelValuesChanged(m_d->selectorModel->channelValues(), (1u << m_d->colorChannelCount) - 1);
    emit sigGamutMaskSupportChanged(supportsGamutMask);
}

References KisVisualEllipticalSelectorShape::border, KisVisualEllipticalSelectorShape::borderMirrored, connect(), KisColorSelectorConfiguration::H, KisColorSelectorConfiguration::Hluma, KisVisualRectangleSelectorShape::horizontal, KisVisualColorModel::HSV, KisColorSelectorConfiguration::hsvS, KisColorSelectorConfiguration::hsvSH, m_d, KisVisualColorModel::None, KisVisualColorSelectorShape::onedimensional, resizeEvent(), KisColorSelectorConfiguration::Ring, sigGamutMaskSupportChanged(), KisColorSelectorConfiguration::Slider, slotChannelValuesChanged(), slotCursorMoved(), KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::SV, KisColorSelectorConfiguration::Triangle, KisVisualColorSelectorShape::twodimensional, useHorizontalSlider(), KisColorSelectorConfiguration::V, KisVisualRectangleSelectorShape::vertical, KisColorSelectorConfiguration::VH, and warnUI.

renderMode()

KisVisualColorSelector::RenderMode KisVisualColorSelector::renderMode

(

)

const

Definition at line 167 of file KisVisualColorSelector.cpp.

{
    return m_d->renderMode;
}

References m_d.

resizeEvent()

void KisVisualColorSelector::resizeEvent ( QResizeEvent * )

overrideprotected

Definition at line 509 of file KisVisualColorSelector.cpp.

{
    if (!m_d->selectorModel || !m_d->initialized) {
        KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->widgetlist.isEmpty() || !m_d->initialized);
        return;
    }
    int sizeValue = qMin(width(), height());
    // due to masking/antialiasing, the visible width is ~4 pixels less, so add them here
    const int margin = 4;
    const qreal sliderRatio = 0.09;
    int borderWidth = qMax(int(sizeValue * sliderRatio), m_d->minimumSliderWidth) + margin;
    QRect newrect(0,0, this->geometry().width(), this->geometry().height());
 
    if (m_d->colorChannelCount == 1) {
        if (m_d->circular) {
            m_d->widgetlist.at(0)->resize(sizeValue, sizeValue);
        }
        else {
            KisVisualRectangleSelectorShape *slider = qobject_cast<KisVisualRectangleSelectorShape *>(m_d->widgetlist.at(0));
            KIS_SAFE_ASSERT_RECOVER_RETURN(slider);
            if (useHorizontalSlider()) {
                int sliderWidth = qMax(width()/10, m_d->minimumSliderWidth);
                sliderWidth = qMin(sliderWidth, height());
                int y = (height() - sliderWidth)/2;
                slider->setOneDimensionalType(KisVisualRectangleSelectorShape::horizontal);
                slider->setGeometry(0, y, width(), sliderWidth);
            }
            else {
                // vertical slider
                int sliderWidth = qMax(height()/10, m_d->minimumSliderWidth);
                sliderWidth = qMin(sliderWidth, width());
                int x = (width() - sliderWidth)/2;
                slider->setOneDimensionalType(KisVisualRectangleSelectorShape::vertical);
                slider->setGeometry(x, 0, sliderWidth, height());
            }
        }
    }
    else if (m_d->colorChannelCount == 3) {
        m_d->widgetlist.at(0)->setBorderWidth(borderWidth);
        // Ring
        if (m_d->acs_config.subType == KisColorSelectorConfiguration::Ring ||
            (m_d->acs_config.subType == KisColorSelectorConfiguration::Slider && m_d->circular)) {
 
            m_d->widgetlist.at(0)->setGeometry((width() - sizeValue)/2, (height() - sizeValue)/2,
                                               sizeValue, sizeValue);
        }
        // Slider Bar
        else if (m_d->acs_config.subType == KisColorSelectorConfiguration::Slider) {
            // limit stretch; only vertical slider currently
            if (useHorizontalSlider()) {
                newrect.setWidth(qMin(newrect.width(), qRound((newrect.height() - borderWidth) * m_d->stretchLimit)));
                newrect.setHeight(qMin(newrect.height(), qRound(sizeValue * m_d->stretchLimit + borderWidth)));
 
                m_d->widgetlist.at(0)->setGeometry(0, 0, newrect.width(), borderWidth);
            }
            else {
                newrect.setWidth(qMin(newrect.width(), qRound(sizeValue * m_d->stretchLimit + borderWidth)));
                newrect.setHeight(qMin(newrect.height(), qRound((newrect.width() - borderWidth) * m_d->stretchLimit)));
 
                m_d->widgetlist.at(0)->setGeometry(0, 0, borderWidth, newrect.height());
            }
 
        }
 
        if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Triangle) {
            if (m_d->selectorModel->colorModel() == KisVisualColorModel::HSV) {
                m_d->widgetlist.at(1)->setGeometry(m_d->widgetlist.at(0)->getSpaceForTriangle(newrect));
            } else {
                m_d->widgetlist.at(1)->setGeometry(m_d->widgetlist.at(0)->getSpaceForCircle(newrect));
            }
        }
        else if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Square) {
            m_d->widgetlist.at(1)->setGeometry(m_d->widgetlist.at(0)->getSpaceForSquare(newrect));
        }
        else if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Wheel) {
            m_d->widgetlist.at(1)->setGeometry(m_d->widgetlist.at(0)->getSpaceForCircle(newrect));
        }
        // center horizontally
        QRect boundRect(m_d->widgetlist.at(0)->geometry() | m_d->widgetlist.at(1)->geometry());
        int offset = (width() - boundRect.width()) / 2 - boundRect.left();
        m_d->widgetlist.at(0)->move(m_d->widgetlist.at(0)->pos() + QPoint(offset, 0));
        m_d->widgetlist.at(1)->move(m_d->widgetlist.at(1)->pos() + QPoint(offset, 0));
    }
    else if (m_d->colorChannelCount == 4) {
        int sizeBlock = qMin(width()/2 - 8, height());
        m_d->widgetlist.at(0)->setGeometry(0, 0, sizeBlock, sizeBlock);
        m_d->widgetlist.at(1)->setGeometry(sizeBlock + 8, 0, sizeBlock, sizeBlock);
    }
}

References KisVisualRectangleSelectorShape::horizontal, KisVisualColorModel::HSV, KIS_SAFE_ASSERT_RECOVER_NOOP, KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, KisColorSelectorConfiguration::Ring, KisVisualRectangleSelectorShape::setBorderWidth(), KisVisualRectangleSelectorShape::setOneDimensionalType(), KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Triangle, useHorizontalSlider(), KisVisualRectangleSelectorShape::vertical, and KisColorSelectorConfiguration::Wheel.

selectorModel()

KisVisualColorModelSP KisVisualColorSelector::selectorModel

(

)

const

Definition at line 98 of file KisVisualColorSelector.cpp.

{
    return m_d->selectorModel;
}

References m_d.

setAcceptTabletEvents()

void KisVisualColorSelector::setAcceptTabletEvents

(

bool

on

)

Definition at line 137 of file KisVisualColorSelector.cpp.

{
    m_d->acceptTabletEvents = on;
    for (KisVisualColorSelectorShape *shape : std::as_const(m_d->widgetlist)) {
        shape->setAcceptTabletEvents(on);
    }
}

References m_d.

setAutoAdjustExposure()

void KisVisualColorSelector::setAutoAdjustExposure

(

bool

enabled

)

Definition at line 188 of file KisVisualColorSelector.cpp.

{
    m_d->autoAdjustExposure = enabled;
}

References m_d.

setConfig()

void KisVisualColorSelector::setConfig ( bool forceCircular, bool forceSelfUpdate )

overridevirtual

setConfig

Parameters

forceCircular	Force circular is for space where you only have room for a circular selector.
forceSelfUpdate	ignored, can possibly be removed from parent class now

Reimplemented from KisColorSelectorInterface.

Definition at line 103 of file KisVisualColorSelector.cpp.

{
    Q_UNUSED(forceSelfUpdate);
    if (forceCircular != m_d->circular) {
        m_d->circular = forceCircular;
        m_d->initialized = false;
        rebuildSelector();
    }
}

References m_d, and rebuildSelector().

setConfiguration()

void KisVisualColorSelector::setConfiguration

(

const KisColorSelectorConfiguration *

config

)

Explicitly set the shape configuration. Accepts all valid combinations of Advanced Color Selector, however parameters will be converted to HSV equivalent since color model is independent.

Parameters

config

Passing null will load the Advanced Color Selector configuration Note: Null will also set the HSX color model for compatibility reasons, while otherwise shape layout and color model are independent.

Definition at line 118 of file KisVisualColorSelector.cpp.

{
    m_d->useACSConfig = !config;
    if (config) {
        // applies immediately, while signalled rebuilds from krita configuration changes
        // are queued, so make sure we cancel queued updates
        m_d->updateTimer->stop();
        KisColorSelectorConfiguration configNew = validatedConfiguration(*config);
        if (configNew != m_d->acs_config) {
            m_d->acs_config = configNew;
            m_d->initialized = false;
            rebuildSelector();
        }
    } else {
        m_d->initialized = false;
        m_d->updateTimer->start();
    }
}

References m_d, rebuildSelector(), and validatedConfiguration().

setDisplayRenderer

void KisVisualColorSelector::setDisplayRenderer ( const KoColorDisplayRendererInterface * displayRenderer )

overrideslot

Definition at line 251 of file KisVisualColorSelector.cpp.

{
    switchDisplayRenderer(displayRenderer);
 
    if (m_d->selectorModel) {
        slotDisplayConfigurationChanged();
    }
}

References displayRenderer(), m_d, slotDisplayConfigurationChanged(), and switchDisplayRenderer().

setMinimumSliderWidth()

void KisVisualColorSelector::setMinimumSliderWidth

(

int

width

)

Definition at line 153 of file KisVisualColorSelector.cpp.

{
    int newWidth = qMax(5, width);
    if (newWidth != m_d->minimumSliderWidth) {
        m_d->minimumSliderWidth = width;
        KisVisualColorSelector::resizeEvent(0);
    }
}

References m_d, and resizeEvent().

setProofColors()

void KisVisualColorSelector::setProofColors

(

bool

enabled

)

Definition at line 198 of file KisVisualColorSelector.cpp.

{
    if (enabled != m_d->proofColors) {
        m_d->proofColors = enabled;
        for (KisVisualColorSelectorShape *shape : std::as_const(m_d->widgetlist)) {
            shape->forceImageUpdate();
            shape->update();
        }
    }
}

References m_d.

setRenderMode()

void KisVisualColorSelector::setRenderMode

(

KisVisualColorSelector::RenderMode

mode

)

Definition at line 172 of file KisVisualColorSelector.cpp.

{
    if (mode != m_d->renderMode) {
        m_d->renderMode = mode;
        for (KisVisualColorSelectorShape *shape : std::as_const(m_d->widgetlist)) {
            shape->forceImageUpdate();
            shape->update();
        }
    }
}

References m_d.

setSelectorModel()

void KisVisualColorSelector::setSelectorModel

(

KisVisualColorModelSP

model

)

Definition at line 79 of file KisVisualColorSelector.cpp.

{
    if (model == m_d->selectorModel) {
        return;
    }
    if (m_d->selectorModel) {
        m_d->selectorModel->disconnect(this);
    }
    connect(model.data(), SIGNAL(sigChannelValuesChanged(QVector4D,quint32)),
                          SLOT(slotChannelValuesChanged(QVector4D,quint32)));
    connect(model.data(), SIGNAL(sigColorModelChanged()), SLOT(slotColorModelChanged()));
    connect(model.data(), SIGNAL(sigColorSpaceChanged()), SLOT(slotColorSpaceChanged()));
    // to keep the KisColorSelectorInterface API functional:
    connect(model.data(), SIGNAL(sigNewColor(KoColor)), this, SIGNAL(sigNewColor(KoColor)));
    m_d->selectorModel = model;
    m_d->initialized = false;
    rebuildSelector();
}

References connect(), m_d, rebuildSelector(), KisColorSelectorInterface::sigNewColor(), slotChannelValuesChanged(), slotColorModelChanged(), and slotColorSpaceChanged().

setSliderPosition()

void KisVisualColorSelector::setSliderPosition

(

Qt::Edge

edge

)

Set the slider position for slider + square and slider + wheel configurations.

Parameters

edge	Edge to position the slider; currently only supports LeftEdge and TopEdge

Definition at line 209 of file KisVisualColorSelector.cpp.

{
    if (edge != Qt::TopEdge && edge != Qt::LeftEdge) {
        return;
    }
 
    if (edge != m_d->sliderPosition) {
        m_d->sliderPosition = edge;
        rebuildSelector();
    }
}

References m_d, and rebuildSelector().

sigGamutMaskSupportChanged

void KisVisualColorSelector::sigGamutMaskSupportChanged ( bool supported )

signal

sigGamutMaskSupportChanged Signals whether gamut masks are supported by the current selector shape.

Parameters

supported

– whether the gamut mask is currently supported.

sigInteraction

void KisVisualColorSelector::sigInteraction ( bool active )

signal

sigInteraction is emitted whenever mouse interaction status changes

Parameters

active

when true, the user started dragging a handle, when false the interaction has just finished

slotChannelValuesChanged

void KisVisualColorSelector::slotChannelValuesChanged ( const QVector4D & values, quint32 channelFlags )

privateslot

Definition at line 286 of file KisVisualColorSelector.cpp.

{
    // about to (re-)build selector, values will be fetched when done
    if (!m_d->initialized) {
        return;
    }
    m_d->channelValues = values;
    for (KisVisualColorSelectorShape *shape : std::as_const(m_d->widgetlist)) {
        shape->setChannelValues(m_d->channelValues, channelFlags);
    }
}

References m_d.

slotColorModelChanged

void KisVisualColorSelector::slotColorModelChanged ( )

privateslot

Definition at line 298 of file KisVisualColorSelector.cpp.

{
    // TODO: triangle <=> diamond switch only happens on HSV <=> non-HSV, but
    // the previous color model is not accessible right now
    if (!m_d->initialized || m_d->selectorModel->colorChannelCount() != m_d->colorChannelCount
            || m_d->acs_config.mainType == KisColorSelectorConfiguration::Triangle) {
        m_d->initialized = false;
        rebuildSelector();
    } else {
        slotDisplayConfigurationChanged();
    }
}

References m_d, rebuildSelector(), slotDisplayConfigurationChanged(), and KisColorSelectorConfiguration::Triangle.

slotColorSpaceChanged

void KisVisualColorSelector::slotColorSpaceChanged ( )

privateslot

Definition at line 311 of file KisVisualColorSelector.cpp.

{
    if (m_d->autoAdjustExposure && m_d->selectorModel && m_d->selectorModel->supportsExposure()) {
        m_d->selectorModel->setMaxChannelValues(calculateMaxChannelValues());
    }
}

References calculateMaxChannelValues(), and m_d.

slotConfigurationChanged

void KisVisualColorSelector::slotConfigurationChanged ( )

slot

Definition at line 240 of file KisVisualColorSelector.cpp.

{
    if (m_d->updateTimer && m_d->useACSConfig) {
        // NOTE: this timer is because notifyConfigChanged() is only called
        // via KisConfig::setCustomColorSelectorColorSpace(), but at this point
        // Advanced Color Selector has not written the relevant config values yet.
        m_d->initialized = false;
        m_d->updateTimer->start();
    }
}

References m_d.

slotCursorMoved

void KisVisualColorSelector::slotCursorMoved ( QPointF pos )

privateslot

Definition at line 318 of file KisVisualColorSelector.cpp.

{
    const KisVisualColorSelectorShape *shape = qobject_cast<KisVisualColorSelectorShape *>(sender());
    KIS_SAFE_ASSERT_RECOVER_RETURN(shape);
 
    m_d->channelValues[shape->channel(0)] = pos.x();
    if (shape->getDimensions() == KisVisualColorSelectorShape::twodimensional) {
        m_d->channelValues[shape->channel(1)] = pos.y();
    }
 
    for (KisVisualColorSelectorShape *widget : std::as_const(m_d->widgetlist)) {
        if (widget != shape){
            widget->setChannelValues(m_d->channelValues, shape->channelMask());
        }
    }
    m_d->selectorModel->slotSetChannelValues(m_d->channelValues);
}

References KisVisualColorSelectorShape::channel(), KisVisualColorSelectorShape::channelMask(), KisVisualColorSelectorShape::getDimensions(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, and KisVisualColorSelectorShape::twodimensional.

slotDisplayConfigurationChanged

void KisVisualColorSelector::slotDisplayConfigurationChanged ( )

privateslot

Definition at line 336 of file KisVisualColorSelector.cpp.

{
    if (m_d->autoAdjustExposure && m_d->selectorModel && m_d->selectorModel->supportsExposure()) {
        m_d->selectorModel->setMaxChannelValues(calculateMaxChannelValues());
    }
    // TODO: can we be smarter about forced updates?
    for (KisVisualColorSelectorShape *shape : std::as_const(m_d->widgetlist)) {
        shape->forceImageUpdate();
        shape->update();
    }
}

References calculateMaxChannelValues(), and m_d.

slotGamutMaskChanged

void KisVisualColorSelector::slotGamutMaskChanged ( KoGamutMaskSP mask )

slot

Definition at line 260 of file KisVisualColorSelector.cpp.

{
    // Note: KisCanvasResourceProvider currently does not distinguish
    // between activating, switching and property changes of a gamut mask
    m_d->gamutMask = mask;
    for (KisVisualColorSelectorShape *shape : std::as_const(m_d->widgetlist)) {
        shape->updateGamutMask();
    }
}

References m_d.

slotGamutMaskPreviewUpdate

void KisVisualColorSelector::slotGamutMaskPreviewUpdate ( )

slot

Definition at line 278 of file KisVisualColorSelector.cpp.

{
    // Shapes currently always requests preview shapes if available, so more of the same...
    for (KisVisualColorSelectorShape *shape : std::as_const(m_d->widgetlist)) {
        shape->updateGamutMask();
    }
}

References m_d.

slotGamutMaskUnset

void KisVisualColorSelector::slotGamutMaskUnset ( )

slot

Definition at line 270 of file KisVisualColorSelector.cpp.

{
    m_d->gamutMask.clear();
    for (KisVisualColorSelectorShape *shape : std::as_const(m_d->widgetlist)) {
        shape->updateGamutMask();
    }
}

References m_d.

slotReloadConfiguration

void KisVisualColorSelector::slotReloadConfiguration ( )

privateslot

Definition at line 348 of file KisVisualColorSelector.cpp.

{
    if (m_d->useACSConfig) {
        loadACSConfig();
        // this may trigger slotColorModelChanged() so check afterwards if we already rebuild
        m_d->selectorModel->slotLoadACSConfig();
        if (!m_d->initialized) {
            rebuildSelector();
        }
    }
}

References loadACSConfig(), m_d, and rebuildSelector().

slotSetColor

void KisVisualColorSelector::slotSetColor ( const KoColor & c )

overrideslot

Definition at line 226 of file KisVisualColorSelector.cpp.

{
    if (m_d->selectorModel) {
        m_d->selectorModel->slotSetColor(c);
    }
}

References m_d.

slotSetColorSpace

void KisVisualColorSelector::slotSetColorSpace ( const KoColorSpace * cs )

overrideslot

Definition at line 233 of file KisVisualColorSelector.cpp.

{
    if (m_d->selectorModel) {
        m_d->selectorModel->slotSetColorSpace(cs);
    }
}

References m_d.

switchDisplayRenderer()

void KisVisualColorSelector::switchDisplayRenderer ( const KoColorDisplayRendererInterface * displayRenderer )

private

Definition at line 609 of file KisVisualColorSelector.cpp.

{
    if (displayRenderer != m_d->displayRenderer) {
        if (m_d->displayRenderer) {
            m_d->displayRenderer->disconnect(this);
        }
        if (displayRenderer) {
            connect(displayRenderer, SIGNAL(displayConfigurationChanged()),
                    SLOT(slotDisplayConfigurationChanged()), Qt::UniqueConnection);
        }
        m_d->displayRenderer = displayRenderer;
    }
}

References connect(), displayRenderer(), m_d, and slotDisplayConfigurationChanged().

useHorizontalSlider()

bool KisVisualColorSelector::useHorizontalSlider ( )

private

Definition at line 599 of file KisVisualColorSelector.cpp.

{
    if (m_d->colorChannelCount == 1) {
        return width() > height();
    }
    else {
        return m_d->sliderPosition == Qt::TopEdge;
    }
}

References m_d.

validatedConfiguration()

KisColorSelectorConfiguration KisVisualColorSelector::validatedConfiguration ( const KisColorSelectorConfiguration & cfg )

staticprivate

Definition at line 651 of file KisVisualColorSelector.cpp.

{
    KisColorSelectorConfiguration validated(cfg);
    bool ok = true;
 
    switch (validated.mainType) {
    case KisColorSelectorConfiguration::Triangle:
    case KisColorSelectorConfiguration::Square:
    case KisColorSelectorConfiguration::Wheel:
        break;
    default:
        ok = false;
    }
 
    switch (validated.subType) {
    case KisColorSelectorConfiguration::Ring:
    case KisColorSelectorConfiguration::Slider:
        break;
    default:
        ok = false;
    }
 
    switch(validated.subTypeParameter)
    {
    case KisColorSelectorConfiguration::H:
    case KisColorSelectorConfiguration::hsvS:
    case KisColorSelectorConfiguration::V:
        break;
    // translate to HSV
    case KisColorSelectorConfiguration::hsyS:
    case KisColorSelectorConfiguration::hsiS:
    case KisColorSelectorConfiguration::hslS:
        validated.subTypeParameter = KisColorSelectorConfiguration::hsvS;
        break;
    case KisColorSelectorConfiguration::L:
    case KisColorSelectorConfiguration::I:
    case KisColorSelectorConfiguration::Y:
        validated.subTypeParameter = KisColorSelectorConfiguration::V;
        break;
    default:
        ok = false;
    }
 
    switch(validated.mainTypeParameter)
    {
    case KisColorSelectorConfiguration::SV:
    case KisColorSelectorConfiguration::hsvSH:
    case KisColorSelectorConfiguration::VH:
        break;
    // translate to HSV
    case KisColorSelectorConfiguration::SL:
    case KisColorSelectorConfiguration::SV2:
    case KisColorSelectorConfiguration::SI:
    case KisColorSelectorConfiguration::SY:
        validated.mainTypeParameter = KisColorSelectorConfiguration::SV;
        break;
    case KisColorSelectorConfiguration::hslSH:
    case KisColorSelectorConfiguration::hsiSH:
    case KisColorSelectorConfiguration::hsySH:
        validated.mainTypeParameter = KisColorSelectorConfiguration::hsvSH;
        break;
    case KisColorSelectorConfiguration::LH:
    case KisColorSelectorConfiguration::IH:
    case KisColorSelectorConfiguration::YH:
        validated.mainTypeParameter = KisColorSelectorConfiguration::VH;
        break;
    default:
        ok = false;
    }
 
    if (ok) {
        return validated;
    }
    return KisColorSelectorConfiguration(KisColorSelectorConfiguration::Triangle,
                                         KisColorSelectorConfiguration::Ring,
                                         KisColorSelectorConfiguration::SV,
                                         KisColorSelectorConfiguration::H);
}

References KisColorSelectorConfiguration::H, KisColorSelectorConfiguration::hsiS, KisColorSelectorConfiguration::hsiSH, KisColorSelectorConfiguration::hslS, KisColorSelectorConfiguration::hslSH, KisColorSelectorConfiguration::hsvS, KisColorSelectorConfiguration::hsvSH, KisColorSelectorConfiguration::hsyS, KisColorSelectorConfiguration::hsySH, KisColorSelectorConfiguration::I, KisColorSelectorConfiguration::IH, KisColorSelectorConfiguration::L, KisColorSelectorConfiguration::LH, KisColorSelectorConfiguration::mainType, KisColorSelectorConfiguration::mainTypeParameter, KisColorSelectorConfiguration::Ring, KisColorSelectorConfiguration::SI, KisColorSelectorConfiguration::SL, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::subType, KisColorSelectorConfiguration::subTypeParameter, KisColorSelectorConfiguration::SV, KisColorSelectorConfiguration::SV2, KisColorSelectorConfiguration::SY, KisColorSelectorConfiguration::Triangle, KisColorSelectorConfiguration::V, KisColorSelectorConfiguration::VH, KisColorSelectorConfiguration::Wheel, KisColorSelectorConfiguration::Y, and KisColorSelectorConfiguration::YH.

Member Data Documentation

m_d

const QScopedPointer<Private> KisVisualColorSelector::m_d

private

Definition at line 138 of file KisVisualColorSelector.h.

---

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

• libs/widgets/KisVisualColorSelector.h
• libs/widgets/KisVisualColorSelector.cpp