HorizontalPaintingStrategy Class Reference

#include <KoRuler_p.h>

Inheritance diagram for HorizontalPaintingStrategy:

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

Private Attributes
qreal	lengthInPixel {0.0}

Detailed Description

Definition at line 71 of file KoRuler_p.h.

Constructor & Destructor Documentation

HorizontalPaintingStrategy()

HorizontalPaintingStrategy::HorizontalPaintingStrategy ( )

inline

Definition at line 74 of file KoRuler_p.h.

: lengthInPixel(1) {}

Member Function Documentation

drawBackground()

QRectF HorizontalPaintingStrategy::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 118 of file KoRuler.cpp.

{
    lengthInPixel = d->viewConverter->documentToViewX(d->rulerLength);
    QRectF rectangle;
 
    rectangle.setX(qMax(0, d->offset));
    rectangle.setY(0);
    rectangle.setWidth(qMin(qreal(d->ruler->width() - 1.0 - rectangle.x()),
                            (d->offset >= 0) ? lengthInPixel : lengthInPixel + d->offset));
    rectangle.setHeight(d->ruler->height() - 1);
    QRectF activeRangeRectangle;
    activeRangeRectangle.setX(qMax(rectangle.x() + 1,
          d->viewConverter->documentToViewX(d->effectiveActiveRangeStart()) + d->offset));
    activeRangeRectangle.setY(rectangle.y() + 1);
    activeRangeRectangle.setRight(qMin(rectangle.right() - 1,
          d->viewConverter->documentToViewX(d->effectiveActiveRangeEnd()) + d->offset));
    activeRangeRectangle.setHeight(rectangle.height() - 2);
 
    painter.setPen(QPen(d->ruler->palette().color(QPalette::Mid), 0));
 
    painter.fillRect(rectangle,d->ruler->palette().color(QPalette::AlternateBase)); // make background slightly different so it is easier to see
    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->documentToViewX(d->firstSelectionBorder) + d->offset;
            painter.drawLine(QPointF(border, rectangle.y() + 1), QPointF(border, rectangle.bottom() - 1));
        }
        // Draw second selection border
        if(d->secondSelectionBorder > 0) {
            qreal border = d->viewConverter->documentToViewX(d->secondSelectionBorder) + d->offset;
            painter.drawLine(QPointF(border, rectangle.y() + 1), QPointF(border, rectangle.bottom() - 1));
        }
    }
 
    return rectangle;
}

References lengthInPixel.

drawIndents()

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

overridevirtual

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 378 of file KoRuler.cpp.

{
    QPolygonF polygon;
 
    painter.setBrush(d->ruler->palette().brush(QPalette::Base));
    painter.setRenderHint( QPainter::Antialiasing );
 
    qreal x;
    // Draw first line start indent
    if (d->rightToLeft)
        x = d->effectiveActiveRangeEnd() - d->firstLineIndent - d->paragraphIndent;
    else
        x = d->effectiveActiveRangeStart() + d->firstLineIndent + d->paragraphIndent;
    // convert and use the +0.5 to go to nearest integer so that the 0.5 added below ensures sharp lines
    x = int(d->viewConverter->documentToViewX(x) + d->offset + 0.5);
    polygon << QPointF(x+6.5, 0.5)
        << QPointF(x+0.5, 8.5)
        << QPointF(x-5.5, 0.5)
        << QPointF(x+5.5, 0.5);
    painter.drawPolygon(polygon);
 
    // draw the hanging indent.
    if (d->rightToLeft)
        x = d->effectiveActiveRangeStart() + d->endIndent;
    else
        x = d->effectiveActiveRangeStart() + d->paragraphIndent;
    // convert and use the +0.5 to go to nearest integer so that the 0.5 added below ensures sharp lines
    x = int(d->viewConverter->documentToViewX(x) + d->offset + 0.5);
    const int bottom = d->ruler->height();
    polygon.clear();
    polygon << QPointF(x+6.5, bottom - 0.5)
        << QPointF(x+0.5, bottom - 8.5)
        << QPointF(x-5.5, bottom - 0.5)
        << QPointF(x+5.5, bottom - 0.5);
    painter.drawPolygon(polygon);
 
    // Draw end-indent or paragraph indent if mode is rightToLeft
    qreal diff;
    if (d->rightToLeft)
        diff = d->viewConverter->documentToViewX(d->effectiveActiveRangeEnd()
                     - d->paragraphIndent) + d->offset - x;
    else
        diff = d->viewConverter->documentToViewX(d->effectiveActiveRangeEnd() - d->endIndent)
                + d->offset - x;
    polygon.translate(diff, 0);
    painter.drawPolygon(polygon);
}

drawMeasurements()

void HorizontalPaintingStrategy::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 248 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->documentToViewX(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->documentToViewX(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)) * 100;
    }
    // the chosen separation converted to pixel
    const int pixelSeparation = qRound(d->viewConverter->documentToViewX(d->unit.fromUserValue(numberSeparation)));
    // the value used to calculate displacement of secondary marks
    const int secondarydisplacement = d->rightToLeft ? -pixelSeparation : pixelSeparation;
 
    // Draw the marks
    int rulerEnd;
    qreal numberStart, numberEnd;
    if (d->rightToLeft) {
        rulerEnd = d->offset;
        numberStart = d->unit.toUserValue(d->viewConverter->viewToDocumentX(
                    rulerLengthPixel + d->offset - rectangle.right()));
        // draw the partly hidden mark when the left part of the ruler is
        // invisible
        int pixelEnd = rulerLengthPixel + d->offset - rectangle.left();
        if (rulerEnd + textLength < rectangle.left()) {
            pixelEnd -= textLength;
        }
        numberEnd = d->unit.toUserValue(d->viewConverter->viewToDocumentX(
                    pixelEnd));
        if (rulerLengthPixel + d->offset > rectangle.right()) {
            numberStart -= fmod(numberStart, numberSeparation);
        }
    } else {
        rulerEnd = d->offset + rulerLengthPixel;
        numberStart = d->unit.toUserValue(d->viewConverter->viewToDocumentX(
                    rectangle.left() - d->offset));
        // draw the partly hidden mark when the right part of the ruler is
        // invisible
        int pixelEnd = rectangle.right() - d->offset;
        if (rulerEnd - textLength > rectangle.right()) {
            pixelEnd += textLength;
        }
        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->documentToViewX(d->unit.fromUserValue(n)));
        int x = posOnRuler + d->offset;
        if (d->rightToLeft) {
            x = d->offset + rulerLengthPixel - posOnRuler;
        }
 
        // to draw the primary mark
        painter.drawLine(QPointF(x, rectangle.bottom()-1),
                QPointF(x, rectangle.bottom() - fullStepMarkerLength));
        QString numberText = QString::number(n);
        painter.setPen(numberPen);
        painter.drawText(QPointF(x - fontMetrics.horizontalAdvance(numberText)/2.0,
                    rectangle.bottom() - fullStepMarkerLength - measurementTextAboveBelowMargin),
                numberText);
        // start to draw secondary marks following the primary mark
        painter.setPen(markerPen);
 
        int xQuarterMark1 = qRound(qreal(x) + qreal(secondarydisplacement) / 4.0);
        if (d->rightToLeft ? xQuarterMark1 < rulerEnd : xQuarterMark1 > rulerEnd)
            break;
        painter.drawLine(QPointF(xQuarterMark1, rectangle.bottom() - 1),
                QPointF(xQuarterMark1, rectangle.bottom() - quarterStepMarkerLength));
 
        int xHalfMark = qRound(qreal(x) + qreal(secondarydisplacement) / 2.0);
        if (d->rightToLeft ? xHalfMark < rulerEnd : xHalfMark > rulerEnd)
            break;
        painter.drawLine(QPointF(xHalfMark, rectangle.bottom() - 1),
                QPointF(xHalfMark, rectangle.bottom() - halfStepMarkerLength));
 
        int xQuarterMark2 = qRound(qreal(x) + 3.0 * qreal(secondarydisplacement) / 4.0);
        if (d->rightToLeft ? xQuarterMark2 < rulerEnd : xQuarterMark2 > rulerEnd)
            break;
        painter.drawLine(QPointF(xQuarterMark2, rectangle.bottom() - 1),
                QPointF(xQuarterMark2, rectangle.bottom() - quarterStepMarkerLength));
    }
 
    // Draw the mouse indicator
    const int mouseCoord = d->mouseCoordinate + d->offset;
    if (d->selected == KoRulerPrivate::None || d->selected == KoRulerPrivate::HotSpot) {
        const qreal top = rectangle.y() + 1;
        const qreal bottom = rectangle.bottom() -1;
        if (d->selected == KoRulerPrivate::None
                && d->showMousePosition
                && d->mouseCoordinate > 0
                && d->mouseCoordinate < rulerLengthPixel)
            painter.drawLine(QPointF(mouseCoord, top), QPointF(mouseCoord, bottom));
        foreach (const KoRulerPrivate::HotSpotData & hp, d->hotspots) {
            const qreal x = d->viewConverter->documentToViewX(hp.position) + d->offset;
            painter.drawLine(QPointF(x, top), QPointF(x, bottom));
        }
    }
}

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

drawTabs()

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

overridevirtual

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 160 of file KoRuler.cpp.

{
    if (! d->showTabs)
        return;
    QPolygonF polygon;
 
    const QColor tabColor = d->ruler->palette().color(QPalette::Text);
    painter.setPen(QPen(tabColor, 0));
    painter.setBrush(tabColor);
    painter.setRenderHint( QPainter::Antialiasing );
 
    qreal position = -10000;
 
    foreach (const KoRuler::Tab & t, d->tabs) {
        qreal x;
        if (d->rightToLeft) {
            x = d->viewConverter->documentToViewX(d->effectiveActiveRangeEnd()
                    - (d->relativeTabs ? d->paragraphIndent : 0) - t.position) + d->offset;
        } else {
            x = d->viewConverter->documentToViewX(d->effectiveActiveRangeStart()
                    + (d->relativeTabs ? d->paragraphIndent : 0) + t.position) + d->offset;
        }
        position = qMax(position, t.position);
 
        polygon.clear();
        switch (t.type) {
        case QTextOption::LeftTab:
            polygon << QPointF(x+0.5, d->ruler->height() - 6.5)
                << QPointF(x+6.5, d->ruler->height() - 0.5)
                << QPointF(x+0.5, d->ruler->height() - 0.5);
            painter.drawPolygon(polygon);
            break;
        case QTextOption::RightTab:
            polygon << QPointF(x+0.5, d->ruler->height() - 6.5)
                << QPointF(x-5.5, d->ruler->height() - 0.5)
                << QPointF(x+0.5, d->ruler->height() - 0.5);
            painter.drawPolygon(polygon);
            break;
        case QTextOption::CenterTab:
            polygon << QPointF(x+0.5, d->ruler->height() - 6.5)
                << QPointF(x-5.5, d->ruler->height() - 0.5)
                << QPointF(x+6.5, d->ruler->height() - 0.5);
            painter.drawPolygon(polygon);
            break;
        case QTextOption::DelimiterTab:
            polygon << QPointF(x-5.5, d->ruler->height() - 0.5)
                << QPointF(x+6.5, d->ruler->height() - 0.5);
            painter.drawPolyline(polygon);
            polygon << QPointF(x+0.5, d->ruler->height() - 0.5)
                << QPointF(x+0.5, d->ruler->height() - 6.5);
            painter.drawPolyline(polygon);
            break;
        default:
            break;
        }
    }
 
    // and also draw the regular interval tab that are non editable
    if (d->tabDistance > 0.0) {
        // first possible position
        position = qMax(position, d->relativeTabs ? 0 : d->paragraphIndent);
        if (position < 0) {
            position = int(position / d->tabDistance) * d->tabDistance;
        } else {
            position = (int(position / d->tabDistance) + 1) * d->tabDistance;
        }
        while (position < d->effectiveActiveRangeEnd() - d->effectiveActiveRangeStart()
                - d->endIndent) {
            qreal x;
            if (d->rightToLeft) {
                x = d->viewConverter->documentToViewX(d->effectiveActiveRangeEnd()
                        - (d->relativeTabs ? d->paragraphIndent : 0) - position) + d->offset;
            } else {
                x = d->viewConverter->documentToViewX(d->effectiveActiveRangeStart()
                        + (d->relativeTabs ? d->paragraphIndent : 0) + position) + d->offset;
            }
 
            polygon.clear();
            polygon << QPointF(x+0.5, d->ruler->height() - 3.5)
                << QPointF(x+4.5, d->ruler->height() - 0.5)
                << QPointF(x+0.5, d->ruler->height() - 0.5);
            painter.drawPolygon(polygon);
 
            position += d->tabDistance;
        }
    }
}

References KoRuler::Tab::position, and KoRuler::Tab::type.

sizeHint()

QSize HorizontalPaintingStrategy::sizeHint ( )

overridevirtual

returns the size suggestion for a ruler with this strategy.

Implements PaintingStrategy.

Definition at line 426 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(0, minimum);
}

References fullStepMarkerLength, and measurementTextAboveBelowMargin.

Member Data Documentation

lengthInPixel

qreal HorizontalPaintingStrategy::lengthInPixel {0.0}

private

Definition at line 83 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