EnhancedPathCommand Class Reference

#include <EnhancedPathCommand.h>

Public Member Functions
void	addParameter (EnhancedPathParameter *parameter)
	Adds a new parameter to the command.
	EnhancedPathCommand (const QChar &command, EnhancedPathShape *parent)
	Constructs a new command from the given command type.
bool	execute ()
	Executes the command on the specified path shape.
QString	toString () const
	Returns a string representation of the command.
	~EnhancedPathCommand ()

Private Member Functions
qreal	angleFromPoint (const QPointF &point) const
	Calculates angle from given point.
qreal	degSweepAngle (qreal start, qreal stop, bool clockwise) const
	Returns sweep angle from start to stop and given direction.
KoPathPoint *	lastPathPoint () const
	Returns the last path point of given path.
QList< QPointF >	pointsFromParameters ()
	Returns a list of points, created from the parameter list.
qreal	radSweepAngle (qreal start, qreal stop, bool clockwise) const
	Returns sweep angle from start to stop and given direction.
QRectF	rectFromPoints (const QPointF &tl, const QPointF &br) const
	Returns rectangle from given points.

Private Attributes
QChar	m_command
	the actual command
QList< EnhancedPathParameter * >	m_parameters
	the commands parameters
EnhancedPathShape *	m_parent
	the enhanced path owning the command

Detailed Description

A EnhancedPathCommand is a command like moveto, curveto, etc. that directly modifies an enhanced paths outline.

Definition at line 23 of file EnhancedPathCommand.h.

Constructor & Destructor Documentation

EnhancedPathCommand()

EnhancedPathCommand::EnhancedPathCommand	(	const QChar &	command,
		EnhancedPathShape *	parent )

Constructs a new command from the given command type.

Definition at line 18 of file EnhancedPathCommand.cpp.

    : m_command(command)
    , m_parent(parent)
{
    Q_ASSERT(m_parent);
}

References m_parent.

~EnhancedPathCommand()

EnhancedPathCommand::~EnhancedPathCommand

(

)

Definition at line 25 of file EnhancedPathCommand.cpp.

{
}

Member Function Documentation

addParameter()

void EnhancedPathCommand::addParameter

(

EnhancedPathParameter *

parameter

)

Adds a new parameter to the command.

Definition at line 234 of file EnhancedPathCommand.cpp.

{
    if (parameter) {
        m_parameters.append(parameter);
    }
}

References m_parameters.

angleFromPoint()

qreal EnhancedPathCommand::angleFromPoint ( const QPointF & point ) const

private

Calculates angle from given point.

Definition at line 241 of file EnhancedPathCommand.cpp.

{
    qreal angle = atan2(point.y(), point.x());
    if (angle < 0.0) {
        angle += 2 * M_PI;
    }
 
    return 2 * M_PI - angle;
}

References M_PI.

degSweepAngle()

qreal EnhancedPathCommand::degSweepAngle ( qreal start, qreal stop, bool clockwise ) const

private

Returns sweep angle from start to stop and given direction.

Definition at line 272 of file EnhancedPathCommand.cpp.

{
    qreal sweepAngle = stop - start;
    if (fabs(sweepAngle) < 0.1) {
        return 360.0;
    }
    if (clockwise) {
        // we are moving clockwise to the end angle
        if (stop > start) {
            sweepAngle = (stop - start) - 360.0;
        }
    } else {
        // we are moving counter-clockwise to the stop angle
        if (start > stop) {
            sweepAngle = 360.0 - (start - stop);
        }
    }
 
    return sweepAngle;
}

execute()

bool EnhancedPathCommand::execute

(

)

Executes the command on the specified path shape.

Definition at line 29 of file EnhancedPathCommand.cpp.

{
    /*
     * The parameters of the commands are in viewbox coordinates, which have
     * to be converted to the shapes coordinate system by calling viewboxToShape
     * on the enhanced path the command works on.
     * Parameters which resemble angles are angles corresponding to the viewbox
     * coordinate system. Those have to be transformed into angles corresponding
     * to the normal mathematically coordinate system to be used for the arcTo
     * drawing routine. This is done by computing (2*M_PI - angle).
     */
    QList<QPointF> points = pointsFromParameters();
    const int pointsCount = points.size();
 
    switch (m_command.unicode()) {
    // starts new subpath at given position (x y) +
    case 'M':
        if (!pointsCount) {
            return false;
        }
        m_parent->moveTo(points[0]);
        if (pointsCount > 1)
            for (int i = 1; i < pointsCount; i++) {
                m_parent->lineTo(points[i]);
            }
        break;
    // line from current point (x y) +
    case 'L':
        Q_FOREACH (const QPointF &point, points) {
            m_parent->lineTo(point);
        }
        break;
    // cubic bezier curve from current point (x1 y1 x2 y2 x y) +
    case 'C':
        for (int i = 0; i < pointsCount; i += 3) {
            m_parent->curveTo(points[i], points[i + 1], points[i + 2]);
        }
        break;
    // closes the current subpath
    case 'Z':
        m_parent->close();
        break;
    // ends the current set of subpaths
    case 'N':
        // N just ends the complete path
        break;
    // no fill for current set of subpaths
    case 'F':
        // TODO implement me
        break;
    // no stroke for current set of subpaths
    case 'S':
        // TODO implement me
        break;
    // segment of an ellipse (x y w h t0 t1) +
    case 'T':
    // same like T but with implied movement to starting point (x y w h t0 t1) +
    case 'U': {
        bool lineTo = m_command.unicode() == 'T';
 
        for (int i = 0; i < pointsCount; i += 3) {
            const QPointF &radii = points[i + 1];
            const QPointF &angles = points[i + 2] / rad2deg;
            // compute the ellipses starting point
            QPointF start(radii.x() * cos(angles.x()), -1 * radii.y() * sin(angles.x()));
            qreal sweepAngle = degSweepAngle(points[i + 2].x(), points[i + 2].y(), false);
 
            if (lineTo) {
                m_parent->lineTo(points[i] + start);
            } else {
                m_parent->moveTo(points[i] + start);
            }
 
            m_parent->arcTo(radii.x(), radii.y(), points[i + 2].x(), sweepAngle);
        }
        break;
    }
    // counter-clockwise arc (x1 y1 x2 y2 x3 y3 x y) +
    case 'A':
    // the same as A, with implied moveto to the starting point (x1 y1 x2 y2 x3 y3 x y) +
    case 'B':
    // clockwise arc (x1 y1 x2 y2 x3 y3 x y) +
    case 'W':
    // the same as W, but implied moveto (x1 y1 x2 y2 x3 y3 x y) +
    case 'V': {
        bool lineTo = ((m_command.unicode() == 'A') || (m_command.unicode() == 'W'));
        bool clockwise = ((m_command.unicode() == 'W') || (m_command.unicode() == 'V'));
        for (int i = 0; i < pointsCount; i += 4) {
            QRectF bbox = rectFromPoints(points[i], points[i + 1]);
            QPointF center = bbox.center();
            qreal rx = 0.5 * bbox.width();
            qreal ry = 0.5 * bbox.height();
 
            if (rx == 0) {
                rx = 1;
            }
 
            if (ry == 0) {
                ry = 1;
            }
 
            QPointF startRadialVector = points[i + 2] - center;
            QPointF endRadialVector = points[i + 3] - center;
 
            // convert from ellipse space to unit-circle space
            qreal x0 = startRadialVector.x() / rx;
            qreal y0 = startRadialVector.y() / ry;
 
            qreal x1 = endRadialVector.x() / rx;
            qreal y1 = endRadialVector.y() / ry;
 
            qreal startAngle = angleFromPoint(QPointF(x0, y0));
            qreal stopAngle = angleFromPoint(QPointF(x1, y1));
 
            // we are moving counter-clockwise to the end angle
            qreal sweepAngle = radSweepAngle(startAngle, stopAngle, clockwise);
            // compute the starting point to draw the line to
            // as the point x3 y3 is not on the ellipse, spec says the point define radial vector
            QPointF startPoint(rx * cos(startAngle), ry * sin(2 * M_PI - startAngle));
 
            // if A or W is first command in enhanced path
            // move to the starting point
            bool isFirstCommandInPath = (m_parent->subpathCount() == 0);
            bool isFirstCommandInSubpath = m_parent->isClosedSubpath(m_parent->subpathCount() - 1);
 
            if (lineTo && !isFirstCommandInPath && !isFirstCommandInSubpath) {
                m_parent->lineTo(center + startPoint);
            } else {
                m_parent->moveTo(center + startPoint);
            }
 
            m_parent->arcTo(rx, ry, startAngle * rad2deg, sweepAngle * rad2deg);
        }
        break;
    }
    // elliptical quadrant (initial segment tangential to x-axis) (x y) +
    case 'X': {
        KoPathPoint *lastPoint = lastPathPoint();
        bool xDir = true;
        foreach (const QPointF &point, points) {
            qreal rx = point.x() - lastPoint->point().x();
            qreal ry = point.y() - lastPoint->point().y();
            qreal startAngle = xDir ? (ry > 0.0 ? 90.0 : 270.0) : (rx < 0.0 ? 0.0 : 180.0);
            qreal sweepAngle = xDir ? (rx * ry < 0.0 ? 90.0 : -90.0) : (rx * ry > 0.0 ? 90.0 : -90.0);
            lastPoint = m_parent->arcTo(fabs(rx), fabs(ry), startAngle, sweepAngle);
            xDir = !xDir;
        }
        break;
    }
    // elliptical quadrant (initial segment tangential to y-axis) (x y) +
    case 'Y': {
        KoPathPoint *lastPoint = lastPathPoint();
        bool xDir = false;
        foreach (const QPointF &point, points) {
            qreal rx = point.x() - lastPoint->point().x();
            qreal ry = point.y() - lastPoint->point().y();
            qreal startAngle = xDir ? (ry > 0.0 ? 90.0 : 270.0) : (rx < 0.0 ? 0.0 : 180.0);
            qreal sweepAngle = xDir ? (rx * ry < 0.0 ? 90.0 : -90.0) : (rx * ry > 0.0 ? 90.0 : -90.0);
            lastPoint = m_parent->arcTo(fabs(rx), fabs(ry), startAngle, sweepAngle);
            xDir = !xDir;
        }
        break;
    }
    // quadratic bezier curve (x1 y1 x y)+
    case 'Q':
        for (int i = 0; i < pointsCount; i += 2) {
            m_parent->curveTo(points[i], points[i + 1]);
        }
        break;
    default:
        break;
    }
    return true;
}

References angleFromPoint(), KoPathShape::arcTo(), KoPathShape::close(), KoPathShape::curveTo(), degSweepAngle(), KoPathShape::isClosedSubpath(), lastPathPoint(), KoPathShape::lineTo(), m_command, m_parent, M_PI, KoPathShape::moveTo(), KoPathPoint::point, pointsFromParameters(), rad2deg, radSweepAngle(), rectFromPoints(), and KoPathShape::subpathCount().

lastPathPoint()

KoPathPoint * EnhancedPathCommand::lastPathPoint ( ) const

private

Returns the last path point of given path.

Definition at line 293 of file EnhancedPathCommand.cpp.

{
    KoPathPoint *lastPoint = 0;
    int subpathCount = m_parent->subpathCount();
    if (subpathCount) {
        int subpathPointCount = m_parent->subpathPointCount(subpathCount - 1);
        lastPoint = m_parent->pointByIndex(KoPathPointIndex(subpathCount - 1, subpathPointCount - 1));
    }
    return lastPoint;
}

References m_parent, KoPathShape::pointByIndex(), KoPathShape::subpathCount(), and KoPathShape::subpathPointCount().

pointsFromParameters()

QList< QPointF > EnhancedPathCommand::pointsFromParameters ( )

private

Returns a list of points, created from the parameter list.

Definition at line 204 of file EnhancedPathCommand.cpp.

{
    QList<QPointF> points;
    QPointF p;
 
    int paramCount = m_parameters.count();
    for (int i = 0; i < paramCount - 1; i += 2) {
        p.setX(m_parameters[i]->evaluate());
        p.setY(m_parameters[i + 1]->evaluate());
        points.append(p);
    }
 
    int mod = 1;
    if (m_command.unicode() == 'C' || m_command.unicode() == 'U'
            || m_command.unicode() == 'T') {
        mod = 3;
    } else if (m_command.unicode() == 'A' || m_command.unicode() == 'B'
               || m_command.unicode() == 'W' || m_command.unicode() == 'V') {
        mod = 4;
    } else if (m_command.unicode() == 'Q') {
        mod = 2;
    }
    if ((points.count() % mod) != 0) { // invalid command
        qWarning() << "Invalid point count for command" << m_command << "ignoring" << "count:" << points.count() << "mod:" << mod;
        return QList<QPointF>();
    }
 
    return points;
}

References m_command, m_parameters, and p.

radSweepAngle()

qreal EnhancedPathCommand::radSweepAngle ( qreal start, qreal stop, bool clockwise ) const

private

Returns sweep angle from start to stop and given direction.

Definition at line 251 of file EnhancedPathCommand.cpp.

{
    qreal sweepAngle = stop - start;
    if (fabs(sweepAngle) < 0.1) {
        return 2 * M_PI;
    }
    if (clockwise) {
        // we are moving clockwise to the end angle
        if (stop > start) {
            sweepAngle = (stop - start) - 2 * M_PI;
        }
    } else {
        // we are moving counter-clockwise to the stop angle
        if (start > stop) {
            sweepAngle = 2 * M_PI - (start - stop);
        }
    }
 
    return sweepAngle;
}

References M_PI.

rectFromPoints()

QRectF EnhancedPathCommand::rectFromPoints ( const QPointF & tl, const QPointF & br ) const

private

Returns rectangle from given points.

Definition at line 304 of file EnhancedPathCommand.cpp.

{
    return QRectF(tl, QSizeF(br.x() - tl.x(), br.y() - tl.y())).normalized();
}

toString()

QString EnhancedPathCommand::toString

(

)

const

Returns a string representation of the command.

Definition at line 309 of file EnhancedPathCommand.cpp.

{
    QString cmd = m_command;
 
    Q_FOREACH (EnhancedPathParameter *p, m_parameters) {
        cmd += p->toString() + ' ';
    }
 
    return cmd.trimmed();
}

References m_command, m_parameters, and p.

Member Data Documentation

m_command

QChar EnhancedPathCommand::m_command

private

the actual command

Definition at line 49 of file EnhancedPathCommand.h.

m_parameters

QList<EnhancedPathParameter *> EnhancedPathCommand::m_parameters

private

the commands parameters

Definition at line 50 of file EnhancedPathCommand.h.

m_parent

EnhancedPathShape* EnhancedPathCommand::m_parent

private

the enhanced path owning the command

Definition at line 51 of file EnhancedPathCommand.h.

---

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

• plugins/flake/pathshapes/enhancedpath/EnhancedPathCommand.h
• plugins/flake/pathshapes/enhancedpath/EnhancedPathCommand.cpp