KisHandlePainterHelper Class Reference

The KisHandlePainterHelper class is a special helper for painting handles around objects. It ensures the handles are painted with the same size and line width whatever transformation is setup in the painter. The handles will also be rotated/skewed if the object itself has these transformations. More...

#include <KisHandlePainterHelper.h>

Public Member Functions
void	drawConnectionLine (const QLineF &line)
void	drawConnectionLine (const QPointF &p1, const QPointF &p2)
void	drawGradientArrow (const QPointF &start, const QPointF &end, qreal radius)
void	drawGradientCrossHandle (const QPointF &center, qreal radius)
void	drawGradientHandle (const QPointF &center)
void	drawGradientHandle (const QPointF &center, qreal radius)
void	drawHandleCircle (const QPointF &center)
void	drawHandleCircle (const QPointF &center, qreal radius)
void	drawHandleLine (const QLineF &line, qreal width=1.0, QVector< qreal > dashPattern={}, qreal dashOffset=0.0)
void	drawHandleRect (const QPointF &center)
void	drawHandleRect (const QPointF &center, qreal radius)
void	drawHandleRect (const QPointF &center, qreal radius, QPoint offset)
void	drawHandleSmallCircle (const QPointF &center)
void	drawPath (const QPainterPath &path)
void	drawPixmap (const QPixmap &pixmap, QPointF position, int size, QRectF sourceRect)
void	drawRubberLine (const QPolygonF &poly)
void	fillHandleRect (const QPointF &center, qreal radius, QColor fillColor, QPoint offset)
	KisHandlePainterHelper (KisHandlePainterHelper &&rhs)
	KisHandlePainterHelper (KisHandlePainterHelper &rhs)=delete
	KisHandlePainterHelper (QPainter *_painter, const QTransform &originalPainterTransform, qreal handleRadius, int decorationThickness=1)
	KisHandlePainterHelper (QPainter *_painter, qreal handleRadius=0.0, int decorationThickness=1)
void	setHandleStyle (const KisHandleStyle &style)
	~KisHandlePainterHelper ()

Private Member Functions
void	drawArrow (const QPointF &pos, const QPointF &from, qreal radius)
void	init ()

Private Attributes
KisAlgebra2D::DecomposedMatrix	m_decomposedMatrix
int	m_decorationThickness
QPolygonF	m_handlePolygon
qreal	m_handleRadius
KisHandleStyle	m_handleStyle
QTransform	m_handleTransform
QTransform	m_originalPainterTransform
QPainter *	m_painter
QTransform	m_painterTransform

Detailed Description

The KisHandlePainterHelper class is a special helper for painting handles around objects. It ensures the handles are painted with the same size and line width whatever transformation is setup in the painter. The handles will also be rotated/skewed if the object itself has these transformations.

On construction it resets QPainter transformation and on destruction recovers it back.

Please consider using KoShape::createHandlePainterHelper instead of direct construction of the helper. This factory method will also apply the transformations needed for a shape.

Definition at line 34 of file KisHandlePainterHelper.h.

Constructor & Destructor Documentation

KisHandlePainterHelper() [1/4]

KisHandlePainterHelper::KisHandlePainterHelper	(	QPainter *	_painter,
		qreal	handleRadius = 0.0,
		int	decorationThickness = 1 )

Creates the helper, initializes all the internal transformations and resets the transformation of the painter.

Definition at line 16 of file KisHandlePainterHelper.cpp.

    : m_painter(_painter),
      m_originalPainterTransform(m_painter->transform()),
      m_painterTransform(m_painter->transform()),
      m_handleRadius(handleRadius),
      m_decorationThickness(decorationThickness),
      m_decomposedMatrix(m_painterTransform)
{
    init();
}

References init().

KisHandlePainterHelper() [2/4]

KisHandlePainterHelper::KisHandlePainterHelper	(	QPainter *	_painter,
		const QTransform &	originalPainterTransform,
		qreal	handleRadius,
		int	decorationThickness = 1 )

Creates the helper, initializes all the internal transformations and resets the transformation of the painter. This override also adjusts the transformation of the painter into the coordinate system of the shape

Definition at line 27 of file KisHandlePainterHelper.cpp.

    : m_painter(_painter),
      m_originalPainterTransform(originalPainterTransform),
      m_painterTransform(m_painter->transform()),
      m_handleRadius(handleRadius),
      m_decorationThickness(decorationThickness),
      m_decomposedMatrix(m_painterTransform)
{
    init();
}

References init().

KisHandlePainterHelper() [3/4]

KisHandlePainterHelper::KisHandlePainterHelper

(

KisHandlePainterHelper &&

rhs

)

Move c-tor. Used to create and return the helper from functions by-value.

Definition at line 38 of file KisHandlePainterHelper.cpp.

    : m_painter(rhs.m_painter),
      m_originalPainterTransform(rhs.m_originalPainterTransform),
      m_painterTransform(rhs.m_painterTransform),
      m_handleRadius(rhs.m_handleRadius),
      m_decorationThickness(rhs.m_decorationThickness),
      m_decomposedMatrix(rhs.m_decomposedMatrix),
      m_handleTransform(rhs.m_handleTransform),
      m_handlePolygon(rhs.m_handlePolygon),
      m_handleStyle(rhs.m_handleStyle)
{
    // disable the source helper
    rhs.m_painter = 0;
}

KisHandlePainterHelper() [4/4]

KisHandlePainterHelper::KisHandlePainterHelper ( KisHandlePainterHelper & rhs )

delete

~KisHandlePainterHelper()

KisHandlePainterHelper::~KisHandlePainterHelper

(

)

Restores the transformation of the painter

Definition at line 66 of file KisHandlePainterHelper.cpp.

                                                {
    if (m_painter) {
        m_painter->setTransform(m_originalPainterTransform);
    }
}

References m_originalPainterTransform, and m_painter.

Member Function Documentation

drawArrow()

void KisHandlePainterHelper::drawArrow ( const QPointF & pos, const QPointF & from, qreal radius )

private

Draw a single arrow with the tip at position pos, directed from from, of size radius.

Definition at line 228 of file KisHandlePainterHelper.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_painter);
 
    QPainterPath p;
 
    QLineF line(pos, from);
    line.setLength(radius);
 
    QPointF norm = KisAlgebra2D::leftUnitNormal(pos - from);
    norm *= 0.34 * radius;
 
    p.moveTo(line.p2() + norm);
    p.lineTo(line.p1());
    p.lineTo(line.p2() - norm);
 
    p.translate(-pos);
 
    p = m_handleTransform.map(p).translated(m_painterTransform.map(pos));
 
    Q_FOREACH (KisHandleStyle::IterationStyle it, m_handleStyle.handleIterations) {
        it.stylePair.first.setWidthF(it.stylePair.first.widthF() * m_decorationThickness);
        PenBrushSaver saver(it.isValid ? m_painter : 0, it.stylePair, PenBrushSaver::allow_noop);
        m_painter->drawPath(p);
    }
}

References KisHandleStyle::handleIterations, KisHandleStyle::IterationStyle::isValid, KIS_SAFE_ASSERT_RECOVER_RETURN, KisAlgebra2D::leftUnitNormal(), m_decorationThickness, m_handleStyle, m_handleTransform, m_painter, m_painterTransform, p, and KisHandleStyle::IterationStyle::stylePair.

drawConnectionLine() [1/2]

void KisHandlePainterHelper::drawConnectionLine

(

const QLineF &

line

)

Draw a line connecting two points

Definition at line 293 of file KisHandlePainterHelper.cpp.

{
    drawConnectionLine(line.p1(), line.p2());
}

References drawConnectionLine().

drawConnectionLine() [2/2]

void KisHandlePainterHelper::drawConnectionLine	(	const QPointF &	p1,
		const QPointF &	p2 )

Draw a line connecting two points

Definition at line 298 of file KisHandlePainterHelper.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_painter);
 
    QPointF realP1 = m_painterTransform.map(p1);
    QPointF realP2 = m_painterTransform.map(p2);
 
    Q_FOREACH (KisHandleStyle::IterationStyle it, m_handleStyle.lineIterations) {
        it.stylePair.first.setWidthF(it.stylePair.first.widthF() * m_decorationThickness);
        PenBrushSaver saver(it.isValid ? m_painter : 0, it.stylePair, PenBrushSaver::allow_noop);
        m_painter->drawLine(realP1, realP2);
    }
}

References KisHandleStyle::IterationStyle::isValid, KIS_SAFE_ASSERT_RECOVER_RETURN, KisHandleStyle::lineIterations, m_decorationThickness, m_handleStyle, m_painter, m_painterTransform, p1, p2, and KisHandleStyle::IterationStyle::stylePair.

drawGradientArrow()

void KisHandlePainterHelper::drawGradientArrow	(	const QPointF &	start,
		const QPointF &	end,
		qreal	radius )

Draw an arrow representing gradient position

Definition at line 255 of file KisHandlePainterHelper.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_painter);
 
    QPainterPath p;
    p.moveTo(start);
    p.lineTo(end);
    p = m_painterTransform.map(p);
 
    Q_FOREACH (KisHandleStyle::IterationStyle it, m_handleStyle.lineIterations) {
        it.stylePair.first.setWidthF(it.stylePair.first.widthF()*m_decorationThickness);
        PenBrushSaver saver(it.isValid ? m_painter : 0, it.stylePair, PenBrushSaver::allow_noop);
        m_painter->drawPath(p);
    }
 
    const qreal length = kisDistance(start, end);
    const QPointF diff = end - start;
 
    if (length > 5 * radius) {
        drawArrow(start + 0.33 * diff, start, radius);
        drawArrow(start + 0.66 * diff, start, radius);
    } else if (length > 3 * radius) {
        drawArrow(start + 0.5 * diff, start, radius);
    }
}

References drawArrow(), KisHandleStyle::IterationStyle::isValid, KIS_SAFE_ASSERT_RECOVER_RETURN, kisDistance(), length(), KisHandleStyle::lineIterations, m_decorationThickness, m_handleStyle, m_painter, m_painterTransform, p, and KisHandleStyle::IterationStyle::stylePair.

drawGradientCrossHandle()

void KisHandlePainterHelper::drawGradientCrossHandle	(	const QPointF &	center,
		qreal	radius )

Draw a special handle representing the center of the gradient

Definition at line 188 of file KisHandlePainterHelper.cpp.

                                                                                        {
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_painter);
 
    { // Draw a cross
        QPainterPath p;
        p.moveTo(-radius, -radius);
        p.lineTo(radius, radius);
        p.moveTo(radius, -radius);
        p.lineTo(-radius, radius);
 
        p = m_handleTransform.map(p);
        p.translate(m_painterTransform.map(center));
 
        Q_FOREACH (KisHandleStyle::IterationStyle it, m_handleStyle.handleIterations) {
            it.stylePair.first.setWidthF(it.stylePair.first.widthF() * m_decorationThickness);
            PenBrushSaver saver(it.isValid ? m_painter : 0, it.stylePair, PenBrushSaver::allow_noop);
            m_painter->drawPath(p);
        }
    }
 
    { // Draw a square
        const qreal halfRadius = 0.5 * radius;
 
        QPolygonF handlePolygon;
        handlePolygon << QPointF(-halfRadius, 0);
        handlePolygon << QPointF(0, halfRadius);
        handlePolygon << QPointF(halfRadius, 0);
        handlePolygon << QPointF(0, -halfRadius);
 
        handlePolygon = m_handleTransform.map(handlePolygon);
        handlePolygon.translate(m_painterTransform.map(center));
 
        Q_FOREACH (KisHandleStyle::IterationStyle it, m_handleStyle.handleIterations) {
            it.stylePair.first.setWidthF(it.stylePair.first.widthF() * m_decorationThickness);
            PenBrushSaver saver(it.isValid ? m_painter : 0, it.stylePair, PenBrushSaver::allow_noop);
            m_painter->drawPolygon(handlePolygon);
        }
    }
}

References KisHandleStyle::handleIterations, KisHandleStyle::IterationStyle::isValid, KIS_SAFE_ASSERT_RECOVER_RETURN, m_decorationThickness, m_handleStyle, m_handleTransform, m_painter, m_painterTransform, p, and KisHandleStyle::IterationStyle::stylePair.

drawGradientHandle() [1/2]

void KisHandlePainterHelper::drawGradientHandle

(

const QPointF &

center

)

Draw a rotated handle representing the gradient handle

Definition at line 183 of file KisHandlePainterHelper.cpp.

{
    drawGradientHandle(center, 1.41 * m_handleRadius);
}

References drawGradientHandle(), and m_handleRadius.

drawGradientHandle() [2/2]

void KisHandlePainterHelper::drawGradientHandle	(	const QPointF &	center,
		qreal	radius )

Draw a rotated handle representing the gradient handle

Definition at line 163 of file KisHandlePainterHelper.cpp.

                                                                                   {
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_painter);
 
    QPolygonF handlePolygon;
 
    handlePolygon << QPointF(-radius, 0);
    handlePolygon << QPointF(0, radius);
    handlePolygon << QPointF(radius, 0);
    handlePolygon << QPointF(0, -radius);
 
    handlePolygon = m_handleTransform.map(handlePolygon);
    handlePolygon.translate(m_painterTransform.map(center));
 
    Q_FOREACH (KisHandleStyle::IterationStyle it, m_handleStyle.handleIterations) {
        it.stylePair.first.setWidthF(it.stylePair.first.widthF() * m_decorationThickness);
        PenBrushSaver saver(it.isValid ? m_painter : 0, it.stylePair, PenBrushSaver::allow_noop);
        m_painter->drawPolygon(handlePolygon);
    }
}

References KisHandleStyle::handleIterations, KisHandleStyle::IterationStyle::isValid, KIS_SAFE_ASSERT_RECOVER_RETURN, m_decorationThickness, m_handleStyle, m_handleTransform, m_painter, m_painterTransform, and KisHandleStyle::IterationStyle::stylePair.

drawHandleCircle() [1/2]

void KisHandlePainterHelper::drawHandleCircle

(

const QPointF &

center

)

Optimized version of the drawing method for drawing handles of predefined size

Definition at line 117 of file KisHandlePainterHelper.cpp.

{
    drawHandleCircle(center, m_handleRadius);
}

References drawHandleCircle(), and m_handleRadius.

drawHandleCircle() [2/2]

void KisHandlePainterHelper::drawHandleCircle	(	const QPointF &	center,
		qreal	radius )

Draws a handle circle with a custom radius at position center

Definition at line 104 of file KisHandlePainterHelper.cpp.

                                                                                 {
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_painter);
 
    QRectF handleRect(-radius, -radius, 2 * radius, 2 * radius);
    handleRect.translate(m_painterTransform.map(center));
 
    Q_FOREACH (KisHandleStyle::IterationStyle it, m_handleStyle.handleIterations) {
        it.stylePair.first.setWidthF(it.stylePair.first.widthF() * m_decorationThickness);
        PenBrushSaver saver(it.isValid ? m_painter : 0, it.stylePair, PenBrushSaver::allow_noop);
        m_painter->drawEllipse(handleRect);
    }
}

References KisHandleStyle::handleIterations, KisHandleStyle::IterationStyle::isValid, KIS_SAFE_ASSERT_RECOVER_RETURN, m_decorationThickness, m_handleStyle, m_painter, m_painterTransform, and KisHandleStyle::IterationStyle::stylePair.

drawHandleLine()

void KisHandlePainterHelper::drawHandleLine	(	const QLineF &	line,
		qreal	width = 1.0,
		QVector< qreal >	dashPattern = {},
		qreal	dashOffset = 0.0 )

Draws a line in the style of a handle with width indicating the thickness.

Definition at line 127 of file KisHandlePainterHelper.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_painter);
 
    QPainterPath p;
    p.moveTo(m_painterTransform.map(line.p1()));
    p.lineTo(m_painterTransform.map(line.p2()));
    QPainterPathStroker s;
    s.setWidth(width);
    if (!dashPattern.isEmpty()) {
        s.setDashPattern(dashPattern);
        s.setDashOffset(dashOffset);
    }
    s.setCapStyle(Qt::RoundCap);
    s.setJoinStyle(Qt::RoundJoin);
    p = s.createStroke(p);
 
    Q_FOREACH (KisHandleStyle::IterationStyle it, m_handleStyle.handleIterations) {
        it.stylePair.first.setWidthF(it.stylePair.first.widthF() * m_decorationThickness);
        PenBrushSaver saver(it.isValid ? m_painter : 0, it.stylePair, PenBrushSaver::allow_noop);
        m_painter->strokePath(p, m_painter->pen());
        m_painter->fillPath(p, m_painter->brush());
    }
}

References KisHandleStyle::handleIterations, KisHandleStyle::IterationStyle::isValid, KIS_SAFE_ASSERT_RECOVER_RETURN, m_decorationThickness, m_handleStyle, m_painter, m_painterTransform, p, and KisHandleStyle::IterationStyle::stylePair.

drawHandleRect() [1/3]

void KisHandlePainterHelper::drawHandleRect

(

const QPointF &

center

)

Optimized version of the drawing method for drawing handles of predefined size

Definition at line 152 of file KisHandlePainterHelper.cpp.

                                                                 {
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_painter);
    QPolygonF paintingPolygon = m_handlePolygon.translated(m_painterTransform.map(center));
 
    Q_FOREACH (KisHandleStyle::IterationStyle it, m_handleStyle.handleIterations) {
        it.stylePair.first.setWidthF(it.stylePair.first.widthF() * m_decorationThickness);
        PenBrushSaver saver(it.isValid ? m_painter : 0, it.stylePair, PenBrushSaver::allow_noop);
        m_painter->drawPolygon(paintingPolygon);
    }
}

References KisHandleStyle::handleIterations, KisHandleStyle::IterationStyle::isValid, KIS_SAFE_ASSERT_RECOVER_RETURN, m_decorationThickness, m_handlePolygon, m_handleStyle, m_painter, m_painterTransform, and KisHandleStyle::IterationStyle::stylePair.

drawHandleRect() [2/3]

void KisHandlePainterHelper::drawHandleRect	(	const QPointF &	center,
		qreal	radius )

Draws a handle rect with a custom radius at position center

drawHandleRect() [3/3]

void KisHandlePainterHelper::drawHandleRect	(	const QPointF &	center,
		qreal	radius,
		QPoint	offset = QPoint(0,0) )

Definition at line 77 of file KisHandlePainterHelper.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_painter);
 
    QRectF handleRect(-radius, -radius, 2 * radius, 2 * radius);
    QPolygonF handlePolygon = m_handleTransform.map(QPolygonF(handleRect));
    handlePolygon.translate(m_painterTransform.map(center));
 
    handlePolygon.translate(offset);
 
    const QPen originalPen = m_painter->pen();
 
    // temporarily set the pen width to 2 to avoid pixel shifting dropping pixels the border
    QPen customPen = m_painter->pen();
    customPen.setCosmetic(true);
    customPen.setWidth(4);
    m_painter->setPen(customPen);
 
    Q_FOREACH (KisHandleStyle::IterationStyle it, m_handleStyle.handleIterations) {
        it.stylePair.first.setWidthF(it.stylePair.first.widthF() * m_decorationThickness);
        PenBrushSaver saver(it.isValid ? m_painter : 0, it.stylePair, PenBrushSaver::allow_noop);
        m_painter->drawPolygon(handlePolygon);
    }
 
    m_painter->setPen(originalPen);
}

References KisHandleStyle::handleIterations, KisHandleStyle::IterationStyle::isValid, KIS_SAFE_ASSERT_RECOVER_RETURN, m_decorationThickness, m_handleStyle, m_handleTransform, m_painter, m_painterTransform, and KisHandleStyle::IterationStyle::stylePair.

drawHandleSmallCircle()

void KisHandlePainterHelper::drawHandleSmallCircle

(

const QPointF &

center

)

Optimized version of the drawing method for drawing handles of predefined size

Definition at line 122 of file KisHandlePainterHelper.cpp.

{
    drawHandleCircle(center, 0.7 * m_handleRadius);
}

References drawHandleCircle(), and m_handleRadius.

drawPath()

void KisHandlePainterHelper::drawPath

(

const QPainterPath &

path

)

Draw an arbitrary path

Definition at line 312 of file KisHandlePainterHelper.cpp.

{
    const QPainterPath realPath = m_painterTransform.map(path);
 
    Q_FOREACH (KisHandleStyle::IterationStyle it, m_handleStyle.lineIterations) {
        it.stylePair.first.setWidthF(it.stylePair.first.widthF() * m_decorationThickness);
        PenBrushSaver saver(it.isValid ? m_painter : 0, it.stylePair, PenBrushSaver::allow_noop);
        m_painter->drawPath(realPath);
    }
}

References KisHandleStyle::IterationStyle::isValid, KisHandleStyle::lineIterations, m_decorationThickness, m_handleStyle, m_painter, m_painterTransform, and KisHandleStyle::IterationStyle::stylePair.

drawPixmap()

void KisHandlePainterHelper::drawPixmap	(	const QPixmap &	pixmap,
		QPointF	position,
		int	size,
		QRectF	sourceRect )

Draw an a given pixmap on the UI

Definition at line 323 of file KisHandlePainterHelper.cpp.

{
    QPointF handlePolygon = m_painterTransform.map(position);
 
    QPoint offsetPosition(0, 40);
    handlePolygon += offsetPosition;
 
    handlePolygon -= QPointF(size*0.5,size*0.5);
 
    m_painter->drawPixmap(QRect(handlePolygon.x(), handlePolygon.y(),
                                size, size),
                                pixmap,
                                sourceRect);
}

References m_painter, and m_painterTransform.

drawRubberLine()

void KisHandlePainterHelper::drawRubberLine

(

const QPolygonF &

poly

)

Draw a line showing the bounding box of the selection

Definition at line 281 of file KisHandlePainterHelper.cpp.

                                                                 {
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_painter);
 
    QPolygonF paintingPolygon = m_painterTransform.map(poly);
 
    Q_FOREACH (KisHandleStyle::IterationStyle it, m_handleStyle.lineIterations) {
        it.stylePair.first.setWidthF(it.stylePair.first.widthF() * m_decorationThickness);
        PenBrushSaver saver(it.isValid ? m_painter : 0, it.stylePair, PenBrushSaver::allow_noop);
        m_painter->drawPolygon(paintingPolygon);
    }
}

References KisHandleStyle::IterationStyle::isValid, KIS_SAFE_ASSERT_RECOVER_RETURN, KisHandleStyle::lineIterations, m_decorationThickness, m_handleStyle, m_painter, m_painterTransform, and KisHandleStyle::IterationStyle::stylePair.

fillHandleRect()

void KisHandlePainterHelper::fillHandleRect	(	const QPointF &	center,
		qreal	radius,
		QColor	fillColor,
		QPoint	offset = QPoint(0,0) )

Definition at line 338 of file KisHandlePainterHelper.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_painter);
 
    QRectF handleRect(-radius, -radius, 2 * radius, 2 * radius);
    QPolygonF handlePolygon = m_handleTransform.map(QPolygonF(handleRect));
    handlePolygon.translate(m_painterTransform.map(center));
 
    QPainterPath painterPath;
    painterPath.addPolygon(handlePolygon);
 
    // offset that happens after zoom transform. This means the offset will be the same, no matter the zoom level
    // this is good for UI elements that need to be below the bounding box
    painterPath.translate(offset);
 
    const QPainterPath pathToSend = painterPath;
    const QBrush brushStyle(fillColor);
    m_painter->fillPath(pathToSend, brushStyle);
}

References KIS_SAFE_ASSERT_RECOVER_RETURN, m_handleTransform, m_painter, and m_painterTransform.

init()

void KisHandlePainterHelper::init ( )

private

Definition at line 53 of file KisHandlePainterHelper.cpp.

{
    m_handleStyle = KisHandleStyle::inheritStyle();
 
    m_painter->setTransform(QTransform());
    m_handleTransform = m_decomposedMatrix.shearTransform() * m_decomposedMatrix.rotateTransform();
 
    if (m_handleRadius > 0.0) {
        const QRectF handleRect(-m_handleRadius, -m_handleRadius, 2 * m_handleRadius, 2 * m_handleRadius);
        m_handlePolygon = m_handleTransform.map(QPolygonF(handleRect));
    }
}

References KisHandleStyle::inheritStyle(), m_decomposedMatrix, m_handlePolygon, m_handleRadius, m_handleStyle, m_handleTransform, m_painter, KisAlgebra2D::DecomposedMatrix::rotateTransform(), and KisAlgebra2D::DecomposedMatrix::shearTransform().

setHandleStyle()

void KisHandlePainterHelper::setHandleStyle

(

const KisHandleStyle &

style

)

Sets style used for painting the handles. Please use static methods of KisHandleStyle to select predefined styles.

Definition at line 72 of file KisHandlePainterHelper.cpp.

{
    m_handleStyle = style;
}

References m_handleStyle.

Member Data Documentation

m_decomposedMatrix

KisAlgebra2D::DecomposedMatrix KisHandlePainterHelper::m_decomposedMatrix

private

Definition at line 164 of file KisHandlePainterHelper.h.

m_decorationThickness

int KisHandlePainterHelper::m_decorationThickness

private

Definition at line 163 of file KisHandlePainterHelper.h.

m_handlePolygon

QPolygonF KisHandlePainterHelper::m_handlePolygon

private

Definition at line 166 of file KisHandlePainterHelper.h.

m_handleRadius

qreal KisHandlePainterHelper::m_handleRadius

private

Definition at line 162 of file KisHandlePainterHelper.h.

m_handleStyle

KisHandleStyle KisHandlePainterHelper::m_handleStyle

private

Definition at line 167 of file KisHandlePainterHelper.h.

m_handleTransform

QTransform KisHandlePainterHelper::m_handleTransform

private

Definition at line 165 of file KisHandlePainterHelper.h.

m_originalPainterTransform

QTransform KisHandlePainterHelper::m_originalPainterTransform

private

Definition at line 160 of file KisHandlePainterHelper.h.

m_painter

QPainter* KisHandlePainterHelper::m_painter

private

Definition at line 159 of file KisHandlePainterHelper.h.

m_painterTransform

QTransform KisHandlePainterHelper::m_painterTransform

private

Definition at line 161 of file KisHandlePainterHelper.h.

---

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

• libs/global/KisHandlePainterHelper.h
• libs/global/KisHandlePainterHelper.cpp