#include <RulerAssistant.h>

Inheritance diagram for RulerAssistant:

Public Member Functions
void	adjustLine (QPointF &point, QPointF &strokeBegin) override

QPointF	adjustPosition (const QPointF &point, const QPointF &strokeBegin, const bool snapToAny, qreal moveThresholdPt) override

KisPaintingAssistantSP	clone (QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > &handleMap) const override

void	enableFixedLength (bool enabled)

void	ensureLength ()

qreal	fixedLength () const

QString	fixedLengthUnit () const

QPointF	getDefaultEditorPosition () const override

bool	hasFixedLength () const

bool	isAssistantComplete () const override

bool	loadCustomXml (QXmlStreamReader *xml) override

int	minorSubdivisions () const

int	numHandles () const override

	RulerAssistant ()

void	saveCustomXml (QXmlStreamWriter *xml) override

void	setFixedLength (qreal length)

void	setFixedLengthUnit (QString unit)

void	setMinorSubdivisions (int subdivisions)

void	setSubdivisions (int subdivisions)

int	subdivisions () const

Public Member Functions inherited from KisPaintingAssistant
void	addHandle (KisPaintingAssistantHandleSP handle, HandleType type)

bool	areTwoPointsClose (const QPointF &pointOne, const QPointF &pointTwo)

QColor	assistantCustomColor ()

KisPaintingAssistantHandleSP	bottomLeft ()

const KisPaintingAssistantHandleSP	bottomLeft () const

KisPaintingAssistantHandleSP	bottomMiddle ()

const KisPaintingAssistantHandleSP	bottomMiddle () const

KisPaintingAssistantHandleSP	bottomRight ()

const KisPaintingAssistantHandleSP	bottomRight () const

virtual bool	canBeLocal () const
	canBeLocal

KisPaintingAssistantHandleSP	closestCornerHandleFromPoint (QPointF point)

void	copySharedData (KisPaintingAssistantSP assistant)

void	drawError (QPainter &painter, const QPainterPath &path)

void	drawPath (QPainter &painter, const QPainterPath &path, bool drawActive=true)

void	drawPreview (QPainter &painter, const QPainterPath &path)

void	drawX (QPainter &painter, const QPointF &pt)

QPointF	editorWidgetOffset ()

QColor	effectiveAssistantColor () const

virtual void	endStroke ()

void	findPerspectiveAssistantHandleLocation ()

virtual QPointF	getEditorPosition () const

QList< KisPaintingAssistantHandleSP >	handles ()

const QList< KisPaintingAssistantHandleSP > &	handles () const

const QString &	id () const

bool	isDuplicating ()
	isDuplicating

bool	isLocal () const
	isLocal

bool	isLocked ()
	isLocked

bool	isSnappingActive () const

	KisPaintingAssistant (const QString &id, const QString &name)

KisPaintingAssistantHandleSP	leftMiddle ()

const KisPaintingAssistantHandleSP	leftMiddle () const

void	loadXml (KoStore *store, QMap< int, KisPaintingAssistantHandleSP > &handleMap, QString path)

const QString &	name () const

KisPaintingAssistantHandleSP	oppHandleOne ()

void	replaceHandle (KisPaintingAssistantHandleSP _handle, KisPaintingAssistantHandleSP _with)

KisPaintingAssistantHandleSP	rightMiddle ()

const KisPaintingAssistantHandleSP	rightMiddle () const

QByteArray	saveXml (QMap< KisPaintingAssistantHandleSP, int > &handleMap)

void	saveXmlList (QDomDocument &doc, QDomElement &assistantsElement, int count)

virtual void	setAdjustedBrushPosition (const QPointF position)

void	setAssistantCustomColor (QColor color)

void	setAssistantGlobalColorCache (const QColor &color)

void	setDecorationThickness (int thickness)

void	setDuplicating (bool value)
	setDuplicating

void	setEditorWidgetOffset (QPointF offset)

virtual void	setFollowBrushPosition (bool follow)

void	setLocal (bool value)
	setLocal

void	setLocked (bool value)
	setLocked

void	setSnappingActive (bool set)

void	setUseCustomColor (bool useCustomColor)

QList< KisPaintingAssistantHandleSP >	sideHandles ()

const QList< KisPaintingAssistantHandleSP > &	sideHandles () const

KisPaintingAssistantHandleSP	topLeft ()

const KisPaintingAssistantHandleSP	topLeft () const

KisPaintingAssistantHandleSP	topMiddle ()

const KisPaintingAssistantHandleSP	topMiddle () const

KisPaintingAssistantHandleSP	topRight ()

const KisPaintingAssistantHandleSP	topRight () const

virtual void	transform (const QTransform &transform)

void	uncache ()

bool	useCustomColor ()

QPointF	viewportConstrainedEditorPosition (const KisCoordinatesConverter *converter, const QSize editorSize)

virtual	~KisPaintingAssistant ()

Protected Member Functions
void	drawAssistant (QPainter &gc, const QRectF &updateRect, const KisCoordinatesConverter converter, bool cached, KisCanvas2 canvas, bool assistantVisible=true, bool previewVisible=true) override

void	drawCache (QPainter &gc, const KisCoordinatesConverter *converter, bool assistantVisible=true) override
	performance layer where the graphics can be drawn from a cache instead of generated every render update

	RulerAssistant (const QString &id, const QString &name)

	RulerAssistant (const RulerAssistant &rhs, QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > &handleMap)

Protected Member Functions inherited from KisPaintingAssistant
virtual QRect	boundingRect () const

QPointF	effectiveBrushPosition (const KisCoordinatesConverter converter, KisCanvas2 canvas) const
	Query the effective brush position to be used for preview lines. This is intended to be used for painting the dynamic preview lines for assistants that feature them. Affected by setAdjustedBrushPosition() and setFollowBrushPosition().

virtual KisPaintingAssistantHandleSP	firstLocalHandle () const
	firstLocalHandle Note: this doesn't guarantee it will be the topleft corner! For that, use getLocalRect().topLeft() The only purpose of those functions to exist is to be able to put getLocalRect() function in the KisPaintingAssistant instead of reimplementing it in every specific assistant.

QRectF	getLocalRect () const
	getLocalRect The function deals with local handles not being topLeft and bottomRight gracefully and returns a correct rectangle. Thanks to that the user can place handles in a "wrong" order or move them around but the local rectangle will still be correct.

void	initHandles (QList< KisPaintingAssistantHandleSP > _handles)

	KisPaintingAssistant (const KisPaintingAssistant &rhs, QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > &handleMap)

QPointF	pixelToView (const QPoint pixelCoords) const

virtual KisPaintingAssistantHandleSP	secondLocalHandle () const
	secondLocalHandle Note: this doesn't guarantee it will be the bottomRight corner! For that, use getLocalRect().bottomRight() (and remember that for QRect bottomRight() works differently than for QRectF, so don't convert to QRect before accessing the corner)

Private Member Functions
void	drawHandleAnnotations (QPainter &gc, const KisCoordinatesConverter *converter)

void	drawSubdivisions (QPainter &gc, const KisCoordinatesConverter *converter)

QPointF	project (const QPointF &pt) const

Private Attributes
qreal	m_fixedLength {0.0}

QString	m_fixedLengthUnit {"px"}

bool	m_hasFixedLength {false}

int	m_minorSubdivisions {0}

int	m_subdivisions {0}

Additional Inherited Members
Static Public Member Functions inherited from KisPaintingAssistant
static QList< KisPaintingAssistantSP >	cloneAssistantList (const QList< KisPaintingAssistantSP > &list)

static double	norm2 (const QPointF &p)

Protected Attributes inherited from KisPaintingAssistant
QList< KisPaintingAssistantHandleSP >	m_handles

bool	m_hasBeenInsideLocalRect {false}

Detailed Description

Definition at line 18 of file RulerAssistant.h.

Constructor & Destructor Documentation

◆ RulerAssistant() [1/3]

RulerAssistant::RulerAssistant ( )

Definition at line 24 of file RulerAssistant.cc.

    : RulerAssistant("ruler", i18n("Ruler assistant"))
{
}

◆ RulerAssistant() [2/3]

RulerAssistant::RulerAssistant	(	const QString &	id,
		const QString &	name )

explicitprotected

Definition at line 29 of file RulerAssistant.cc.

    : KisPaintingAssistant(id, name)
{
}

◆ RulerAssistant() [3/3]

RulerAssistant::RulerAssistant	(	const RulerAssistant &	rhs,
		QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > &	handleMap )

explicitprotected

Definition at line 39 of file RulerAssistant.cc.

    : KisPaintingAssistant(rhs, handleMap)
    , m_subdivisions(rhs.m_subdivisions)
    , m_minorSubdivisions(rhs.m_minorSubdivisions)
    , m_hasFixedLength(rhs.m_hasFixedLength)
    , m_fixedLength(rhs.m_fixedLength)
    , m_fixedLengthUnit(rhs.m_fixedLengthUnit)
{
}

Member Function Documentation

◆ adjustLine()

void RulerAssistant::adjustLine	(	QPointF &	point,
		QPointF &	strokeBegin )

overridevirtual

Implements KisPaintingAssistant.

Definition at line 77 of file RulerAssistant.cc.

{
    point = project(point);
    strokeBegin = project(strokeBegin);
}

References project().

◆ adjustPosition()

QPointF RulerAssistant::adjustPosition	(	const QPointF &	point,
		const QPointF &	strokeBegin,
		const bool	snapToAny,
		qreal	moveThresholdPt )

overridevirtual

Adjust the position given in parameter.

Parameters

point	the coordinates in point in the document reference
strokeBegin	the coordinates of the beginning of the stroke
snapToAny	because now assistants can be composited out of multiple inside assistants. snapToAny true means that you can use any of the inside assistant, while it being false means you should use the last used one. The logic determining when it happens (first stroke etc.) is in the decoration, so those two options are enough.
moveThresholdPt	the threshold for the "move" of the cursor measured in pt (usually equals to 2px in screen coordinates converted to pt)

Implements KisPaintingAssistant.

Definition at line 72 of file RulerAssistant.cc.

{
    return project(pt);
}

References project().

◆ clone()

KisPaintingAssistantSP RulerAssistant::clone ( QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > & handleMap ) const

overridevirtual

Implements KisPaintingAssistant.

Definition at line 34 of file RulerAssistant.cc.

{
    return KisPaintingAssistantSP(new RulerAssistant(*this, handleMap));
}

References RulerAssistant().

◆ drawAssistant()

void RulerAssistant::drawAssistant	(	QPainter &	gc,
		const QRectF &	updateRect,
		const KisCoordinatesConverter *	converter,
		bool	cached,
		KisCanvas2 *	canvas,
		bool	assistantVisible = true,
		bool	previewVisible = true )

overrideprotectedvirtual

Reimplemented from KisPaintingAssistant.

Definition at line 182 of file RulerAssistant.cc.

{
    // Draw the subdivisions
    // When the number of subdivisions (or minor subdivisions) is set to
    // 0, the respective feature is turned off and won't be rendered.
    if (assistantVisible && isAssistantComplete() && subdivisions() > 0) {
        drawSubdivisions(gc, converter);
    }
    
    // Indicate handle type on fixed-length handles
    if (canvas && canvas->paintingAssistantsDecoration()->isEditingAssistants() && hasFixedLength()) {
        drawHandleAnnotations(gc, converter);
    }
    
    // Draw the ruler itself via drawCache
    KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
}

References KisPaintingAssistant::drawAssistant(), drawHandleAnnotations(), drawSubdivisions(), hasFixedLength(), isAssistantComplete(), KisPaintingAssistantsDecoration::isEditingAssistants(), KisCanvas2::paintingAssistantsDecoration(), and subdivisions().

◆ drawCache()

void RulerAssistant::drawCache	(	QPainter &	gc,
		const KisCoordinatesConverter *	converter,
		bool	assistantVisible = true )

overrideprotectedvirtual

performance layer where the graphics can be drawn from a cache instead of generated every render update

Implements KisPaintingAssistant.

Definition at line 200 of file RulerAssistant.cc.

{
    if (!assistantVisible || !isAssistantComplete()){
        return;
    }
 
    QTransform initialTransform = converter->documentToWidgetTransform();
 
    // Draw the line
    QPointF p1 = *handles()[0];
    QPointF p2 = *handles()[1];
 
    gc.setTransform(initialTransform);
    QPainterPath path;
    path.moveTo(p1);
    path.lineTo(p2);
    drawPath(gc, path, isSnappingActive());
}

References KisCoordinatesConverter::documentToWidgetTransform(), KisPaintingAssistant::drawPath(), KisPaintingAssistant::handles(), isAssistantComplete(), KisPaintingAssistant::isSnappingActive(), p1, and p2.

◆ drawHandleAnnotations()

void RulerAssistant::drawHandleAnnotations	(	QPainter &	gc,
		const KisCoordinatesConverter *	converter )

private

Definition at line 150 of file RulerAssistant.cc.

                                                                                                 {
    gc.save();
    gc.resetTransform();
    
    QTransform doc2widget = converter->documentToWidgetTransform();
    QPointF center = doc2widget.map(*handles()[0]);
    QPointF handle = doc2widget.map(*handles()[1]);
  
    QPainterPath path;
  
    // Center / Movement handle
    for (int i = 0; i < 4; ++i) {
        QTransform rot = QTransform().rotate(i * 90);
      
        path.moveTo(center + rot.map(QPointF(12, -3)));
        path.lineTo(center + rot.map(QPointF(9, 0)));
        path.lineTo(center + rot.map(QPointF(12, 3)));
    }
    
    // Rotation handle
    QRectF bounds = QRectF(handle, QSizeF(0, 0)).adjusted(-11, -11, 11, 11);
    for (int i = 0; i < 2; ++i) {
        int dir = i == 0 ? 1 : -1;
        
        path.moveTo(handle + QPointF(dir * 11, 0));
        path.arcTo(bounds, i * 180, -90);
    }
    
    drawPath(gc, path);
    gc.restore();
}

References bounds, KisCoordinatesConverter::documentToWidgetTransform(), KisPaintingAssistant::drawPath(), and KisPaintingAssistant::handles().

◆ drawSubdivisions()

void RulerAssistant::drawSubdivisions	(	QPainter &	gc,
		const KisCoordinatesConverter *	converter )

private

Definition at line 83 of file RulerAssistant.cc.

                                                                                            {
    if (subdivisions() == 0) {
        return;
    }
  
    // Get handle positions
    QTransform document2widget = converter->documentToWidgetTransform();
  
    QPointF p1 = document2widget.map(*handles()[0]);
    QPointF p2 = document2widget.map(*handles()[1]);
  
    const qreal scale = 16.0 / 2;
    const qreal minorScale = scale / 2;
    const QRectF clipping = QRectF(gc.viewport()).adjusted(-scale, -scale, scale, scale);
    // If the lines would end up closer to each other than this threshold (in
    // screen coordinates), they are not rendered, as they wouldn't be
    // distinguishable anymore.
    const qreal threshold = 3.0;
    
    // Calculate line direction and normal vector
    QPointF delta = p2 - p1;
    qreal length = sqrt(KisPaintingAssistant::norm2(delta));
    qreal stepsize = length / subdivisions();
    
    // Only draw if lines are far enough apart
    if (stepsize >= threshold) {
        QPointF normal = QPointF(delta.y(), -delta.x());
        normal /= length;
  
        QPainterPath path;
        
        // Draw the major subdivisions
        for (int ii = 0; ii <= subdivisions(); ++ii) {
          
            QPointF pos = p1 + delta * ((qreal)ii / subdivisions());
            
            if (clipping.contains(pos)) {
                path.moveTo(pos - normal * scale);
                path.lineTo(pos + normal * scale);
            }
            
            // Draw minor subdivisions, if they exist (implicit check due to
            // the loop bounds)
            // Skip for the last iteration of the outer loop, which would
            // already be beyond the ruler's length
            // Also skip if major subdivisions are too close already
            if (ii == subdivisions() || stepsize / minorSubdivisions() < threshold)
                continue;
            // Draw minor marks in between the major ones
            for (int jj = 1; jj < minorSubdivisions(); ++jj) {
              
                QPointF mpos = pos + delta * ((qreal)jj / (subdivisions() * minorSubdivisions()));
    
                if (clipping.contains(mpos)) {
                    path.moveTo(mpos - normal * minorScale);
                    path.lineTo(mpos + normal * minorScale);
                }
            }
        }
  
        gc.save();
        gc.resetTransform();
        drawPath(gc, path, isSnappingActive());
        gc.restore();
    }
}

References KisCoordinatesConverter::documentToWidgetTransform(), KisPaintingAssistant::drawPath(), KisPaintingAssistant::handles(), KisPaintingAssistant::isSnappingActive(), length(), minorSubdivisions(), KisPaintingAssistant::norm2(), p1, p2, and subdivisions().

◆ enableFixedLength()

void RulerAssistant::enableFixedLength ( bool enabled )

Definition at line 257 of file RulerAssistant.cc.

                                                   {
    m_hasFixedLength = enabled;
}

References m_hasFixedLength.

◆ ensureLength()

void RulerAssistant::ensureLength ( )

Definition at line 285 of file RulerAssistant.cc.

                                  {
    if (!hasFixedLength() || fixedLength() < 1e-3) {
        return;
    }
    
    QPointF center = *handles()[0];
    QPointF handle = *handles()[1];
    QPointF direction = handle - center;
    qreal distance = sqrt(KisPaintingAssistant::norm2(direction));
    QPointF delta = direction / distance * fixedLength();
    *handles()[1] = center + delta;
    uncache();
}

References distance(), fixedLength(), KisPaintingAssistant::handles(), hasFixedLength(), KisPaintingAssistant::norm2(), and KisPaintingAssistant::uncache().

◆ fixedLength()

qreal RulerAssistant::fixedLength ( ) const

Definition at line 261 of file RulerAssistant.cc.

                                        {
    return m_fixedLength;
}

References m_fixedLength.

◆ fixedLengthUnit()

QString RulerAssistant::fixedLengthUnit ( ) const

Definition at line 273 of file RulerAssistant.cc.

                                              {
    return m_fixedLengthUnit;
}

References m_fixedLengthUnit.

◆ getDefaultEditorPosition()

QPointF RulerAssistant::getDefaultEditorPosition ( ) const

overridevirtual

Implements KisPaintingAssistant.

Definition at line 219 of file RulerAssistant.cc.

{
    return (*handles()[0] + *handles()[1]) * 0.5;
}

References KisPaintingAssistant::handles().

◆ hasFixedLength()

bool RulerAssistant::hasFixedLength ( ) const

Definition at line 253 of file RulerAssistant.cc.

                                          {
    return m_hasFixedLength;
}

References m_hasFixedLength.

◆ isAssistantComplete()

bool RulerAssistant::isAssistantComplete ( ) const

overridevirtual

determines if the assistant has enough handles to be considered created new assistants get in a "creation" phase where they are currently being made on the canvas it will return false if we are in the middle of creating the assistant.

Reimplemented from KisPaintingAssistant.

Definition at line 224 of file RulerAssistant.cc.

{
    return handles().size() >= 2;
}

References KisPaintingAssistant::handles().

◆ loadCustomXml()

bool RulerAssistant::loadCustomXml ( QXmlStreamReader * xml )

overridevirtual

Reimplemented from KisPaintingAssistant.

Definition at line 315 of file RulerAssistant.cc.

                                                        {
    if (xml) {
        if (xml->name() == "subdivisions") {
            setSubdivisions(KisDomUtils::toInt(xml->attributes().value("value").toString()));
        }
        else if (xml->name() == "minorSubdivisions") {
            setMinorSubdivisions(KisDomUtils::toInt(xml->attributes().value("value").toString()));
        }
        else if (xml->name() == "fixedLength") {
            setFixedLength(KisDomUtils::toDouble(xml->attributes().value("value").toString()));
            enableFixedLength(0 != KisDomUtils::toInt(xml->attributes().value("enabled").toString()));
            setFixedLengthUnit(xml->attributes().value("unit").toString());
        }
    }
    return true;
}

References enableFixedLength(), setFixedLength(), setFixedLengthUnit(), setMinorSubdivisions(), setSubdivisions(), KisDomUtils::toDouble(), and KisDomUtils::toInt().

◆ minorSubdivisions()

int RulerAssistant::minorSubdivisions ( ) const

Definition at line 241 of file RulerAssistant.cc.

                                            {
    return m_minorSubdivisions;
}

References m_minorSubdivisions.

◆ numHandles()

int RulerAssistant::numHandles ( ) const

inlineoverridevirtual

Implements KisPaintingAssistant.

Definition at line 26 of file RulerAssistant.h.

26{ return 2; }

◆ project()

QPointF RulerAssistant::project ( const QPointF & pt ) const

private

Definition at line 49 of file RulerAssistant.cc.

{
    Q_ASSERT(isAssistantComplete());
    QPointF pt1 = *handles()[0];
    QPointF pt2 = *handles()[1];
    
    QPointF a = pt - pt1;
    QPointF u = pt2 - pt1;
    
    qreal u_norm = sqrt(u.x() * u.x() + u.y() * u.y());
    
    if(u_norm == 0) return pt;
    
    u /= u_norm;
    
    double t = a.x() * u.x() + a.y() * u.y();
    
    if(t < 0.0) return pt1;
    if(t > u_norm) return pt2;
    
    return t * u + pt1;
}

References KisPaintingAssistant::handles(), isAssistantComplete(), and u.

◆ saveCustomXml()

void RulerAssistant::saveCustomXml ( QXmlStreamWriter * xml )

overridevirtual

Reimplemented from KisPaintingAssistant.

Definition at line 299 of file RulerAssistant.cc.

                                                        {
    if (xml) {
        xml->writeStartElement("subdivisions");
        xml->writeAttribute("value", KisDomUtils::toString(subdivisions()));
        xml->writeEndElement();
        xml->writeStartElement("minorSubdivisions");
        xml->writeAttribute("value", KisDomUtils::toString(minorSubdivisions()));
        xml->writeEndElement();
        xml->writeStartElement("fixedLength");
        xml->writeAttribute("value", KisDomUtils::toString(fixedLength()));
        xml->writeAttribute("enabled", KisDomUtils::toString((int)hasFixedLength()));
        xml->writeAttribute("unit", fixedLengthUnit());
        xml->writeEndElement();
    }
}

References fixedLength(), fixedLengthUnit(), hasFixedLength(), minorSubdivisions(), subdivisions(), and KisDomUtils::toString().

◆ setFixedLength()

void RulerAssistant::setFixedLength ( qreal length )

Definition at line 265 of file RulerAssistant.cc.

                                                {
    if (length < 0.0) {
        m_fixedLength = 0.0;
    } else {
        m_fixedLength = length;
    }
}

References length(), and m_fixedLength.

◆ setFixedLengthUnit()

void RulerAssistant::setFixedLengthUnit ( QString unit )

Definition at line 277 of file RulerAssistant.cc.

                                                    {
    if (unit.isEmpty()) {
        m_fixedLengthUnit = "px";
    } else {
        m_fixedLengthUnit = unit;
    }
}

References m_fixedLengthUnit.

◆ setMinorSubdivisions()

void RulerAssistant::setMinorSubdivisions ( int subdivisions )

Definition at line 245 of file RulerAssistant.cc.

                                                          {
    if (subdivisions < 0) {
        m_minorSubdivisions = 0;
    } else {
        m_minorSubdivisions = subdivisions;
    }
}

References m_minorSubdivisions, and subdivisions().

◆ setSubdivisions()

void RulerAssistant::setSubdivisions ( int subdivisions )

Definition at line 233 of file RulerAssistant.cc.

                                                     {
    if (subdivisions < 0) {
        m_subdivisions = 0;
    } else {
        m_subdivisions = subdivisions;
    }
}

References m_subdivisions, and subdivisions().

◆ subdivisions()

int RulerAssistant::subdivisions ( ) const

Definition at line 229 of file RulerAssistant.cc.

                                       {
    return m_subdivisions;
}

References m_subdivisions.

Member Data Documentation

◆ m_fixedLength

qreal RulerAssistant::m_fixedLength {0.0}

private

Definition at line 58 of file RulerAssistant.h.

58{0.0};

◆ m_fixedLengthUnit

QString RulerAssistant::m_fixedLengthUnit {"px"}

private

Definition at line 59 of file RulerAssistant.h.

59{"px"};

◆ m_hasFixedLength

bool RulerAssistant::m_hasFixedLength {false}

private

Definition at line 57 of file RulerAssistant.h.

57{false};

◆ m_minorSubdivisions

int RulerAssistant::m_minorSubdivisions {0}

private

Definition at line 56 of file RulerAssistant.h.

56{0};

◆ m_subdivisions

int RulerAssistant::m_subdivisions {0}

private

Definition at line 55 of file RulerAssistant.h.

55{0};

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

plugins/assistants/Assistants/RulerAssistant.h
plugins/assistants/Assistants/RulerAssistant.cc

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ RulerAssistant() [1/3]

◆ RulerAssistant() [2/3]

◆ RulerAssistant() [3/3]

Member Function Documentation

◆ adjustLine()

◆ adjustPosition()

◆ clone()

◆ drawAssistant()

◆ drawCache()

◆ drawHandleAnnotations()

◆ drawSubdivisions()

◆ enableFixedLength()

◆ ensureLength()

◆ fixedLength()

◆ fixedLengthUnit()

◆ getDefaultEditorPosition()

◆ hasFixedLength()

◆ isAssistantComplete()

◆ loadCustomXml()

◆ minorSubdivisions()

◆ numHandles()

◆ project()

◆ saveCustomXml()

◆ setFixedLength()

◆ setFixedLengthUnit()

◆ setMinorSubdivisions()

◆ setSubdivisions()

◆ subdivisions()

Member Data Documentation

◆ m_fixedLength

◆ m_fixedLengthUnit

◆ m_hasFixedLength

◆ m_minorSubdivisions

◆ m_subdivisions