KisVisualRectangleSelectorShape Class Reference

#include <KisVisualRectangleSelectorShape.h>

Inheritance diagram for KisVisualRectangleSelectorShape:

Public Types
enum	singelDTypes { vertical , horizontal , border , borderMirrored }
Public Types inherited from KisVisualColorSelectorShape
enum	Dimensions { onedimensional , twodimensional }
	The Dimensions enum Whether or not the shape is single or two dimensional. More...

Public Member Functions
QRect	getSpaceForCircle (QRect geom) override
QRect	getSpaceForSquare (QRect geom) override
	getSpaceForSquare
QRect	getSpaceForTriangle (QRect geom) override
	KisVisualRectangleSelectorShape (KisVisualColorSelector *parent, Dimensions dimension, int channel1, int channel2, int width=20, KisVisualRectangleSelectorShape::singelDTypes d=KisVisualRectangleSelectorShape::vertical)
void	setBorderWidth (int width) override
	setBorderWidth set the border of the single dimensional selector.
void	setOneDimensionalType (singelDTypes type)
	~KisVisualRectangleSelectorShape () override
Public Member Functions inherited from KisVisualColorSelectorShape
int	channel (int dimension) const
	channel Get the channel index associated with a selector shape dimension
quint32	channelMask () const
void	forceImageUpdate ()
	forceImageUpdate force the image to recache.
QColor	getColorFromConverter (KoColor c)
	getColorFromConverter
KoColor	getCurrentColor ()
	getCurrentColor
QPointF	getCursorPosition () const
	getCursorPosition
Dimensions	getDimensions () const
	getDimensions
const QImage &	getImageMap ()
	getImageMap returns the updated base image
bool	isHueControl () const
	KisVisualColorSelectorShape (KisVisualColorSelector *parent, KisVisualColorSelectorShape::Dimensions dimension, int channel1, int channel2)
void	setAcceptTabletEvents (bool on)
void	setChannelValues (QVector4D channelValues, quint32 channelFlags)
	setChannelValues Set the current channel values; Note that channel values controlled by the shape itself have no effect unless setCursor is true. This will trigger a full widget repaint.
void	setCursorPosition (QPointF position, bool signal=false)
	setCursorPosition Set the cursor to normalized shape coordinates. This will only repaint the cursor.
virtual bool	supportsGamutMask () const
virtual void	updateGamutMask ()
	Notify shape that the gamut mask changed.
	~KisVisualColorSelectorShape () override

Protected Member Functions
QRect	getAvailableSpace (QRect geom, bool stretch)
QImage	renderAlphaMask () const override
	render the alpha mask for the widget background the returned image is expected to be QImage::Format_Alpha8
Protected Member Functions inherited from KisVisualColorSelectorShape
KisVisualColorSelector *	colorSelector () const
virtual QImage	compositeBackground () const
QImage	convertImageMap (const quint8 *rawColor, quint32 bufferSize, QSize imgSize) const
	convertImageMap convert image data containing raw KoColor data into a QImage
void	mouseMoveEvent (QMouseEvent *e) override
virtual QPointF	mousePositionToShapeCoordinate (const QPointF &pos, const QPointF &dragStart) const
	default implementation just calls convertWidgetCoordinateToShapeCoordinate(pos)
void	mousePressEvent (QMouseEvent *e) override
void	mouseReleaseEvent (QMouseEvent *e) override
void	paintEvent (QPaintEvent *) override
virtual QImage	renderBackground (const QVector4D &channelValues, const QImage &alpha) const
	renderBackground Render the widget background visible inside the widget's mask in current color space Rendering shall be done with the conversion functions of KisVisualColorSelector
virtual QImage	renderStaticAlphaMask () const
void	resizeEvent (QResizeEvent *) override
KisVisualColorModel *	selectorModel () const
void	tabletEvent (QTabletEvent *event) override

Private Member Functions
QPointF	convertShapeCoordinateToWidgetCoordinate (QPointF coordinate) const override
	convertShapeCoordinateToWidgetCoordinate
QPointF	convertWidgetCoordinateToShapeCoordinate (QPointF coordinate) const override
	convertWidgetCoordinateToShapeCoordinate Convert a coordinate in the widget's height/width to a shape coordinate.
void	drawCursor (QPainter &painter) override
QRegion	getMaskMap () override
	getPixmap

Private Attributes
int	m_barWidth
singelDTypes	m_type

Additional Inherited Members
Signals inherited from KisVisualColorSelectorShape
void	sigCursorMoved (QPointF pos)

Detailed Description

Definition at line 11 of file KisVisualRectangleSelectorShape.h.

Member Enumeration Documentation

singelDTypes

enum KisVisualRectangleSelectorShape::singelDTypes

Enumerator
vertical
horizontal
border
borderMirrored

Definition at line 15 of file KisVisualRectangleSelectorShape.h.

{vertical, horizontal, border, borderMirrored};

Constructor & Destructor Documentation

KisVisualRectangleSelectorShape()

KisVisualRectangleSelectorShape::KisVisualRectangleSelectorShape ( KisVisualColorSelector * parent, Dimensions dimension, int channel1, int channel2, int width = 20, KisVisualRectangleSelectorShape::singelDTypes d = KisVisualRectangleSelectorShape::vertical )

explicit

Definition at line 17 of file KisVisualRectangleSelectorShape.cpp.

    : KisVisualColorSelectorShape(parent, dimension, channel1, channel2)
{
    //qDebug()  << "creating KisVisualRectangleSelectorShape" << this;
    m_type = d;
    m_barWidth = width;
}

References m_barWidth, and m_type.

~KisVisualRectangleSelectorShape()

KisVisualRectangleSelectorShape::~KisVisualRectangleSelectorShape ( )

override

Definition at line 29 of file KisVisualRectangleSelectorShape.cpp.

{
    //qDebug() << "deleting KisVisualRectangleSelectorShape" << this;
}

Member Function Documentation

convertShapeCoordinateToWidgetCoordinate()

QPointF KisVisualRectangleSelectorShape::convertShapeCoordinateToWidgetCoordinate ( QPointF ) const

overrideprivatevirtual

convertShapeCoordinateToWidgetCoordinate

Returns

take the position in the shape and convert it to screen coordinates.

Implements KisVisualColorSelectorShape.

Definition at line 92 of file KisVisualRectangleSelectorShape.cpp.

{
    // Reminder: in Qt widget space, origin is top-left, but we want zero y to be at the bottom
    qreal x = 0.5 * width();
    qreal y = 0.5 * height();
    qreal offset = 5.0;
    KisVisualColorSelectorShape::Dimensions dimension = getDimensions();
    if (dimension == KisVisualColorSelectorShape::onedimensional) {
        if ( m_type == KisVisualRectangleSelectorShape::vertical) {
            y = qMin((1.0 - coordinate.x())*(height()-offset*2)+offset, (qreal)height());
        } else if (m_type == KisVisualRectangleSelectorShape::horizontal) {
            x = qMin(coordinate.x()*(width()-offset*2)+offset, (qreal)width());
        } else if (m_type == KisVisualRectangleSelectorShape::border) {
 
            QRectF innerRect(m_barWidth/2, m_barWidth/2, width()-m_barWidth, height()-m_barWidth);
            QPointF left (innerRect.left(),innerRect.center().y());
            QList <QLineF> polygonLines;
            polygonLines.append(QLineF(left, innerRect.topLeft()));
            polygonLines.append(QLineF(innerRect.topLeft(), innerRect.topRight()));
            polygonLines.append(QLineF(innerRect.topRight(), innerRect.bottomRight()));
            polygonLines.append(QLineF(innerRect.bottomRight(), innerRect.bottomLeft()));
            polygonLines.append(QLineF(innerRect.bottomLeft(), left));
 
            qreal totalLength =0.0;
            Q_FOREACH(QLineF line, polygonLines) {
                totalLength += line.length();
            }
 
            qreal length = coordinate.x()*totalLength;
            QPointF intersect(x,y);
            Q_FOREACH(QLineF line, polygonLines) {
                if (line.length()>length && length>0){
                    intersect = line.pointAt(length/line.length());
 
                }
                length-=line.length();
            }
            x = qRound(intersect.x());
            y = qRound(intersect.y());
 
        }
        else /*if (m_type == KisVisualRectangleSelectorShape::borderMirrored)*/  {
 
            QRectF innerRect(m_barWidth/2, m_barWidth/2, width()-m_barWidth, height()-m_barWidth);
            QPointF bottom (innerRect.center().x(), innerRect.bottom());
            QList <QLineF> polygonLines;
            polygonLines.append(QLineF(bottom, innerRect.bottomLeft()));
            polygonLines.append(QLineF(innerRect.bottomLeft(), innerRect.topLeft()));
            polygonLines.append(QLineF(innerRect.topLeft(), innerRect.topRight()));
            polygonLines.append(QLineF(innerRect.topRight(), innerRect.bottomRight()));
            polygonLines.append(QLineF(innerRect.bottomRight(), bottom));
 
            qreal totalLength =0.0;
            Q_FOREACH(QLineF line, polygonLines) {
                totalLength += line.length();
            }
 
            qreal length = coordinate.x()*(totalLength/2);
            QPointF intersect(x,y);
            if (coordinate.y()==1) {
                for (int i = polygonLines.size()-1; i==0; i--) {
                    QLineF line = polygonLines.at(i);
                    if (line.length()>length && length>0){
                        intersect = line.pointAt(length/line.length());
 
                    }
                    length-=line.length();
                }
            } else {
                Q_FOREACH(QLineF line, polygonLines) {
                    if (line.length()>length && length>0){
                        intersect = line.pointAt(length/line.length());
 
                    }
                    length-=line.length();
                }
            }
            x = qRound(intersect.x());
            y = qRound(intersect.y());
 
        }
    } else {
        x = qMin(coordinate.x()*(width()-offset*2)+offset, (qreal)width());
        y = qMin((1.0 - coordinate.y())*(height()-offset*2)+offset, (qreal)height());
    }
    return QPointF(x,y);
}

References border, KisVisualColorSelectorShape::getDimensions(), horizontal, length(), m_barWidth, m_type, KisVisualColorSelectorShape::onedimensional, and vertical.

convertWidgetCoordinateToShapeCoordinate()

QPointF KisVisualRectangleSelectorShape::convertWidgetCoordinateToShapeCoordinate ( QPointF coordinate ) const

overrideprivatevirtual

convertWidgetCoordinateToShapeCoordinate Convert a coordinate in the widget's height/width to a shape coordinate.

Parameters

coordinate

the position your wish to have the shape coordinates of.

Implements KisVisualColorSelectorShape.

Definition at line 180 of file KisVisualRectangleSelectorShape.cpp.

{
    // Reminder: in Qt widget space, origin is top-left, but we want zero y to be at the bottom
    //default values:
    qreal x = 0.5;
    qreal y = 0.5;
    qreal offset = 5.0;
    KisVisualColorSelectorShape::Dimensions dimension = getDimensions();
    if (dimension == KisVisualColorSelectorShape::onedimensional ) {
        if (m_type == KisVisualRectangleSelectorShape::vertical) {
            x = 1.0 - (coordinate.y()-offset)/(height()-offset*2);
        } else if (m_type == KisVisualRectangleSelectorShape::horizontal) {
            x = (coordinate.x()-offset)/(width()-offset*2);
        } else if (m_type == KisVisualRectangleSelectorShape::border) {
            //border
 
            QRectF innerRect(m_barWidth, m_barWidth, width()-(m_barWidth*2), height()-(m_barWidth*2));
            QPointF left (innerRect.left(),innerRect.center().y());
            QList <QLineF> polygonLines;
            polygonLines.append(QLineF(left, innerRect.topLeft()));
            polygonLines.append(QLineF(innerRect.topLeft(), innerRect.topRight()));
            polygonLines.append(QLineF(innerRect.topRight(), innerRect.bottomRight()));
            polygonLines.append(QLineF(innerRect.bottomRight(), innerRect.bottomLeft()));
            polygonLines.append(QLineF(innerRect.bottomLeft(), left));
 
            QLineF radius(coordinate, this->geometry().center());
            QPointF intersect(0.5,0.5);
            qreal length = 0.0;
            qreal totalLength = 0.0;
            bool foundIntersect = false;
            Q_FOREACH(QLineF line, polygonLines) {
                if (line.intersects(radius, &intersect) == QLineF::BoundedIntersection && foundIntersect == false)
                {
                    foundIntersect = true;
                    length+=QLineF(line.p1(), intersect).length();
 
                }
                if (foundIntersect==false) {
                    length+=line.length();
                }
                totalLength+=line.length();
            }
 
            x = length/totalLength;
 
        } else /*if (m_type == KisVisualRectangleSelectorShape::borderMirrored)*/  {
            //border
 
            QRectF innerRect(m_barWidth, m_barWidth, width()-(m_barWidth*2), height()-(m_barWidth*2));
            QPointF bottom (innerRect.center().x(), innerRect.bottom());
            QList <QLineF> polygonLines;
            polygonLines.append(QLineF(bottom, innerRect.bottomLeft()));
            polygonLines.append(QLineF(innerRect.bottomLeft(), innerRect.topLeft()));
            polygonLines.append(QLineF(innerRect.topLeft(), innerRect.topRight()));
            polygonLines.append(QLineF(innerRect.topRight(), innerRect.bottomRight()));
            polygonLines.append(QLineF(innerRect.bottomRight(), bottom));
 
            QLineF radius(coordinate, this->geometry().center());
            QPointF intersect(0.5,0.5);
            qreal length = 0.0;
            qreal totalLength = 0.0;
            bool foundIntersect = false;
            Q_FOREACH(QLineF line, polygonLines) {
                if (line.intersects(radius, &intersect) == QLineF::BoundedIntersection && foundIntersect == false)
                {
                    foundIntersect = true;
                    length+=QLineF(line.p1(), intersect).length();
 
                }
                if (foundIntersect==false) {
                    length+=line.length();
                }
                totalLength+=line.length();
            }
            int halflength = totalLength/2;
 
            if (length>halflength) {
                x = (halflength - (length-halflength))/halflength;
                y = 1.0;
            } else {
                x = length/halflength;
                y = 0.0;
            }
        }
    }
    else {
        x = (coordinate.x()-offset)/(width()-offset*2);
        y = 1.0 - (coordinate.y()-offset)/(height()-offset*2);
    }
    x = qBound((qreal)0.0, x, (qreal)1.0);
    y = qBound((qreal)0.0, y, (qreal)1.0);
    return QPointF(x, y);
}

References border, KisVisualColorSelectorShape::getDimensions(), horizontal, length(), m_barWidth, m_type, KisVisualColorSelectorShape::onedimensional, and vertical.

drawCursor()

void KisVisualRectangleSelectorShape::drawCursor ( QPainter & painter )

overrideprivatevirtual

Implements KisVisualColorSelectorShape.

Definition at line 315 of file KisVisualRectangleSelectorShape.cpp.

{
    //qDebug() << this << "KisVisualRectangleSelectorShape::drawCursor: image needs update" << imagesNeedUpdate();
    QPointF cursorPoint = convertShapeCoordinateToWidgetCoordinate(getCursorPosition());
    QColor col = getColorFromConverter(getCurrentColor());
    QBrush fill(Qt::SolidPattern);
 
    int cursorwidth = 5;
 
    if (getDimensions() == KisVisualColorSelectorShape::onedimensional
            && m_type != KisVisualRectangleSelectorShape::border
            && m_type != KisVisualRectangleSelectorShape::borderMirrored) {
        QRectF rect;
        if (m_type==KisVisualRectangleSelectorShape::vertical) {
            qreal y = qRound(cursorPoint.y());
            rect.setCoords(1.5, y - cursorwidth + 0.5, width() - 1.5, y + cursorwidth - 0.5);
        } else {
            qreal x = qRound(cursorPoint.x());
            rect.setCoords(x - cursorwidth  + 0.5, 1.5, x + cursorwidth - 0.5, height() - 1.5);
        }
        painter.setPen(Qt::white);
        fill.setColor(Qt::white);
        painter.setBrush(fill);
        painter.drawRect(rect);
        fill.setColor(col);
        painter.setPen(Qt::black);
        painter.setBrush(fill);
        painter.drawRect(rect.adjusted(1, 1, -1, -1));
 
    }else if(m_type==KisVisualRectangleSelectorShape::borderMirrored){
        QRectF innerRect(m_barWidth, m_barWidth, width()-(m_barWidth*2), height()-(m_barWidth*2));
        painter.setPen(Qt::white);
        fill.setColor(Qt::white);
        painter.setBrush(fill);
        painter.drawEllipse(cursorPoint, cursorwidth, cursorwidth);
        QPoint mirror(innerRect.center().x()+(innerRect.center().x()-cursorPoint.x()),cursorPoint.y());
        painter.drawEllipse(mirror, cursorwidth, cursorwidth);
        fill.setColor(col);
        painter.setPen(Qt::black);
        painter.setBrush(fill);
        painter.drawEllipse(cursorPoint, cursorwidth-1, cursorwidth-1);
        painter.drawEllipse(mirror, cursorwidth-1, cursorwidth-1);
 
    } else {
        painter.setPen(Qt::white);
        fill.setColor(Qt::white);
        painter.setBrush(fill);
        painter.drawEllipse(cursorPoint, cursorwidth, cursorwidth);
        fill.setColor(col);
        painter.setPen(Qt::black);
        painter.setBrush(fill);
        painter.drawEllipse(cursorPoint, cursorwidth-1.0, cursorwidth-1.0);
    }
}

References border, borderMirrored, convertShapeCoordinateToWidgetCoordinate(), KisVisualColorSelectorShape::getColorFromConverter(), KisVisualColorSelectorShape::getCurrentColor(), KisVisualColorSelectorShape::getCursorPosition(), KisVisualColorSelectorShape::getDimensions(), m_barWidth, m_type, KisVisualColorSelectorShape::onedimensional, and vertical.

getAvailableSpace()

QRect KisVisualRectangleSelectorShape::getAvailableSpace ( QRect geom, bool stretch )

protected

Definition at line 63 of file KisVisualRectangleSelectorShape.cpp.

{
    QPoint tl;
    QPoint br;
 
    if (m_type == KisVisualRectangleSelectorShape::vertical) {
        br = geom.bottomRight();
        tl = QPoint(geom.topLeft().x() + m_barWidth, geom.topLeft().y());
    } else if (m_type == KisVisualRectangleSelectorShape::horizontal) {
        br = geom.bottomRight();
        tl = QPoint(geom.topLeft().x(), geom.topLeft().y() + m_barWidth);
    } else {
        tl = QPoint(geom.topLeft().x() + m_barWidth, geom.topLeft().y() + m_barWidth);
        br = QPoint(geom.bottomRight().x() - m_barWidth, geom.bottomRight().y() - m_barWidth);
    }
    QRect available(tl, br);
    if (!stretch) {
        int size = qMin(available.height(), available.width());
        if (m_type == KisVisualRectangleSelectorShape::vertical) {
            available.moveTop(available.y() + (available.height() - size)/2);
        } else if (m_type == KisVisualRectangleSelectorShape::horizontal) {
            available.moveLeft(available.x() + (available.width() - size)/2);
        }
        available.setSize(QSize(size, size));
    }
 
    return available;
}

References horizontal, m_barWidth, m_type, and vertical.

getMaskMap()

QRegion KisVisualRectangleSelectorShape::getMaskMap ( )

overrideprivatevirtual

getPixmap

Returns

the pixmap of this shape.

Implements KisVisualColorSelectorShape.

Definition at line 274 of file KisVisualRectangleSelectorShape.cpp.

{
    QRegion mask = QRegion(0,0,width(),height());
    if (m_type==KisVisualRectangleSelectorShape::border || m_type==KisVisualRectangleSelectorShape::borderMirrored) {
        mask = mask.subtracted(QRegion(m_barWidth, m_barWidth, width()-(m_barWidth*2), height()-(m_barWidth*2)));
    }
    return mask;
}

References border, borderMirrored, m_barWidth, and m_type.

getSpaceForCircle()

QRect KisVisualRectangleSelectorShape::getSpaceForCircle ( QRect geom )

overridevirtual

Implements KisVisualColorSelectorShape.

Definition at line 53 of file KisVisualRectangleSelectorShape.cpp.

{
    return getAvailableSpace(geom, false);
}

References getAvailableSpace().

getSpaceForSquare()

QRect KisVisualRectangleSelectorShape::getSpaceForSquare ( QRect geom )

overridevirtual

getSpaceForSquare

Parameters

geom	the full widget rectangle

Returns

rectangle with enough space for second widget

Implements KisVisualColorSelectorShape.

Definition at line 48 of file KisVisualRectangleSelectorShape.cpp.

{
    return getAvailableSpace(geom, true);
}

References getAvailableSpace().

getSpaceForTriangle()

QRect KisVisualRectangleSelectorShape::getSpaceForTriangle ( QRect geom )

overridevirtual

Implements KisVisualColorSelectorShape.

Definition at line 58 of file KisVisualRectangleSelectorShape.cpp.

{
    return getSpaceForSquare(geom);
}

References getSpaceForSquare().

renderAlphaMask()

QImage KisVisualRectangleSelectorShape::renderAlphaMask ( ) const

overrideprotectedvirtual

render the alpha mask for the widget background the returned image is expected to be QImage::Format_Alpha8

Reimplemented from KisVisualColorSelectorShape.

Definition at line 283 of file KisVisualRectangleSelectorShape.cpp.

{
    // Hi-DPI aware rendering requires that we determine the device pixel dimension;
    // actual widget size in device pixels is not accessible unfortunately, it might be 1px smaller...
    const int deviceWidth = qCeil(width() * devicePixelRatioF());
    const int deviceHeight = qCeil(height() * devicePixelRatioF());
 
    QImage alphaMask(deviceWidth, deviceHeight, QImage::Format_Alpha8);
    alphaMask.fill(0);
    alphaMask.setDevicePixelRatio(devicePixelRatioF());
    QPainter painter(&alphaMask);
    painter.setRenderHint(QPainter::Antialiasing);
    painter.setBrush(Qt::white);
    painter.setPen(Qt::NoPen);
 
    if (getDimensions() == onedimensional) {
        if (m_type == KisVisualRectangleSelectorShape::vertical) {
            painter.drawRect(2, 3, width() - 4, height() - 6);
        } else if (m_type == KisVisualRectangleSelectorShape::horizontal) {
            painter.drawRect(3, 2, width() - 6, height() - 4);
        } else /*if (m_type == border || m_type == borderMirrored)*/ {
            painter.drawRect(2, 2, width() - 4, height() - 4);
            painter.setBrush(Qt::black);
            painter.drawRect(m_barWidth, m_barWidth, width() - 2 * m_barWidth, height() - 2 * m_barWidth);
        }
    } else {
        painter.drawRect(3, 3, width() - 6, height() - 6);
    }
 
    return alphaMask;
}

References KisVisualColorSelectorShape::getDimensions(), horizontal, m_barWidth, m_type, KisVisualColorSelectorShape::onedimensional, and vertical.

setBorderWidth()

void KisVisualRectangleSelectorShape::setBorderWidth ( int width )

overridevirtual

setBorderWidth set the border of the single dimensional selector.

Parameters

width

Implements KisVisualColorSelectorShape.

Definition at line 34 of file KisVisualRectangleSelectorShape.cpp.

{
    m_barWidth = width;
}

References m_barWidth.

setOneDimensionalType()

void KisVisualRectangleSelectorShape::setOneDimensionalType

(

KisVisualRectangleSelectorShape::singelDTypes

type

)

Definition at line 39 of file KisVisualRectangleSelectorShape.cpp.

{
    if (type != m_type) {
        m_type = type;
        forceImageUpdate();
        update();
    }
}

References KisVisualColorSelectorShape::forceImageUpdate(), and m_type.

Member Data Documentation

m_barWidth

int KisVisualRectangleSelectorShape::m_barWidth

private

Definition at line 43 of file KisVisualRectangleSelectorShape.h.

m_type

singelDTypes KisVisualRectangleSelectorShape::m_type

private

Definition at line 42 of file KisVisualRectangleSelectorShape.h.

---

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

• libs/widgets/KisVisualRectangleSelectorShape.h
• libs/widgets/KisVisualRectangleSelectorShape.cpp