KisGridDecoration Class Reference

#include <kis_grid_decoration.h>

Inheritance diagram for KisGridDecoration:

Classes
struct	Private

Public Member Functions
	KisGridDecoration (KisView *parent)
void	setGridConfig (const KisGridConfig &config)
	~KisGridDecoration () override
Public Member Functions inherited from KisCanvasDecoration
const QString &	id () const
	KisCanvasDecoration (const QString &id, QPointer< KisView >parent)
virtual void	notifyWindowMinimized (bool minimized)
void	paint (QPainter &gc, const QRectF &updateRect, const KisCoordinatesConverter *converter, KisCanvas2 *canvas)
int	priority () const
void	setView (QPointer< KisView > imageView)
bool	visible () const
	~KisCanvasDecoration () override
Public Member Functions inherited from KisShared
bool	deref ()
bool	ref ()
int	refCount ()
QAtomicInt *	sharedWeakReference ()

Protected Member Functions
void	drawDecoration (QPainter &gc, const QRectF &updateArea, const KisCoordinatesConverter *converter, KisCanvas2 *canvas) override
Protected Member Functions inherited from KisCanvasDecoration
int	decorationThickness () const
void	setPriority (int value)
QPointer< KisView >	view () const
Protected Member Functions inherited from KisShared
	KisShared ()
	~KisShared ()

Private Attributes
const QScopedPointer< Private >	m_d

Additional Inherited Members
Public Slots inherited from KisCanvasDecoration
virtual void	setVisible (bool v)
void	toggleVisibility ()
Static Public Member Functions inherited from KisCanvasDecoration
static bool	comparePriority (KisCanvasDecorationSP decoration1, KisCanvasDecorationSP decoration2)

Detailed Description

Definition at line 19 of file kis_grid_decoration.h.

Constructor & Destructor Documentation

KisGridDecoration()

KisGridDecoration::KisGridDecoration

(

KisView *

parent

)

Definition at line 27 of file kis_grid_decoration.cpp.

    : KisCanvasDecoration("grid", parent),
      m_d(new Private)
{
    setPriority(0);
}

References KisCanvasDecoration::setPriority().

~KisGridDecoration()

KisGridDecoration::~KisGridDecoration ( )

override

Definition at line 34 of file kis_grid_decoration.cpp.

{
 
}

Member Function Documentation

drawDecoration()

void KisGridDecoration::drawDecoration ( QPainter & gc, const QRectF & updateArea, const KisCoordinatesConverter * converter, KisCanvas2 * canvas )

overrideprotectedvirtual

Implements KisCanvasDecoration.

Definition at line 44 of file kis_grid_decoration.cpp.

{
    if (!m_d->config.showGrid()) return;
 
    Q_UNUSED(canvas);
 
    QTransform transform = converter->imageToWidgetTransform();
 
    const qreal scale = KoUnit::approxTransformScale(transform);
    const int minWidgetSize = 3;
    const int effectiveSize = qMin(m_d->config.spacing().x(), m_d->config.spacing().y());
 
    int scaleCoeff = 1;
    quint32 subdivision = m_d->config.subdivision();
 
    while (qFloor(scale * scaleCoeff * effectiveSize) <= minWidgetSize) {
        if (subdivision > 1) {
            scaleCoeff = subdivision;
            subdivision = 1;
        } else {
            scaleCoeff *= 2;
        }
 
        if (scaleCoeff > 32768) {
            qWarning() << "WARNING: Grid Scale Coeff is too high! That is surely a bug!";
            return;
        }
    }
 
    QPen mainPen = m_d->config.penMain();
    QPen subdivisionPen = m_d->config.penSubdivision();
 
    gc.save();
    gc.setTransform(transform);
 
    const QRect imageRectInImagePixels = converter->imageRectInImagePixels();
    const QRectF updateRectInImagePixels =
        converter->documentToImage(updateArea) &
        imageRectInImagePixels;
 
    // for angles. This will later be a combobox to select different types of options
    // also add options to hide specific lines (vertical, horizontal, angle 1, etc
    KisGridConfig::GridType gridType = m_d->config.gridType();
 
    if (gridType == KisGridConfig::GRID_RECTANGULAR) {
        gc.setRenderHints(QPainter::Antialiasing, false);
        qreal x1, y1, x2, y2;
        updateRectInImagePixels.getCoords(&x1, &y1, &x2, &y2);
 
        // compensate the fact the getCoordt returns off-by-one pixel
        // at the bottom right of the rect.
        x2++;
        y2++;
 
        if (m_d->config.xSpacingActive()) {
            // vertical lines
            int offset = 0;
            if (m_d->config.offsetActive()) {
                offset = m_d->config.offset().x();
            }
            const int step = scaleCoeff * m_d->config.spacing().x();
            const int lineIndexFirst = qCeil((x1 - offset) / step);
            const int lineIndexLast = qFloor((x2 - offset) / step);
 
            if (mainPen.style() != Qt::SolidLine) {
                mainPen.setDashOffset(y1 * scale);
            }
            if (subdivisionPen.style() != Qt::SolidLine) {
                subdivisionPen.setDashOffset(y1 * scale);
            }
 
            for (int i = lineIndexFirst; i <= lineIndexLast; i++) {
                int w = offset + i * step;
 
                gc.setPen(i % subdivision == 0 ? mainPen : subdivisionPen);
                // we adjusted y2 to draw the grid correctly, clip it now...
                gc.drawLine(QPointF(w, y1),QPointF(w, qMin(y2, qreal(imageRectInImagePixels.bottom() + 1))));
            }
        }
 
        if (m_d->config.ySpacingActive()) {
            // horizontal lines
            int offset = 0;
            if (m_d->config.offsetActive()) {
                offset = m_d->config.offset().y();
            }
            const int step = scaleCoeff * m_d->config.spacing().y();
            const int lineIndexFirst = qCeil((y1 - offset) / step);
            const int lineIndexLast = qFloor((y2 - offset) / step);
 
            if (mainPen.style() != Qt::SolidLine) {
                mainPen.setDashOffset(x1 * scale);
            }
            if (subdivisionPen.style() != Qt::SolidLine) {
                subdivisionPen.setDashOffset(x1 * scale);
            }
 
            for (int i = lineIndexFirst; i <= lineIndexLast; i++) {
                int w = offset + i * step;
 
                gc.setPen(i % subdivision == 0 ? mainPen : subdivisionPen);
                // we adjusted x2 to draw the grid correctly, clip it now...
                gc.drawLine(QPointF(x1, w),QPointF(qMin(x2, qreal(imageRectInImagePixels.right() + 1)), w));
            }
        }
    } else if (gridType == KisGridConfig::GRID_ISOMETRIC_LEGACY)  {
        qreal x1, y1, x2, y2;
 
        // get true coordinates, not just the updateArea
        QRectF trueImageRect = converter->imageRectInImagePixels();
        trueImageRect.getCoords(&x1, &y1, &x2, &y2);
 
        // compensate the fact the getCoordt returns off-by-one pixel
        // at the bottom right of the rect.
        x2++;
        y2++;
 
        int offset = 0;
        int offsetY = 0;
        if (m_d->config.offsetActive()) {
            offset = m_d->config.offset().x();
            offsetY = m_d->config.offset().y();
        }
        const int cellSpacing = m_d->config.cellSpacing();
 
        gc.setClipping(true);
        gc.setClipRect(updateRectInImagePixels, Qt::IntersectClip);
 
        // left angle
        if (m_d->config.angleLeftActive()) {
            const qreal gridXAngle = m_d->config.angleLeft();
            const qreal bottomRightOfImageY = y2; // this should be the height of the image
            qreal finalY = 0.0;
 
            // figure out the spacing based off the angle. The spacing needs to be perpendicular to the angle,
            // so we need to do a bit of trig to get the correct spacing.
            qreal correctedAngleSpacing = cellSpacing;
            if (gridXAngle > 0.0) {
                correctedAngleSpacing = cellSpacing / qCos(qDegreesToRadians(gridXAngle));
                gc.setRenderHints(QPainter::Antialiasing, true);
            } else {
                // horizontal line: don't want to be antialiased
                gc.setRenderHints(QPainter::Antialiasing, false);
            }
 
            qreal counter = qFloor((-(offset + offsetY)) / correctedAngleSpacing);
 
            while (finalY < bottomRightOfImageY) {
 
                const qreal w = (counter * correctedAngleSpacing) + offsetY + offset;
                gc.setPen(mainPen);
 
                // calculate where the ending point will be based off the angle
                const qreal startingY = w;
                const qreal horizontalDistance = x2;
 
                // qTan takes radians, so convert first before sending it
                const qreal length2 = qTan(qDegreesToRadians(gridXAngle)) * x2;
 
                finalY = startingY - length2;
 
                gc.drawLine(QPointF(x1, w), QPointF(horizontalDistance, finalY));
 
                counter = counter + 1.0;
            }
        }
 
        // right angle (almost the same thing, except starting the lines on the right side)
        if (m_d->config.angleRightActive()) {
            const qreal gridXAngle = m_d->config.angleRight(); // TODO: add another angle property
            const qreal bottomLeftOfImageY = y2;
 
            // figure out the spacing based off the angle
            qreal correctedAngleSpacing = cellSpacing;
            if (gridXAngle > 0.0) {
                correctedAngleSpacing = cellSpacing / qCos(qDegreesToRadians(gridXAngle));
                gc.setRenderHints(QPainter::Antialiasing, true);
            } else {
                // horizontal line: don't want to be antialiased
                gc.setRenderHints(QPainter::Antialiasing, false);
            }
 
            // distance is the same (width of the image)
            const qreal horizontalDistance = x2;
            // qTan takes radians, so convert first before sending it
            const qreal length2 = qTan(qDegreesToRadians(gridXAngle)) * horizontalDistance;
 
            // let's get x, y of the line that starts in the top right corder
            const qreal yLower = 0.0;
            const qreal yHigher = yLower - length2;
 
            const qreal yLeftFirst = qCeil(yHigher / correctedAngleSpacing) * correctedAngleSpacing;
            const qreal additionalOffset = yLeftFirst - yHigher;
            qreal finalY = 0.0;
            qreal counter = qFloor((-(offsetY - offset)) / correctedAngleSpacing);
 
            while (finalY < bottomLeftOfImageY) {
 
                const qreal w = (counter * correctedAngleSpacing) + offsetY - offset + additionalOffset;
                gc.setPen(mainPen);
 
                // calculate where the ending point will be based off the angle
                const qreal startingY = w;
 
                finalY = startingY - length2;
 
                gc.drawLine(QPointF(x2, w), QPointF(0.0, finalY));
 
                counter = counter + 1.0;
            }
        }
    } else if (gridType == KisGridConfig::GRID_ISOMETRIC)  {
        qreal x1, y1, xRight, yBottom;
 
        // get true coordinates, not just the updateArea
        QRectF trueImageRect = converter->imageRectInImagePixels();
        trueImageRect.getCoords(&x1, &y1, &xRight, &yBottom);
 
        // compensate the fact the getCoordt returns off-by-one pixel
        // at the bottom right of the rect.
        xRight++;
        yBottom++;
 
        const KisGridConfig::TrigoCache trigoCache = m_d->config.trigoCache();
 
        int offsetX = 0;
        int offsetY = 0;
        if (m_d->config.offsetActive()) {
            offsetX = trigoCache.correctedAngleRightOffsetX;
            offsetY = m_d->config.offset().y();
        }
 
        gc.setClipping(true);
        gc.setClipRect(updateRectInImagePixels, Qt::IntersectClip);
 
        // left angle
        if (trigoCache.correctedAngleLeftCellSize > 0 && m_d->config.angleLeftActive()) {
            if (m_d->config.angleLeft() > 0.0) {
                gc.setRenderHints(QPainter::Antialiasing, true);
            } else {
                // horizontal line: don't want to be antialiased
                gc.setRenderHints(QPainter::Antialiasing, false);
            }
 
            const qreal length2 = trigoCache.tanAngleLeft * xRight;
 
            // let's get x, y of the line that starts in the top right corner
            const qreal yLower = 0.0;
            const qreal yHigher = yLower - length2;
 
            const qreal yLeftFirst = qCeil(yHigher / trigoCache.correctedAngleLeftCellSize) * trigoCache.correctedAngleLeftCellSize;
            const qreal additionalOffset = yLeftFirst - yHigher;
 
            qreal finalY = 0.0;
 
            // define line number used to determinate if is a subdivision or not
            int subdivisionIndex = qCeil(yHigher / trigoCache.correctedAngleLeftCellSize);
 
            qreal startingY = yLeftFirst + offsetY + offsetX + additionalOffset;
 
            while (finalY < yBottom) {
                // calculate where the ending point will be based off the angle
                finalY = startingY - length2;
 
                gc.setPen(qAbs(subdivisionIndex) % subdivision == 0 ? mainPen : subdivisionPen);
                gc.drawLine(QPointF(0.0, startingY), QPointF(xRight, finalY));
 
                subdivisionIndex++;
                startingY += trigoCache.correctedAngleLeftCellSize;
            }
        }
 
        // right angle (almost the same thing, except starting the lines on the right side)
        if (trigoCache.correctedAngleRightCellSize > 0 && m_d->config.angleRightActive()) {
            if (m_d->config.angleRight() > 0.0) {
                gc.setRenderHints(QPainter::Antialiasing, true);
            } else {
                // horizontal line: don't want to be antialiased
                gc.setRenderHints(QPainter::Antialiasing, false);
            }
 
            const qreal length2 = trigoCache.tanAngleRight * xRight;
 
            // let's get x, y of the line that starts in the top right corner
            const qreal yLower = 0.0;
            const qreal yHigher = yLower - length2;
 
            const qreal yLeftFirst = qCeil(yHigher / trigoCache.correctedAngleRightCellSize) * trigoCache.correctedAngleRightCellSize;
            const qreal additionalOffset = yLeftFirst - yHigher;
 
            qreal finalY = 0.0;
 
            // define line number used to determinate if is a subdivision or not
            int subdivisionIndex = qCeil(yHigher / trigoCache.correctedAngleRightCellSize);
 
            qreal startingY = yLeftFirst + offsetY - offsetX + additionalOffset;
 
            while (finalY < yBottom) {
                // calculate where the ending point will be based off the angle
                finalY = startingY - length2;
 
                gc.setPen(qAbs(subdivisionIndex) % subdivision == 0 ? mainPen : subdivisionPen);
                gc.drawLine(QPointF(xRight, startingY), QPointF(0.0, finalY));
 
                subdivisionIndex++;
                startingY += trigoCache.correctedAngleRightCellSize;
            }
        }
 
        // vertical
        if (trigoCache.verticalSpace > 0) {
            QPen verticalPen = m_d->config.penVertical();
            if (verticalPen.style() != Qt::SolidLine) {
                verticalPen.setDashOffset(updateRectInImagePixels.top() * scale);
            }
            gc.setPen(verticalPen);
            gc.setRenderHints(QPainter::Antialiasing, false);
 
            int offset = 0;
            if (m_d->config.offsetActive()) {
                offset = m_d->config.offset().x();
            }
 
            qreal pX = (xRight - x1)/(2*trigoCache.verticalSpace);
            pX = offset + (pX - qFloor(pX)) * trigoCache.verticalSpace;
            pX = pX - trigoCache.verticalSpace * qFloor(pX/trigoCache.verticalSpace);
 
            while(pX <= updateRectInImagePixels.right()) {
                if (pX > updateRectInImagePixels.left()) {
                    gc.drawLine(QPointF(pX, updateRectInImagePixels.top()),QPointF(pX, qMin(yBottom, qreal(updateRectInImagePixels.bottom() + 1))));
                }
                pX += trigoCache.verticalSpace;
            }
        }
    }
 
    gc.restore();
}

References KoUnit::approxTransformScale(), KisGridConfig::TrigoCache::correctedAngleLeftCellSize, KisGridConfig::TrigoCache::correctedAngleRightCellSize, KisGridConfig::TrigoCache::correctedAngleRightOffsetX, KisCoordinatesConverter::documentToImage(), KisGridConfig::GRID_ISOMETRIC, KisGridConfig::GRID_ISOMETRIC_LEGACY, KisGridConfig::GRID_RECTANGULAR, KisCoordinatesConverter::imageRectInImagePixels(), KisCoordinatesConverter::imageToWidgetTransform(), m_d, KisGridConfig::TrigoCache::tanAngleLeft, KisGridConfig::TrigoCache::tanAngleRight, and KisGridConfig::TrigoCache::verticalSpace.

setGridConfig()

void KisGridDecoration::setGridConfig

(

const KisGridConfig &

config

)

Definition at line 39 of file kis_grid_decoration.cpp.

{
    m_d->config = config;
}

References m_d.

Member Data Documentation

m_d

const QScopedPointer<Private> KisGridDecoration::m_d

private

Definition at line 33 of file kis_grid_decoration.h.

---

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

• libs/ui/canvas/kis_grid_decoration.h
• libs/ui/canvas/kis_grid_decoration.cpp