VerticalPaintingStrategy Class Reference

#include <KoRuler_p.h>

Inheritance diagram for VerticalPaintingStrategy:

Public Member Functions
QRectF	drawBackground (const KoRulerPrivate *ruler, QPainter &painter) override
void	drawIndents (const KoRulerPrivate *, QPainter &) override
void	drawMeasurements (const KoRulerPrivate *ruler, QPainter &painter, const QRectF &rectangle) override
void	drawTabs (const KoRulerPrivate *, QPainter &) override
QSize	sizeHint () override
	VerticalPaintingStrategy ()
Public Member Functions inherited from PaintingStrategy
	PaintingStrategy ()
	constructor
virtual	~PaintingStrategy ()
	destructor

Private Attributes
qreal	lengthInPixel {0.0}

Detailed Description

Definition at line 86 of file KoRuler_p.h.

Constructor & Destructor Documentation

VerticalPaintingStrategy()

VerticalPaintingStrategy::VerticalPaintingStrategy ( )

inline

Definition at line 89 of file KoRuler_p.h.

: lengthInPixel(1) {}

Member Function Documentation

drawBackground()

QRectF VerticalPaintingStrategy::drawBackground ( const KoRulerPrivate * ruler, QPainter & painter )

overridevirtual

Draw the background of the ruler.

Parameters

ruler	the ruler to draw on.
painter	the painter we can paint with.

Implements PaintingStrategy.

Definition at line 436 of file KoRuler.cpp.

{
    lengthInPixel = d->viewConverter->documentToViewY(d->rulerLength);
    QRectF rectangle;
    rectangle.setX(0);
    rectangle.setY(qMax(0, d->offset));
    rectangle.setWidth(d->ruler->width() - 1.0);
    rectangle.setHeight(qMin(qreal(d->ruler->height() - 1.0 - rectangle.y()),
                             (d->offset >= 0) ? lengthInPixel : lengthInPixel + d->offset));
 
    QRectF activeRangeRectangle;
    activeRangeRectangle.setX(rectangle.x() + 1);
    activeRangeRectangle.setY(qMax(rectangle.y() + 1,
        d->viewConverter->documentToViewY(d->effectiveActiveRangeStart()) + d->offset));
    activeRangeRectangle.setWidth(rectangle.width() - 2);
    activeRangeRectangle.setBottom(qMin(rectangle.bottom() - 1,
        d->viewConverter->documentToViewY(d->effectiveActiveRangeEnd()) + d->offset));
 
    painter.setPen(QPen(d->ruler->palette().color(QPalette::Mid), 0));
 
    painter.fillRect(rectangle,d->ruler->palette().color(QPalette::AlternateBase));
    painter.drawRect(rectangle);
 
    if(d->effectiveActiveRangeStart() != d->effectiveActiveRangeEnd())
        painter.fillRect(activeRangeRectangle, d->ruler->palette().brush(QPalette::Base));
 
    if(d->showSelectionBorders) {
        // Draw first selection border
        if(d->firstSelectionBorder > 0) {
            qreal border = d->viewConverter->documentToViewY(d->firstSelectionBorder) + d->offset;
            painter.drawLine(QPointF(rectangle.x() + 1, border), QPointF(rectangle.right() - 1, border));
        }
        // Draw second selection border
        if(d->secondSelectionBorder > 0) {
            qreal border = d->viewConverter->documentToViewY(d->secondSelectionBorder) + d->offset;
            painter.drawLine(QPointF(rectangle.x() + 1, border), QPointF(rectangle.right() - 1, border));
        }
    }
 
    return rectangle;
}

References lengthInPixel.

drawIndents()

void VerticalPaintingStrategy::drawIndents ( const KoRulerPrivate * ruler, QPainter & painter )

inlineoverridevirtual

Draw the indicators for the indents of a text paragraph

Parameters

ruler	the ruler to draw on.
painter	the painter we can paint with.

Implements PaintingStrategy.

Definition at line 94 of file KoRuler_p.h.

{ }

drawMeasurements()

void VerticalPaintingStrategy::drawMeasurements ( const KoRulerPrivate * ruler, QPainter & painter, const QRectF & rectangle )

overridevirtual

Draw the indicators for the measurements which typically are drawn every [unit].

Parameters

ruler	the ruler to draw on.
painter	the painter we can paint with.
rectangle

Implements PaintingStrategy.

Definition at line 478 of file KoRuler.cpp.

{
    const QFont font = QFontDatabase::systemFont(QFontDatabase::SmallestReadableFont);
    const QFontMetrics fontMetrics(font);
    const QPen numberPen(d->ruler->palette().color(QPalette::Text), 0);
    const QPen markerPen(d->ruler->palette().color(QPalette::Inactive, QPalette::Text), 0);
    painter.setPen(markerPen);
    painter.setFont(font);
 
    // length of the ruler in pixels
    const int rulerLengthPixel = d->viewConverter->documentToViewY(d->rulerLength);
    // length of the ruler in the chosen unit
    const qreal rulerLengthUnit = d->unit.toUserValue(d->rulerLength);
    // length of a unit in pixels
    const qreal unitLength = d->viewConverter->documentToViewY(d->unit.fromUserValue(1.0));
    // length of the text for longest number with some padding
     const int textLength = fontMetrics.horizontalAdvance(QString::number(qCeil(rulerLengthUnit))) + 20;
 
    // the minimal separation of numbers that won't make the text a mess
    const qreal minimalNumberSeparation = qCeil(textLength / unitLength);
    // the chosen separation of numbers so that we have "whole" numbers
    qreal numberSeparation = minimalNumberSeparation;
    if (minimalNumberSeparation <= 5) {
    } else if (minimalNumberSeparation <= 10) {
        numberSeparation = 10;
    } else if (minimalNumberSeparation <= 20) {
        numberSeparation = 20;
    } else if (minimalNumberSeparation <= 50) {
        numberSeparation = 50;
    } else if (minimalNumberSeparation <= 100) {
        numberSeparation = 100;
    } else if (minimalNumberSeparation <= 200) {
        numberSeparation = 200;
    } else if (minimalNumberSeparation <= 500) {
        numberSeparation = 500;
    } else {
        numberSeparation = qRound(qreal(numberSeparation / 100.0)) * 100;
    }
    // the chosen separation converted to pixel
    const int pixelSeparation = qRound(d->viewConverter->documentToViewY(d->unit.fromUserValue(numberSeparation)));
 
    // Draw the marks
    const int rulerEnd = rulerLengthPixel + d->offset;
    qreal numberStart = d->unit.toUserValue(d->viewConverter->viewToDocumentY(
                rectangle.top() - d->offset));
    // draw the partly hidden mark when the bottom part of the ruler is
    // invisible
    int pixelEnd = rectangle.bottom() - d->offset;
    if (rulerEnd - textLength > rectangle.bottom()) {
        pixelEnd += textLength;
    }
    qreal numberEnd = d->unit.toUserValue(d->viewConverter->viewToDocumentX(
                pixelEnd));
    if (d->offset < 0) {
        numberStart -= fmod(numberStart, numberSeparation);
    }
    for(qreal n = numberStart; n < numberEnd; n += numberSeparation) {
        int posOnRuler = qRound(d->viewConverter->documentToViewY(d->unit.fromUserValue(n)));
        int y = d->offset + posOnRuler;
 
        // to draw the primary mark
        QString numberText = QString::number(n);
        painter.save();
        painter.translate(rectangle.right() - fullStepMarkerLength, y);
        painter.drawLine(QPointF(0, 0),
                QPointF(rectangle.right() - fullStepMarkerLength, 0));
        painter.setPen(numberPen);
        painter.rotate(-90);
        painter.drawText(QPointF(-fontMetrics.horizontalAdvance(numberText) / 2.0, 0),
                numberText);
        painter.restore();
 
        // start to draw secondary marks following the primary mark
        painter.setPen(markerPen);
 
        int yQuarterMark1 = qRound(qreal(y + pixelSeparation / 4.0));
        if (yQuarterMark1 > rulerEnd)
            break;
        painter.drawLine(QPointF(rectangle.right() - 1, yQuarterMark1),
                QPointF(rectangle.right() - quarterStepMarkerLength, yQuarterMark1));
 
        int yHalfMark = qRound(qreal(y + pixelSeparation / 2.0));
        if (yHalfMark > rulerEnd)
            break;
        painter.drawLine(QPointF(rectangle.right() - 1, yHalfMark),
                QPointF(rectangle.right() - halfStepMarkerLength, yHalfMark));
 
        int yQuarterMark2 = qRound(qreal(y + 3.0 * pixelSeparation / 4.0));
        if (yQuarterMark2 > rulerEnd)
            break;
        painter.drawLine(QPointF(rectangle.right() - 1, yQuarterMark2),
                QPointF(rectangle.right() - quarterStepMarkerLength, yQuarterMark2));
    }
 
    // Draw the mouse indicator
    const int mouseCoord = d->mouseCoordinate + d->offset;
    if (d->selected == KoRulerPrivate::None || d->selected == KoRulerPrivate::HotSpot) {
        const qreal left = rectangle.left() + 1;
        const qreal right = rectangle.right() -1;
        if (d->selected == KoRulerPrivate::None
                && d->showMousePosition
                && d->mouseCoordinate > 0
                && d->mouseCoordinate < rulerLengthPixel)
            painter.drawLine(QPointF(left, mouseCoord), QPointF(right, mouseCoord));
        foreach (const KoRulerPrivate::HotSpotData & hp, d->hotspots) {
            const qreal y = d->viewConverter->documentToViewY(hp.position) + d->offset;
            painter.drawLine(QPointF(left, y), QPointF(right, y));
        }
    }
}

References fullStepMarkerLength, halfStepMarkerLength, KoRulerPrivate::HotSpot, KoRulerPrivate::None, KoRulerPrivate::HotSpotData::position, and quarterStepMarkerLength.

drawTabs()

void VerticalPaintingStrategy::drawTabs ( const KoRulerPrivate * ruler, QPainter & painter )

inlineoverridevirtual

Draw the indicators for text-tabs.

Parameters

ruler	the ruler to draw on.
painter	the painter we can paint with.

Implements PaintingStrategy.

Definition at line 92 of file KoRuler_p.h.

{}

sizeHint()

QSize VerticalPaintingStrategy::sizeHint ( )

overridevirtual

returns the size suggestion for a ruler with this strategy.

Implements PaintingStrategy.

Definition at line 589 of file KoRuler.cpp.

{
    // assumes that digits for the number only use glyphs which do not go below the baseline
    const QFontMetrics fm(QFontDatabase::systemFont(QFontDatabase::SmallestReadableFont));
    const int digitsHeight = fm.ascent() + 1; // +1 for baseline
    const int minimum = digitsHeight + fullStepMarkerLength + 2*measurementTextAboveBelowMargin;
 
    return QSize(minimum, 0);
}

References fullStepMarkerLength, and measurementTextAboveBelowMargin.

Member Data Documentation

lengthInPixel

qreal VerticalPaintingStrategy::lengthInPixel {0.0}

private

Definition at line 98 of file KoRuler_p.h.

{0.0};

---

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

• libs/widgets/KoRuler_p.h
• libs/widgets/KoRuler.cpp