WGMyPaintShadeSelector Class Reference

A port of MyPaint's "Crossed Bowl" color selector. More...

#include <WGMyPaintShadeSelector.h>

Inheritance diagram for WGMyPaintShadeSelector:

Public Member Functions
void	setModel (KisVisualColorModelSP model) override
	WGMyPaintShadeSelector (WGSelectorDisplayConfigSP displayConfig, QWidget *parent, UiMode mode)
	~WGMyPaintShadeSelector () override
Public Member Functions inherited from WGSelectorWidgetBase
WGSelectorDisplayConfigSP	displayConfiguration () const
const KisDisplayColorConverter *	displayConverter () const
virtual QPoint	popupOffset () const
	The position, relative to the top left corner, where the cursor of the cursor shall be when showing the popup.
void	setUiMode (UiMode mode)
UiMode	uiMode () const
virtual void	updateSettings ()
	WGSelectorWidgetBase (WGSelectorDisplayConfigSP displayConfig, QWidget *parent=nullptr, UiMode uiMode=UiMode::DockerMode)

Protected Member Functions
bool	getChannelValues (QPoint pos, QVector4D &values, QVector4D &blendValues)
void	mouseMoveEvent (QMouseEvent *event) override
void	mousePressEvent (QMouseEvent *event) override
void	mouseReleaseEvent (QMouseEvent *event) override
void	paintEvent (QPaintEvent *) override
void	pickColorAt (const QPointF &posF)
void	recalculateSizeHD ()
void	resizeEvent (QResizeEvent *event) override

Private Slots
void	slotSetChannelValues (const QVector4D &values)

Private Attributes
bool	m_allowUpdates {true}
float	m_colorH {0.0f}
float	m_colorS {0.0f}
float	m_colorV {0.0f}
int	m_heightHD
KisVisualColorModelSP	m_model
KisPaintDeviceSP	m_realCircleBorder
KisPaintDeviceSP	m_realPixelCache
int	m_sizeHD
int	m_widthHD

Additional Inherited Members
Public Types inherited from WGSelectorWidgetBase
enum	UiMode { DockerMode , PopupMode }
Signals inherited from WGSelectorWidgetBase
void	sigChannelValuesChanged (const QVector4D &values)
void	sigColorInteraction (bool active)

Detailed Description

A port of MyPaint's "Crossed Bowl" color selector.

Definition at line 18 of file WGMyPaintShadeSelector.h.

Constructor & Destructor Documentation

WGMyPaintShadeSelector()

WGMyPaintShadeSelector::WGMyPaintShadeSelector	(	WGSelectorDisplayConfigSP	displayConfig,
		QWidget *	parent,
		UiMode	mode )

Definition at line 44 of file WGMyPaintShadeSelector.cpp.

    : WGSelectorWidgetBase(displayConfig, parent, mode)
{
    recalculateSizeHD();
}

References recalculateSizeHD().

~WGMyPaintShadeSelector()

WGMyPaintShadeSelector::~WGMyPaintShadeSelector ( )

override

Definition at line 50 of file WGMyPaintShadeSelector.cpp.

{
 
}

Member Function Documentation

getChannelValues()

bool WGMyPaintShadeSelector::getChannelValues ( QPoint pos, QVector4D & values, QVector4D & blendValues )

protected

Definition at line 162 of file WGMyPaintShadeSelector.cpp.

{
    bool needsBlending = false;
 
    const float v_factor = 0.6f;
    const float s_factor = 0.6f;
    const float v_factor2 = 0.013f;
    const float s_factor2 = 0.013f;
 
    const int stripe_width = (15 * m_sizeHD)/255;
    int s_radiusHD = m_sizeHD/2.6;
 
    float h = 0;
    float s = 0;
    float v = 0;
 
    int dx = pos.x() - m_widthHD/2;
    int dy = pos.y() - m_heightHD/2;
    int diag = sqrt(2.0) * m_sizeHD/2;
 
    int dxs, dys;
    if (dx > 0)
        dxs = dx - stripe_width;
    else
        dxs = dx + stripe_width;
    if (dy > 0)
        dys = dy - stripe_width;
    else
        dys = dy + stripe_width;
 
    qreal r = std::sqrt(qreal(sqr(dxs)+sqr(dys)));
 
    if (qMin(abs(dx), abs(dy)) < stripe_width) {
        // horizontal and vertical lines
        bool horizontal = std::abs(dx) > std::abs(dy);
        dx = (dx/qreal(m_sizeHD))*255;
        dy = (dy/qreal(m_sizeHD))*255;
 
        h = 0;
        // x-axis = value, y-axis = saturation
        v =    dx*v_factor + signedSqr(dx)*v_factor2;
        s = - (dy*s_factor + signedSqr(dy)*s_factor2);
        // but not both at once
        if (horizontal) {
            // horizontal stripe
            s = 0.0;
        } else {
            // vertical stripe
            v = 0.0;
        }
    }
    else if (std::min(std::abs(dx - dy), std::abs(dx + dy)) < stripe_width) {
 
        dx = (dx/qreal(m_sizeHD))*255;
        dy = (dy/qreal(m_sizeHD))*255;
 
        h = 0;
        // x-axis = value, y-axis = saturation
        v =    dx*v_factor + signedSqr(dx)*v_factor2;
        s = - (dy*s_factor + signedSqr(dy)*s_factor2);
        // both at once
    }
    else if (r < s_radiusHD+1) {
 
        // hue
        if (dx > 0)
            h = 90*sqr2(r/s_radiusHD);
        else
            h = 360 - 90*sqr2(r/s_radiusHD);
        s = 256*(atan2f(std::abs(dxs),dys)/M_PI) - 128;
 
        if (r > s_radiusHD) {
            needsBlending = true;
            // antialiasing boarder
            qreal aaFactor = r-floor(r); // part after the decimal point
            aaFactor = 1-aaFactor;
 
            qreal fh = m_colorH + h/360.0;
            qreal fs = m_colorS + s/255.0;
            qreal fv = m_colorV + v/255.0;
 
            fh -= floor(fh);
            fs = qBound(qreal(0.0), fs, qreal(1.0));
            fv = qBound(qreal(0.01), fv, qreal(1.0));
            blendValues = QVector4D(fh, fs, fv, aaFactor);
 
            h = 180 + 180*atan2f(dys,-dxs)/M_PI;
            v = 255*(r-s_radiusHD)/(diag-s_radiusHD) - 128;
            s = 0; // overwrite the s value that was meant for the inside of the circle
            // here we already have drawn the inside, and the value left should be just the background value
        }
    }
    else {
        // background (hue+darkness gradient)
        h = 180 + 180*atan2f(dys,-dxs)/M_PI;
        v = 255*(r-s_radiusHD)/(diag-s_radiusHD) - 128;
    }
 
    qreal fh = m_colorH + h/360.0;
    qreal fs = m_colorS + s/255.0;
    qreal fv = m_colorV + v/255.0;
 
    fh -= floor(fh);
    fs = qBound(qreal(0.0), fs, qreal(1.0));
    fv = qBound(qreal(0.01), fv, qreal(1.0));
    values = QVector4D(fh, fs, fv, 0);
 
    return needsBlending;
}

References m_colorH, m_colorS, m_colorV, m_heightHD, M_PI, m_sizeHD, m_widthHD, signedSqr(), sqr(), sqr2(), and v.

mouseMoveEvent()

void WGMyPaintShadeSelector::mouseMoveEvent ( QMouseEvent * event )

overrideprotected

Definition at line 81 of file WGMyPaintShadeSelector.cpp.

{
    if (event->buttons() & Qt::LeftButton) {
        if (rect().contains(event->pos())) {
            pickColorAt(event->localPos());
        }
    } else {
        event->ignore();
    }
}

References pickColorAt().

mousePressEvent()

void WGMyPaintShadeSelector::mousePressEvent ( QMouseEvent * event )

overrideprotected

Definition at line 71 of file WGMyPaintShadeSelector.cpp.

{
    if (event->button() == Qt::LeftButton) {
        Q_EMIT sigColorInteraction(true);
        pickColorAt(event->localPos());
    } else {
        event->ignore();
    }
}

References pickColorAt(), and WGSelectorWidgetBase::sigColorInteraction().

mouseReleaseEvent()

void WGMyPaintShadeSelector::mouseReleaseEvent ( QMouseEvent * event )

overrideprotected

Definition at line 92 of file WGMyPaintShadeSelector.cpp.

{
    if (event->button() == Qt::LeftButton) {
        Q_EMIT sigColorInteraction(false);
    } else {
        event->ignore();
    }
}

References WGSelectorWidgetBase::sigColorInteraction().

paintEvent()

void WGMyPaintShadeSelector::paintEvent ( QPaintEvent * )

overrideprotected

Definition at line 101 of file WGMyPaintShadeSelector.cpp.

{
    // Hint to the casual reader: some of the calculation here do not
    // what Martin Renold originally intended. Not everything here will make sense.
    // It does not matter in the end, as long as the result looks good.
    if (!m_model || !m_model->isHSXModel()) {
        return;
    }
 
    // This selector was ported from MyPaint in 2010
    if (!m_realPixelCache || m_realPixelCache->colorSpace() != m_model->colorSpace()) {
        m_realPixelCache = new KisPaintDevice(m_model->colorSpace());
        m_realCircleBorder = new KisPaintDevice(m_model->colorSpace());
//        m_cachedColorSpace = colorSpace();
    }
    else {
        m_realPixelCache->clear();
        m_realCircleBorder->clear();
    }
 
    const int pixelSize = m_model->colorSpace()->pixelSize();
 
    QRect pickRectHighDPI = QRect(QPoint(0, 0), size()*devicePixelRatioF());
    KisSequentialIterator it(m_realPixelCache, pickRectHighDPI);
    KisSequentialIterator borderIt(m_realCircleBorder, pickRectHighDPI);
    QVector4D values;
    QVector4D values2;
 
    while (it.nextPixel() && borderIt.nextPixel()) {
        const int x = it.x();
        const int y = it.y();
 
        bool needsBlending = getChannelValues(QPoint(x, y), values, values2);
 
        if (needsBlending) {
            const qreal aaFactor = static_cast<qreal>(values2[3]);
            KoColor color = m_model->convertChannelValuesToKoColor(values2);
            color.setOpacity(aaFactor);
            setColorWithIterator(borderIt, color, pixelSize);
        }
 
        KoColor color = m_model->convertChannelValuesToKoColor(values);
        setColorWithIterator(it, color, pixelSize);
    }
 
    KisPainter gc(m_realPixelCache);
    gc.bitBlt(QPoint(0,0), m_realCircleBorder, QRect(rect().topLeft(), rect().size()*devicePixelRatioF()));
 
    QPainter painter(this);
    QImage renderedImage = displayConverter()->toQImage(m_realPixelCache, displayConfiguration()->previewInPaintingCS());
    renderedImage.setDevicePixelRatio(devicePixelRatioF());
 
    painter.drawImage(0, 0, renderedImage);
}

References KisPainter::bitBlt(), KisPaintDevice::clear(), KisPaintDevice::colorSpace(), WGSelectorWidgetBase::displayConfiguration(), WGSelectorWidgetBase::displayConverter(), getChannelValues(), m_model, m_realCircleBorder, m_realPixelCache, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), setColorWithIterator(), KoColor::setOpacity(), KisDisplayColorConverter::toQImage(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::x(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::y().

pickColorAt()

void WGMyPaintShadeSelector::pickColorAt ( const QPointF & posF )

protected

Definition at line 272 of file WGMyPaintShadeSelector.cpp.

{
    QPoint pos = (posF * devicePixelRatioF()).toPoint();
    QVector4D values, dummy;
    getChannelValues(pos, values, dummy);
    m_allowUpdates = false;
    Q_EMIT sigChannelValuesChanged(values);
    m_allowUpdates = true;
}

References getChannelValues(), m_allowUpdates, and WGSelectorWidgetBase::sigChannelValuesChanged().

recalculateSizeHD()

void WGMyPaintShadeSelector::recalculateSizeHD ( )

protected

Definition at line 282 of file WGMyPaintShadeSelector.cpp.

{
    m_widthHD = qMax(1, width()) * devicePixelRatioF();
    m_heightHD = qMax(1, height()) *devicePixelRatioF();
    m_sizeHD = qMin(m_widthHD, m_heightHD);
}

References m_heightHD, m_sizeHD, and m_widthHD.

resizeEvent()

void WGMyPaintShadeSelector::resizeEvent ( QResizeEvent * event )

overrideprotected

Definition at line 156 of file WGMyPaintShadeSelector.cpp.

{
    WGSelectorWidgetBase::resizeEvent(event);
    recalculateSizeHD();
}

References recalculateSizeHD().

setModel()

void WGMyPaintShadeSelector::setModel ( KisVisualColorModelSP model )

overridevirtual

Reimplemented from WGSelectorWidgetBase.

Definition at line 55 of file WGMyPaintShadeSelector.cpp.

{
    if (m_model) {
        disconnect(m_model.data());
        m_model->disconnect(this);
    }
    m_model = model;
    connect(this, SIGNAL(sigChannelValuesChanged(QVector4D)),
            m_model.data(), SLOT(slotSetChannelValues(QVector4D)));
    connect(m_model.data(), SIGNAL(sigChannelValuesChanged(QVector4D,quint32)),
            this, SLOT(slotSetChannelValues(QVector4D)));
    if (m_model->isHSXModel()) {
        slotSetChannelValues(m_model->channelValues());
    }
}

References connect(), m_model, WGSelectorWidgetBase::sigChannelValuesChanged(), and slotSetChannelValues().

slotSetChannelValues

void WGMyPaintShadeSelector::slotSetChannelValues ( const QVector4D & values )

privateslot

Definition at line 289 of file WGMyPaintShadeSelector.cpp.

{
    if (m_allowUpdates) {
        m_colorH = values.x();
        m_colorS = values.y();
        m_colorV = values.z();
        update();
    }
}

References m_allowUpdates, m_colorH, m_colorS, and m_colorV.

Member Data Documentation

m_allowUpdates

bool WGMyPaintShadeSelector::m_allowUpdates {true}

private

Definition at line 51 of file WGMyPaintShadeSelector.h.

{true};

m_colorH

float WGMyPaintShadeSelector::m_colorH {0.0f}

private

Definition at line 45 of file WGMyPaintShadeSelector.h.

{0.0f};

m_colorS

float WGMyPaintShadeSelector::m_colorS {0.0f}

private

Definition at line 46 of file WGMyPaintShadeSelector.h.

{0.0f};

m_colorV

float WGMyPaintShadeSelector::m_colorV {0.0f}

private

Definition at line 47 of file WGMyPaintShadeSelector.h.

{0.0f};

m_heightHD

int WGMyPaintShadeSelector::m_heightHD

private

Definition at line 50 of file WGMyPaintShadeSelector.h.

m_model

KisVisualColorModelSP WGMyPaintShadeSelector::m_model

private

Definition at line 42 of file WGMyPaintShadeSelector.h.

m_realCircleBorder

KisPaintDeviceSP WGMyPaintShadeSelector::m_realCircleBorder

private

Definition at line 44 of file WGMyPaintShadeSelector.h.

m_realPixelCache

KisPaintDeviceSP WGMyPaintShadeSelector::m_realPixelCache

private

Definition at line 43 of file WGMyPaintShadeSelector.h.

m_sizeHD

int WGMyPaintShadeSelector::m_sizeHD

private

Definition at line 48 of file WGMyPaintShadeSelector.h.

m_widthHD

int WGMyPaintShadeSelector::m_widthHD

private

Definition at line 49 of file WGMyPaintShadeSelector.h.

---

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

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