KisColorSelectorWheel Class Reference

#include <kis_color_selector_wheel.h>

Inheritance diagram for KisColorSelectorWheel:

Public Member Functions
	KisColorSelectorWheel (KisColorSelector *parent)
void	setColor (const KoColor &color) override
	set the color, blibs etc
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
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
const KoColorSpace *	colorSpace () const
virtual bool	containsPointInComponentCoords (int x, int y) 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
bool	allowsColorSelectionAtPoint (const QPoint &pt) const override
KoColor	colorAt (float x, float y, bool forceValid=false)

Private Attributes
qreal	B {0.0}
qreal	G {0.0}
qreal	Gamma {0.0}
QPointF	m_lastClickPos
QImage	m_pixelCache
QPoint	m_pixelCacheOffset
qreal	m_renderAreaOffsetX {0.0}
qreal	m_renderAreaOffsetY {0.0}
QSize	m_renderAreaSize
QTransform	m_toRenderArea
qreal	R {0.0}

Friends
class	Acs::PixelCacheRenderer

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 23 of file kis_color_selector_wheel.h.

Constructor & Destructor Documentation

KisColorSelectorWheel()

KisColorSelectorWheel::KisColorSelectorWheel ( KisColorSelector * parent )

explicit

Definition at line 21 of file kis_color_selector_wheel.cpp.

                                                                     :
    KisColorSelectorComponent(parent),
    m_lastClickPos(-1,-1),
    m_renderAreaSize(1,1),
    m_renderAreaOffsetX(0.0),
    m_renderAreaOffsetY(0.0),
    m_toRenderArea(QTransform())
{
}

Member Function Documentation

allowsColorSelectionAtPoint()

bool KisColorSelectorWheel::allowsColorSelectionAtPoint ( const QPoint & ) const

overrideprivatevirtual

a subclass can implement this method to note that the point, although it is in containsPointInComponentCoords area, still cannot be selected as a color (e.g. it is masked out). Default implementation always returns true.

Reimplemented from KisColorSelectorComponent.

Definition at line 307 of file kis_color_selector_wheel.cpp.

{
    if (!m_gamutMaskOn || !m_currentGamutMask) {
        return true;
    }
 
    QPointF colorCoord = m_toRenderArea.map(QPointF(pt));
    QPointF translatedPoint = m_currentGamutMask->viewToMaskTransform(m_renderAreaSize.width()).map(colorCoord);
    bool isClear = m_currentGamutMask->coordIsClear(translatedPoint, m_maskPreviewActive);
 
    return isClear;
}

References KisColorSelectorComponent::m_currentGamutMask, KisColorSelectorComponent::m_gamutMaskOn, KisColorSelectorComponent::m_maskPreviewActive, m_renderAreaSize, and m_toRenderArea.

colorAt()

KoColor KisColorSelectorWheel::colorAt ( float x, float y, bool forceValid = false )

private

Definition at line 249 of file kis_color_selector_wheel.cpp.

{
    KoColor color = KoColor::createTransparent(m_parent->colorSpace());
 
    Q_ASSERT(x>=0 && x<=width());
    Q_ASSERT(y>=0 && y<=height());
 
    const qreal xRel = x - 0.5 * width();
    const qreal yRel = y - 0.5 * height();
    const qreal minDimension = qMin(width(), height());
 
    qreal radius = sqrt(xRel*xRel+yRel*yRel);
    if (radius > 0.5 * minDimension) {
        if (!forceValid) {
            return color;
        } else {
            radius = 0.5 * minDimension;
        }
    }
    radius /= 0.5 * minDimension;
 
    qreal angle = std::atan2(yRel, xRel);
    angle += M_PI;
    angle /= 2 * M_PI;
 
    switch(m_parameter) {
    case KisColorSelectorConfiguration::hsvSH:
        color = m_parent->converter()->fromHsvF(angle, radius, m_value);
        break;
    case KisColorSelectorConfiguration::hslSH:
        color = m_parent->converter()->fromHslF(angle, radius, m_lightness);
        break;
    case KisColorSelectorConfiguration::hsiSH:
        color = m_parent->converter()->fromHsiF(angle, radius, m_intensity);
        break;
    case KisColorSelectorConfiguration::hsySH:
        color = m_parent->converter()->fromHsyF(angle, radius, m_luma, R, G, B, Gamma);
        break;
    case KisColorSelectorConfiguration::VH:
        color = m_parent->converter()->fromHsvF(angle, m_hsvSaturation, radius);
        break;
    case KisColorSelectorConfiguration::LH:
        color = m_parent->converter()->fromHslF(angle, m_hslSaturation, radius);
        break;
    case KisColorSelectorConfiguration::IH:
        color = m_parent->converter()->fromHsiF(angle, m_hsiSaturation, radius);
        break;
    case KisColorSelectorConfiguration::YH:
        color = m_parent->converter()->fromHsyF(angle, m_hsySaturation, radius, R, G, B, Gamma);
        break;
    default:
        Q_ASSERT(false);
 
        return color;
    }
    return color;
}

References B, KisColorSelectorBase::colorSpace(), KisColorSelectorBase::converter(), KoColor::createTransparent(), KisDisplayColorConverter::fromHsiF(), KisDisplayColorConverter::fromHslF(), KisDisplayColorConverter::fromHsvF(), KisDisplayColorConverter::fromHsyF(), G, KisColorSelectorComponent::height(), KisColorSelectorConfiguration::hsiSH, KisColorSelectorConfiguration::hslSH, KisColorSelectorConfiguration::hsvSH, KisColorSelectorConfiguration::hsySH, KisColorSelectorConfiguration::IH, KisColorSelectorConfiguration::LH, KisColorSelectorComponent::m_hsiSaturation, KisColorSelectorComponent::m_hslSaturation, KisColorSelectorComponent::m_hsvSaturation, KisColorSelectorComponent::m_hsySaturation, KisColorSelectorComponent::m_intensity, KisColorSelectorComponent::m_lightness, KisColorSelectorComponent::m_luma, KisColorSelectorComponent::m_parameter, KisColorSelectorComponent::m_parent, M_PI, KisColorSelectorComponent::m_value, R, KisColorSelectorConfiguration::VH, KisColorSelectorComponent::width(), and KisColorSelectorConfiguration::YH.

paint()

void KisColorSelectorWheel::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 173 of file kis_color_selector_wheel.cpp.

{
 
    if(isDirty()) {
        KisPaintDeviceSP realPixelCache;
        Acs::PixelCacheRenderer::render(this, m_parent->converter(), QRect(0, 0, width(), height()), realPixelCache,
                                        m_pixelCache, m_pixelCacheOffset, painter->device()->devicePixelRatioF());
 
        //antialiasing for wheel
        QPainter tmpPainter(&m_pixelCache);
        tmpPainter.setRenderHint(QPainter::Antialiasing);
        tmpPainter.setPen(QPen(QColor(0,0,0,0), 2.5));
        tmpPainter.setCompositionMode(QPainter::CompositionMode_Clear);
        int size=qMin(width(), height());
 
        m_renderAreaSize = QSize(size,size);
        m_renderAreaOffsetX = ((qreal)width()-(qreal)m_renderAreaSize.width())*0.5;
        m_renderAreaOffsetY = ((qreal)height()-(qreal)m_renderAreaSize.height())*0.5;
        m_toRenderArea.reset();
        m_toRenderArea.translate(-m_renderAreaOffsetX,-m_renderAreaOffsetY);
 
        QPoint ellipseCenter(width() / 2 - size / 2, height() / 2 - size / 2);
        ellipseCenter -= m_pixelCacheOffset;
 
        tmpPainter.drawEllipse(ellipseCenter.x(), ellipseCenter.y(), size, size);
    }
 
    painter->drawImage(m_pixelCacheOffset.x(),m_pixelCacheOffset.y(), m_pixelCache);
 
    // draw gamut mask
    if (m_gamutMaskOn && m_currentGamutMask) {
        QImage maskBuffer = QImage(m_renderAreaSize*painter->device()->devicePixelRatioF(), QImage::Format_ARGB32_Premultiplied);
        maskBuffer.setDevicePixelRatio(painter->device()->devicePixelRatioF());
        maskBuffer.fill(0);
        QPainter maskPainter(&maskBuffer);
 
        QRect rect = QRect(0, 0, m_renderAreaSize.width(), m_renderAreaSize.height());
        maskPainter.setRenderHint(QPainter::Antialiasing, true);
 
        maskPainter.resetTransform();
        maskPainter.translate(rect.width()*0.5, rect.height()*0.5);
        maskPainter.scale(rect.width()*0.5, rect.height()*0.5);
 
        maskPainter.setPen(QPen(QBrush(Qt::white), 0.002));
        maskPainter.setBrush(QColor(128,128,128,255)); // middle gray
 
        maskPainter.drawEllipse(QPointF(0,0), 1.0, 1.0);
 
        maskPainter.resetTransform();
        maskPainter.setTransform(m_currentGamutMask->maskToViewTransform(m_renderAreaSize.width()));
 
        maskPainter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
        m_currentGamutMask->paint(maskPainter, m_maskPreviewActive);
 
        maskPainter.setCompositionMode(QPainter::CompositionMode_SourceOver);
        m_currentGamutMask->paintStroke(maskPainter, m_maskPreviewActive);
 
        painter->drawImage(m_renderAreaOffsetX, m_renderAreaOffsetY, maskBuffer);
    }
 
    // draw blips
 
    if(m_lastClickPos!=QPoint(-1,-1) && m_parent->displayBlip()) {
        QPoint pos = (m_lastClickPos*qMin(width(), height())).toPoint();
        if(width()<height())
            pos.setY(pos.y()+height()/2-width()/2);
        else
            pos.setX(pos.x()+width()/2-height()/2);
 
        painter->setPen(QColor(0,0,0));
        painter->drawEllipse(pos, 5, 5);
        painter->setPen(QColor(255,255,255));
        painter->drawEllipse(pos, 4, 4);
    }
}

References KisColorSelectorBase::converter(), KisColorSelector::displayBlip(), KisColorSelectorComponent::height(), KisColorSelectorComponent::isDirty(), KisColorSelectorComponent::m_currentGamutMask, KisColorSelectorComponent::m_gamutMaskOn, m_lastClickPos, KisColorSelectorComponent::m_maskPreviewActive, KisColorSelectorComponent::m_parent, m_pixelCache, m_pixelCacheOffset, m_renderAreaOffsetX, m_renderAreaOffsetY, m_renderAreaSize, m_toRenderArea, Acs::PixelCacheRenderer::render(), and KisColorSelectorComponent::width().

selectColor()

KoColor KisColorSelectorWheel::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 31 of file kis_color_selector_wheel.cpp.

{
    int xWheel = x-width()/2;
    int yWheel = y-height()/2;
 
    qreal radius = sqrt((double)xWheel*xWheel+yWheel*yWheel);
    radius/=qMin(width(), height());
    if(radius>0.5)
        radius=0.5;
 
    radius*=2.;
 
    qreal angle = std::atan2((qreal)yWheel, (qreal)xWheel);
    angle+=M_PI;
    angle/=2*M_PI;
 
    switch (m_parameter) {
    case KisColorSelectorConfiguration::hsvSH:
        Q_EMIT paramChanged(angle, radius, -1, -1, -1, -1, -1, -1, -1);
        break;
    case KisColorSelectorConfiguration::hslSH:
        Q_EMIT paramChanged(angle, -1, -1, radius, -1, -1, -1, -1, -1);
        break;
    case KisColorSelectorConfiguration::hsiSH:
        Q_EMIT paramChanged(angle, -1, -1, -1, -1, radius, -1, -1, -1);
        break;
    case KisColorSelectorConfiguration::hsySH:
        Q_EMIT paramChanged(angle, -1, -1, -1, -1, -1, -1, radius, -1);
        break;
    case KisColorSelectorConfiguration::VH:
        Q_EMIT paramChanged(angle, -1, radius, -1, -1, -1, -1, -1, -1);
        break;
    case KisColorSelectorConfiguration::LH:
        Q_EMIT paramChanged(angle, -1, -1, -1, radius, -1, -1, -1, -1);
        break;
    case KisColorSelectorConfiguration::IH:
        Q_EMIT paramChanged(angle, -1, -1, -1, -1, -1, radius, -1, -1);
        break;
    case KisColorSelectorConfiguration::YH:
        Q_EMIT paramChanged(angle, -1, -1, -1, -1, -1, -1, -1, radius);
        break;
    default:
        Q_ASSERT(false);
        break;
    }
 
    Q_EMIT update();
 
    angle *= 2. * M_PI;
    angle -= M_PI;
    radius*=0.5;
    m_lastClickPos.setX(cos(angle)*radius+0.5);
    m_lastClickPos.setY(sin(angle)*radius+0.5);
 
    return colorAt(x, y, true);
}

References colorAt(), KisColorSelectorComponent::height(), KisColorSelectorConfiguration::hsiSH, KisColorSelectorConfiguration::hslSH, KisColorSelectorConfiguration::hsvSH, KisColorSelectorConfiguration::hsySH, KisColorSelectorConfiguration::IH, KisColorSelectorConfiguration::LH, m_lastClickPos, KisColorSelectorComponent::m_parameter, M_PI, KisColorSelectorComponent::paramChanged(), KisColorSelectorComponent::update(), KisColorSelectorConfiguration::VH, KisColorSelectorComponent::width(), and KisColorSelectorConfiguration::YH.

setColor()

void KisColorSelectorWheel::setColor ( const KoColor & color )

overridevirtual

set the color, blibs etc

Reimplemented from KisColorSelectorComponent.

Definition at line 88 of file kis_color_selector_wheel.cpp.

{
    qreal hsvH, hsvS, hsvV;
    qreal hslH, hslS, hslL;
    qreal hsiH, hsiS, hsiI;
    qreal hsyH, hsyS, hsyY;
    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);
    m_parent->converter()->getHsvF(color, &hsvH, &hsvS, &hsvV);
    m_parent->converter()->getHslF(color, &hslH, &hslS, &hslL);
    m_parent->converter()->getHsiF(color, &hsiH, &hsiS, &hsiI);
    m_parent->converter()->getHsyF(color, &hsyH, &hsyS, &hsyY, R, G, B, Gamma);
 
    qreal angle = 0.0, radius = 0.0;
    switch (m_parameter) {
    case KisColorSelectorConfiguration::LH:
        Q_EMIT paramChanged(hslH, -1, -1, -1, hslL, -1, -1, -1, -1);
        angle = hslH;
        radius = hslL;
        break;
    case KisColorSelectorConfiguration::VH:
        Q_EMIT paramChanged(hsvH, -1, hsvV, -1, -1, -1, -1, -1, -1);
        angle = hsvH;
        radius = hsvV;
        break;
    case KisColorSelectorConfiguration::IH:
        Q_EMIT paramChanged(hslH, -1, -1, -1, -1, -1, hsiI, -1, -1);
        angle = hsiH;
        radius = hsiI;
        break;
    case KisColorSelectorConfiguration::YH:
        Q_EMIT paramChanged(hsyH, -1, -1, -1, -1, -1, -1, -1, hsyY);
        angle = hsyH;
        radius = hsyY;
        break;
    case KisColorSelectorConfiguration::hsvSH:
        Q_EMIT paramChanged(hsvH, hsvS, -1, -1, -1, -1, -1, -1, -1);
        angle = hsvH;
        radius = hsvS;
        break;
    case KisColorSelectorConfiguration::hslSH:
        Q_EMIT paramChanged(hslH, -1, -1, hslS, -1, -1, -1, -1, -1);
        angle = hslH;
        radius = hslS;
        break;
    case KisColorSelectorConfiguration::hsiSH:
        Q_EMIT paramChanged(hsiH, -1, -1, -1, -1, hsiS, -1, -1, -1);
        angle = hsiH;
        radius = hsiS;
        break;
    case KisColorSelectorConfiguration::hsySH:
        Q_EMIT paramChanged(hsyH, -1, -1, -1, -1, -1, -1, hsyS, -1);
        angle = hsyH;
        radius = hsyS;
        break;
    default:
        Q_ASSERT(false);
        break;
    }
    angle *= 2. * M_PI;
    angle -= M_PI;
    radius *= 0.5;
 
    m_lastClickPos.setX(cos(angle)*radius+0.5);
    m_lastClickPos.setY(sin(angle)*radius+0.5);
 
    //workaround for bug 279500
 
    if(m_lastClickPos!=QPoint(-1,-1) && m_parent->displayBlip()) {
        QPoint pos = (m_lastClickPos*qMin(width(), height())).toPoint();
        if(width() < height()) {
            pos.setY(pos.y()+height()/2-width()/2);
        } else {
            pos.setX(pos.x()+width()/2-height()/2);
        }
 
        setLastMousePosition(pos.x(), pos.y());
    }
 
    KisColorSelectorComponent::setColor(color);
}

References B, KisColorSelectorBase::converter(), KisColorSelector::displayBlip(), G, KisDisplayColorConverter::getHsiF(), KisDisplayColorConverter::getHslF(), KisDisplayColorConverter::getHsvF(), KisDisplayColorConverter::getHsyF(), KisColorSelectorComponent::height(), KisColorSelectorConfiguration::hsiSH, KisColorSelectorConfiguration::hslSH, KisColorSelectorConfiguration::hsvSH, KisColorSelectorConfiguration::hsySH, KisColorSelectorConfiguration::IH, KisColorSelectorConfiguration::LH, m_lastClickPos, KisColorSelectorComponent::m_parameter, KisColorSelectorComponent::m_parent, M_PI, KisColorSelectorComponent::paramChanged(), R, KisColorSelectorComponent::setColor(), KisColorSelectorComponent::setLastMousePosition(), KisColorSelectorConfiguration::VH, KisColorSelectorComponent::width(), and KisColorSelectorConfiguration::YH.

Friends And Related Symbol Documentation

Acs::PixelCacheRenderer

friend class Acs::PixelCacheRenderer

friend

Definition at line 35 of file kis_color_selector_wheel.h.

Member Data Documentation

B

qreal KisColorSelectorWheel::B {0.0}

private

Definition at line 45 of file kis_color_selector_wheel.h.

{0.0};

G

qreal KisColorSelectorWheel::G {0.0}

private

Definition at line 44 of file kis_color_selector_wheel.h.

{0.0};

Gamma

qreal KisColorSelectorWheel::Gamma {0.0}

private

Definition at line 46 of file kis_color_selector_wheel.h.

{0.0};

m_lastClickPos

QPointF KisColorSelectorWheel::m_lastClickPos

private

Definition at line 40 of file kis_color_selector_wheel.h.

m_pixelCache

QImage KisColorSelectorWheel::m_pixelCache

private

Definition at line 41 of file kis_color_selector_wheel.h.

m_pixelCacheOffset

QPoint KisColorSelectorWheel::m_pixelCacheOffset

private

Definition at line 42 of file kis_color_selector_wheel.h.

m_renderAreaOffsetX

qreal KisColorSelectorWheel::m_renderAreaOffsetX {0.0}

private

Definition at line 49 of file kis_color_selector_wheel.h.

{0.0};

m_renderAreaOffsetY

qreal KisColorSelectorWheel::m_renderAreaOffsetY {0.0}

private

Definition at line 50 of file kis_color_selector_wheel.h.

{0.0};

m_renderAreaSize

QSize KisColorSelectorWheel::m_renderAreaSize

private

Definition at line 48 of file kis_color_selector_wheel.h.

m_toRenderArea

QTransform KisColorSelectorWheel::m_toRenderArea

private

Definition at line 51 of file kis_color_selector_wheel.h.

R

qreal KisColorSelectorWheel::R {0.0}

private

Definition at line 43 of file kis_color_selector_wheel.h.

{0.0};

---

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

• plugins/dockers/advancedcolorselector/kis_color_selector_wheel.h
• plugins/dockers/advancedcolorselector/kis_color_selector_wheel.cpp