#include <kis_color_selector_ring.h>

Inheritance diagram for KisColorSelectorRing:

Public Member Functions
int	innerRadius () const

	KisColorSelectorRing (KisColorSelector *parent)

void	setColor (const KoColor &color) override
	set the color, blibs etc

void	setInnerRingRadiusFraction (qreal newFraction)

Public Member Functions inherited from KisColorSelectorComponent
KoColor	currentColor ()
	return the color, that was selected by calling mouseEvent

int	height () const

	KisColorSelectorComponent (KisColorSelector *parent)

virtual void	mouseEvent (int x, int y)
	saves the mouse position, so that a blip can be created.

void	paintEvent (QPainter *)

void	setConfiguration (Parameter param, Type type)
	setConfiguration can be ignored (for instance ring and triangle, as they can have only one config)

void	setDirty ()
	force subsequent redraw of the component

void	setGamutMask (KoGamutMaskSP gamutMask)

void	setGeometry (int x, int y, int width, int height)

void	toggleGamutMask (bool state)

void	unsetGamutMask ()

void	updateGamutMaskPreview ()

bool	wantsGrab (int x, int y)
	returns true, if this component wants to grab the mouse (normally true, if containsPoint returns true)

int	width () const

Protected Member Functions
bool	containsPointInComponentCoords (int x, int y) const override

void	paint (QPainter *) override

KoColor	selectColor (int x, int y) override
	this method must be overloaded to return the color at position x/y and draw a marker on that position

Protected Member Functions inherited from KisColorSelectorComponent
virtual bool	allowsColorSelectionAtPoint (const QPoint &) const

const KoColorSpace *	colorSpace () const

bool	isDirty () const
	returns true, if ether the color space, the size or the parameters have changed since the last paint event

void	setLastMousePosition (int x, int y)

Private Member Functions
void	colorCache ()

int	outerRadius () const

void	paintCache (qreal devicePixelRatioF)

Private Attributes
qreal	B {0.0}

qreal	G {0.0}

qreal	Gamma {1.0}

QList< QRgb >	m_cachedColors

const KoColorSpace *	m_cachedColorSpace {0}

int	m_cachedSize {0}

qreal	m_innerRingRadiusFraction {0.85}

qreal	m_lastHue {0.0}

QImage	m_pixelCache

qreal	R {0.0}

Additional Inherited Members
Public Types inherited from KisColorSelectorComponent
typedef KisColorSelectorConfiguration::Parameters	Parameter

typedef KisColorSelectorConfiguration::Type	Type

Public Slots inherited from KisColorSelectorComponent
void	setParam (qreal hue, qreal hsvSaturation, qreal value, qreal hslSaturation, qreal lightness, qreal hsiSaturation, qreal intensity, qreal hsySaturation, qreal luma)

Signals inherited from KisColorSelectorComponent
void	paramChanged (qreal hue, qreal hsvSaturation, qreal value, qreal hslSaturation, qreal lightness, qreal hsiSaturation, qreal intensity, qreal hsySaturation, qreal luma)
	-1, if unaffected

void	update ()
	request for repaint, for instance, if the hue changes.

Protected Attributes inherited from KisColorSelectorComponent
KoGamutMaskSP	m_currentGamutMask

bool	m_gamutMaskOn {false}

qreal	m_hsiSaturation {0.0}

qreal	m_hslSaturation {0.0}

qreal	m_hsvSaturation {0.0}

qreal	m_hsySaturation {0.0}

qreal	m_hue {0.0}

qreal	m_intensity {0.0}

qreal	m_lastX {0.0}

qreal	m_lastY {0.0}

qreal	m_lightness {0.0}

qreal	m_luma {0.0}

bool	m_maskPreviewActive {false}

Parameter	m_parameter

KisColorSelector *	m_parent {0}

Type	m_type

qreal	m_value {0.0}

int	m_x {0}

int	m_y {0}

Detailed Description

Definition at line 14 of file kis_color_selector_ring.h.

Constructor & Destructor Documentation

◆ KisColorSelectorRing()

KisColorSelectorRing::KisColorSelectorRing ( KisColorSelector * parent )

explicit

Definition at line 19 of file kis_color_selector_ring.cpp.

                                                                   :
    KisColorSelectorComponent(parent)
{
}

Member Function Documentation

◆ colorCache()

void KisColorSelectorRing::colorCache ( )

private

Definition at line 201 of file kis_color_selector_ring.cpp.

{
    Q_ASSERT(m_cachedColorSpace);
    m_cachedColors.clear();
    KoColor koColor;
    QColor qColor;
    for(int i=0; i<360; i++) {
        if(m_parameter == KisColorSelectorConfiguration::Hluma) {
            koColor = m_parent->converter()->fromHsyF(1.0 * i / 360.0, 1.0, 0.55, R, G, B, Gamma);
        } else {
            koColor = m_parent->converter()->fromHsvF(1.0 * i / 360.0, 1.0, 1.0);
        }
        qColor = m_parent->converter()->toQColor(koColor);
        m_cachedColors.append(qColor.rgb());
    }
}

References B, KisColorSelectorBase::converter(), KisDisplayColorConverter::fromHsvF(), KisDisplayColorConverter::fromHsyF(), G, KisColorSelectorConfiguration::Hluma, m_cachedColors, m_cachedColorSpace, KisColorSelectorComponent::m_parameter, KisColorSelectorComponent::m_parent, R, and KisDisplayColorConverter::toQColor().

◆ containsPointInComponentCoords()

bool KisColorSelectorRing::containsPointInComponentCoords	(	int	x,
		int	y ) const

overrideprotectedvirtual

a subclass can implement this method, the default returns true if the coordinates are in the component rect values for the subclasses are provided in component coordinates, eg (0,0) is top left of component

Reimplemented from KisColorSelectorComponent.

Definition at line 34 of file kis_color_selector_ring.cpp.

{
    int outerRadiusSquared = qMin(width(), height())/2;
    int innerRadiusSquared = innerRadius();
    outerRadiusSquared*=outerRadiusSquared;
    innerRadiusSquared*=innerRadiusSquared;
 
 
    Eigen::Vector2i relativeVector(x-width()/2, y-height()/2);
 
    if(relativeVector.squaredNorm() < outerRadiusSquared
       && relativeVector.squaredNorm() > innerRadiusSquared) {
        return true;
    }
    return false;
}

References KisColorSelectorComponent::height(), innerRadius(), and KisColorSelectorComponent::width().

◆ innerRadius()

int KisColorSelectorRing::innerRadius ( ) const

Definition at line 24 of file kis_color_selector_ring.cpp.

{
    return (qMin(width(), height())/2)*m_innerRingRadiusFraction;
}

References KisColorSelectorComponent::height(), m_innerRingRadiusFraction, and KisColorSelectorComponent::width().

◆ outerRadius()

int KisColorSelectorRing::outerRadius ( ) const

private

Definition at line 218 of file kis_color_selector_ring.cpp.

{
    return m_cachedSize/2-1;
}

References m_cachedSize.

◆ paint()

void KisColorSelectorRing::paint ( QPainter * )

overrideprotectedvirtual

paint component using given painter the component should respect width() and height() (eg. scale to width and height), but doesn't have to care about x/y coordinates (top left corner)

Implements KisColorSelectorComponent.

Definition at line 51 of file kis_color_selector_ring.cpp.

{
    qreal devicePixelRatioF = painter->device()->devicePixelRatioF();
    if(isDirty()) {
        m_cachedColorSpace = colorSpace();
        m_cachedSize=qMin(width(), height());
        colorCache();
        paintCache(devicePixelRatioF);
    }
 
    int size = qMin(width(), height());
    if(m_cachedSize!=size) {
        m_cachedSize=size;
        paintCache(devicePixelRatioF);
    }
 
    QPoint startPoint = QPoint(width()/2 - (m_pixelCache.width()/(2*devicePixelRatioF)),
                               height()/2 - (m_pixelCache.height()/(2*devicePixelRatioF)));
    painter->drawImage(startPoint, m_pixelCache);
 
 
    // paint blip
    if(m_parent->displayBlip()) {
        qreal angle;
        int y_start, y_end, x_start, x_end;
        angle=m_lastHue*2.*M_PI+(M_PI);
        y_start=innerRadius()*sin(angle)+height()/2;
        y_end=outerRadius()*sin(angle)+height()/2;
        x_start=innerRadius()*cos(angle)+width()/2;
        x_end=outerRadius()*cos(angle)+width()/2;
 
        painter->setPen(QColor(0,0,0));
        painter->drawLine(x_start, y_start, x_end, y_end);
 
        angle+=M_PI/180.;
        y_start=innerRadius()*sin(angle)+height()/2;
        y_end=outerRadius()*sin(angle)+height()/2;
        x_start=innerRadius()*cos(angle)+width()/2;
        x_end=outerRadius()*cos(angle)+width()/2;
 
        painter->setPen(QColor(255,255,255));
        painter->drawLine(x_start, y_start, x_end, y_end);
    }
}

References colorCache(), KisColorSelectorComponent::colorSpace(), KisColorSelector::displayBlip(), KisColorSelectorComponent::height(), innerRadius(), KisColorSelectorComponent::isDirty(), m_cachedColorSpace, m_cachedSize, m_lastHue, KisColorSelectorComponent::m_parent, M_PI, m_pixelCache, outerRadius(), paintCache(), and KisColorSelectorComponent::width().

◆ paintCache()

void KisColorSelectorRing::paintCache ( qreal devicePixelRatioF )

private

Definition at line 140 of file kis_color_selector_ring.cpp.

{
    QImage cache(m_cachedSize*devicePixelRatioF, m_cachedSize*devicePixelRatioF, QImage::Format_ARGB32_Premultiplied);
    cache.setDevicePixelRatio(devicePixelRatioF);
 
    Eigen::Vector2i center(cache.width()/2., cache.height()/2.);
 
    int outerRadiusHighDPI = outerRadius()*devicePixelRatioF;
    int innerRadiusHighDPI = innerRadius()*devicePixelRatioF;
 
 
    for(int x=0; x<cache.width(); x++) {
        for(int y=0; y<cache.height(); y++) {
            Eigen::Vector2i currentPoint((float)x, (float)y);
            Eigen::Vector2i relativeVector = currentPoint-center;
 
            qreal currentRadius = relativeVector.squaredNorm();
            currentRadius=sqrt(currentRadius);
 
            if(currentRadius < outerRadiusHighDPI+1
               && currentRadius > innerRadiusHighDPI-1)
            {
 
                float angle = std::atan2((float)relativeVector.y(), (float)relativeVector.x())+((float)M_PI);
                angle/=2*((float)M_PI);
                angle*=359.f;
                if(currentRadius < outerRadiusHighDPI
                   && currentRadius > innerRadiusHighDPI) {
                    cache.setPixel(x, y, m_cachedColors.at(angle));
                }
                else {
                    // draw antialiased border
                    qreal coef=1.;
                    if(currentRadius > outerRadiusHighDPI) {
                        // outer border
                        coef-=currentRadius;
                        coef+=outerRadiusHighDPI;
                    }
                    else {
                        // inner border
                        coef+=currentRadius;
                        coef-=innerRadiusHighDPI;
                    }
                    coef=qBound(qreal(0.), coef, qreal(1.));
                    int red=qRed(m_cachedColors.at(angle));
                    int green=qGreen(m_cachedColors.at(angle));
                    int blue=qBlue(m_cachedColors.at(angle));
 
                    // the format is premultiplied, so we have to take care of that
                    QRgb color = qRgba(red*coef, green*coef, blue*coef, 255*coef);
                    cache.setPixel(x, y, color);
                }
            }
            else {
                cache.setPixel(x, y, qRgba(0,0,0,0));
            }
        }
    }
    m_pixelCache = cache;
}

References innerRadius(), m_cachedColors, m_cachedSize, M_PI, m_pixelCache, and outerRadius().

◆ selectColor()

KoColor KisColorSelectorRing::selectColor	(	int	x,
		int	y )

overrideprotectedvirtual

this method must be overloaded to return the color at position x/y and draw a marker on that position

Implements KisColorSelectorComponent.

Definition at line 96 of file kis_color_selector_ring.cpp.

{
    QPoint ringMiddle(width()/2, height()/2);
    QPoint ringCoord = QPoint(x, y)-ringMiddle;
    qreal hue = std::atan2(qreal(ringCoord.y()), qreal(ringCoord.x()))+(M_PI);
    hue/=2.*M_PI;
    Q_EMIT paramChanged(hue, -1, -1, -1, -1, -1, -1, -1, -1);
    m_lastHue=hue;
    Q_EMIT update();
 
    if(m_parameter == KisColorSelectorConfiguration::Hluma) {
        return m_parent->converter()->fromHsyF(hue, 1.0, 0.55, R, G, B, Gamma);
    }
    return m_parent->converter()->fromHsvF(hue, 1.0, 1.0);
}

References B, KisColorSelectorBase::converter(), KisDisplayColorConverter::fromHsvF(), KisDisplayColorConverter::fromHsyF(), G, KisColorSelectorComponent::height(), KisColorSelectorConfiguration::Hluma, m_lastHue, KisColorSelectorComponent::m_parameter, KisColorSelectorComponent::m_parent, M_PI, KisColorSelectorComponent::paramChanged(), R, KisColorSelectorComponent::update(), and KisColorSelectorComponent::width().

◆ setColor()

void KisColorSelectorRing::setColor ( const KoColor & color )

overridevirtual

set the color, blibs etc

Reimplemented from KisColorSelectorComponent.

Definition at line 112 of file kis_color_selector_ring.cpp.

{
    qreal h, s, v;
    KConfigGroup cfg = KSharedConfig::openConfig()->group("advancedColorSelector");
    R = cfg.readEntry("lumaR", 0.2126);
    G = cfg.readEntry("lumaG", 0.7152);
    B = cfg.readEntry("lumaB", 0.0722);
    Gamma = cfg.readEntry("gamma", 2.2);
 
    if(m_parameter == KisColorSelectorConfiguration::Hluma) {
        m_parent->converter()->getHsyF(color, &h, &s, &v, R, G, B, Gamma);
    }
    else {
        m_parent->converter()->getHsvF(color, &h, &s, &v);
    }
 
    Q_EMIT paramChanged(h, -1, -1, -1, -1, -1, -1, -1, -1);
 
    // selector keeps the position on the ring if hue is undefined (when saturation is 0)
    if (!qFuzzyCompare(s, 0.0)) {
        m_lastHue=h;
    }
 
    Q_EMIT update();
 
    KisColorSelectorComponent::setColor(color);
}

References B, KisColorSelectorBase::converter(), G, KisDisplayColorConverter::getHsvF(), KisDisplayColorConverter::getHsyF(), KisColorSelectorConfiguration::Hluma, m_lastHue, KisColorSelectorComponent::m_parameter, KisColorSelectorComponent::m_parent, KisColorSelectorComponent::paramChanged(), qFuzzyCompare(), R, KisColorSelectorComponent::setColor(), KisColorSelectorComponent::update(), and v.

◆ setInnerRingRadiusFraction()

void KisColorSelectorRing::setInnerRingRadiusFraction ( qreal newFraction )

Definition at line 29 of file kis_color_selector_ring.cpp.

{
    m_innerRingRadiusFraction = newFraction;
}

References m_innerRingRadiusFraction.

Member Data Documentation

◆ B

qreal KisColorSelectorRing::B {0.0}

private

Definition at line 42 of file kis_color_selector_ring.h.

42{0.0};

◆ G

qreal KisColorSelectorRing::G {0.0}

private

Definition at line 41 of file kis_color_selector_ring.h.

41{0.0};

◆ Gamma

qreal KisColorSelectorRing::Gamma {1.0}

private

Definition at line 43 of file kis_color_selector_ring.h.

43{1.0};

◆ m_cachedColors

QList<QRgb> KisColorSelectorRing::m_cachedColors

private

Definition at line 37 of file kis_color_selector_ring.h.

◆ m_cachedColorSpace

const KoColorSpace* KisColorSelectorRing::m_cachedColorSpace {0}

private

Definition at line 34 of file kis_color_selector_ring.h.

34{0};

◆ m_cachedSize

int KisColorSelectorRing::m_cachedSize {0}

private

Definition at line 35 of file kis_color_selector_ring.h.

35{0};

◆ m_innerRingRadiusFraction

qreal KisColorSelectorRing::m_innerRingRadiusFraction {0.85}

private

Definition at line 38 of file kis_color_selector_ring.h.

38{0.85};

◆ m_lastHue

qreal KisColorSelectorRing::m_lastHue {0.0}

private

Definition at line 36 of file kis_color_selector_ring.h.

36{0.0};

◆ m_pixelCache

QImage KisColorSelectorRing::m_pixelCache

private

Definition at line 33 of file kis_color_selector_ring.h.

◆ R

qreal KisColorSelectorRing::R {0.0}

private

Definition at line 40 of file kis_color_selector_ring.h.

40{0.0};

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

plugins/dockers/advancedcolorselector/kis_color_selector_ring.h
plugins/dockers/advancedcolorselector/kis_color_selector_ring.cpp

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisColorSelectorRing()

Member Function Documentation

◆ colorCache()

◆ containsPointInComponentCoords()

◆ innerRadius()

◆ outerRadius()

◆ paint()

◆ paintCache()

◆ selectColor()

◆ setColor()

◆ setInnerRingRadiusFraction()

Member Data Documentation

◆ B

◆ G

◆ Gamma

◆ m_cachedColors

◆ m_cachedColorSpace

◆ m_cachedSize

◆ m_innerRingRadiusFraction

◆ m_lastHue

◆ m_pixelCache

◆ R