KoShapeGradientHandles Class Reference

#include <KoShapeGradientHandles.h>

Classes
struct	Handle

Public Member Functions
Handle	getHandle (Handle::Type handleType)
QVector< Handle >	handles () const
	KoShapeGradientHandles (KoFlake::FillVariant fillVariant, KoShape *shape)
KUndo2Command *	moveGradientHandle (Handle::Type handleType, const QPointF &absoluteOffset)
QGradient::Type	type () const

Private Member Functions
QPointF	getNewHandlePos (const QPointF &oldPos, const QPointF &absoluteOffset, QGradient::CoordinateMode mode)
const QGradient *	gradient () const

Private Attributes
KoFlake::FillVariant	m_fillVariant
KoShape *	m_shape

Detailed Description

Definition at line 18 of file KoShapeGradientHandles.h.

Constructor & Destructor Documentation

KoShapeGradientHandles()

KoShapeGradientHandles::KoShapeGradientHandles	(	KoFlake::FillVariant	fillVariant,
		KoShape *	shape )

Definition at line 17 of file KoShapeGradientHandles.cpp.

    : m_fillVariant(fillVariant),
      m_shape(shape)
{
}

Member Function Documentation

getHandle()

KoShapeGradientHandles::Handle KoShapeGradientHandles::getHandle

(

Handle::Type

handleType

)

Definition at line 134 of file KoShapeGradientHandles.cpp.

{
    Handle result;
 
    Q_FOREACH (const Handle &h, handles()) {
        if (h.type == handleType) {
            result = h;
            break;
        }
    }
 
    return result;
}

References handles().

getNewHandlePos()

QPointF KoShapeGradientHandles::getNewHandlePos ( const QPointF & oldPos, const QPointF & absoluteOffset, QGradient::CoordinateMode mode )

private

Some shapes may have zero-width/height, then inverted transform will not exist. Therefore we should use a special method for that.

Definition at line 153 of file KoShapeGradientHandles.cpp.

{
    const QTransform offset = QTransform::fromTranslate(absoluteOffset.x(), absoluteOffset.y());
    QTransform localToAbsolute = m_shape->absoluteTransformation();
    QTransform absoluteToLocal = localToAbsolute.inverted();
 
    if (mode == QGradient::ObjectBoundingMode) {
        const QRectF rect = m_shape->outlineRect();
        const QTransform gradientToUser = KisAlgebra2D::mapToRect(rect);
        localToAbsolute = gradientToUser * localToAbsolute;
 
        const QTransform userToGradient = KisAlgebra2D::mapToRectInverse(rect);
        absoluteToLocal = absoluteToLocal * userToGradient;
    }
 
    return (localToAbsolute * offset * absoluteToLocal).map(oldPos);
}

References KoShape::absoluteTransformation(), m_shape, KisAlgebra2D::mapToRect(), KisAlgebra2D::mapToRectInverse(), and KoShape::outlineRect().

gradient()

const QGradient * KoShapeGradientHandles::gradient ( ) const

private

Definition at line 148 of file KoShapeGradientHandles.cpp.

                                                        {
    KoShapeFillWrapper wrapper(m_shape, m_fillVariant);
    return wrapper.gradient();
}

References KoShapeFillWrapper::gradient(), m_fillVariant, and m_shape.

handles()

QVector< KoShapeGradientHandles::Handle > KoShapeGradientHandles::handles

(

)

const

Definition at line 23 of file KoShapeGradientHandles.cpp.

                                                                            {
    QVector<Handle> result;
 
    const QGradient *g = gradient();
    if (!g) return result;
 
    switch (g->type()) {
    case QGradient::LinearGradient: {
        const QLinearGradient *lgradient = static_cast<const QLinearGradient*>(g);
        result << Handle(Handle::LinearStart, lgradient->start());
        result << Handle(Handle::LinearEnd, lgradient->finalStop());
        break;
    }
    case QGradient::RadialGradient: {
        const QRadialGradient *rgradient = static_cast<const QRadialGradient*>(g);
 
        result << Handle(Handle::RadialCenter, rgradient->center());
 
        if (rgradient->center() != rgradient->focalPoint()) {
            result << Handle(Handle::RadialFocalPoint, rgradient->focalPoint());
        }
 
        result << Handle(Handle::RadialRadius,
                         rgradient->center() + QPointF(rgradient->centerRadius(), 0));
        break;
    }
    case QGradient::ConicalGradient:
        // not supported
        break;
    case QGradient::NoGradient:
        // not supported
        break;
    }
 
    if (g->coordinateMode() == QGradient::ObjectBoundingMode) {
        const QRectF boundingRect = m_shape->outlineRect();
        const QTransform gradientToUser(boundingRect.width(), 0, 0, boundingRect.height(),
                                        boundingRect.x(), boundingRect.y());
        const QTransform t = gradientToUser * m_shape->absoluteTransformation();
 
        QVector<Handle>::iterator it = result.begin();
 
 
 
        for (; it != result.end(); ++it) {
            it->pos = t.map(it->pos);
        }
    }
 
    return result;
}

References KoShape::absoluteTransformation(), gradient(), KoShapeGradientHandles::Handle::LinearEnd, KoShapeGradientHandles::Handle::LinearStart, m_shape, KoShape::outlineRect(), KoShapeGradientHandles::Handle::RadialCenter, KoShapeGradientHandles::Handle::RadialFocalPoint, and KoShapeGradientHandles::Handle::RadialRadius.

moveGradientHandle()

KUndo2Command * KoShapeGradientHandles::moveGradientHandle	(	Handle::Type	handleType,
		const QPointF &	absoluteOffset )

Definition at line 81 of file KoShapeGradientHandles.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(handleType != Handle::None, 0);
 
    KoShapeFillWrapper wrapper(m_shape, m_fillVariant);
    const QGradient *originalGradient = wrapper.gradient();
    QTransform originalTransform = wrapper.gradientTransform();
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(originalGradient, 0);
 
    QScopedPointer<QGradient> newGradient;
 
    switch (originalGradient->type()) {
    case QGradient::LinearGradient: {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(handleType == Handle::LinearStart ||
                                             handleType == Handle::LinearEnd, 0);
 
        newGradient.reset(KoFlake::cloneGradient(originalGradient));
        QLinearGradient *lgradient = static_cast<QLinearGradient*>(newGradient.data());
 
        if (handleType == Handle::LinearStart) {
            lgradient->setStart(getNewHandlePos(lgradient->start(), absoluteOffset, newGradient->coordinateMode()));
        } else if (handleType == Handle::LinearEnd) {
            lgradient->setFinalStop(getNewHandlePos(lgradient->finalStop(), absoluteOffset, newGradient->coordinateMode()));
 
        }
        break;
    }
    case QGradient::RadialGradient: {
        newGradient.reset(KoFlake::cloneGradient(originalGradient));
        QRadialGradient *rgradient = static_cast<QRadialGradient*>(newGradient.data());
 
        if (handleType == Handle::RadialCenter) {
            rgradient->setCenter(getNewHandlePos(rgradient->center(), absoluteOffset, newGradient->coordinateMode()));
        } else if (handleType == Handle::RadialFocalPoint) {
            rgradient->setFocalPoint(getNewHandlePos(rgradient->focalPoint(), absoluteOffset, newGradient->coordinateMode()));
        } else if (handleType == Handle::RadialRadius) {
            QPointF radiusPos = rgradient->center() + QPointF(QPointF(rgradient->radius(), 0));
            radiusPos = getNewHandlePos(radiusPos, absoluteOffset, newGradient->coordinateMode());
            rgradient->setRadius(radiusPos.x() - rgradient->center().x());
        }
        break;
    }
    case QGradient::ConicalGradient:
        // not supported
        break;
    case QGradient::NoGradient:
        // not supported
        break;
    }
 
    return wrapper.setGradient(newGradient.data(), originalTransform);
}

References KoFlake::cloneGradient(), getNewHandlePos(), KoShapeFillWrapper::gradient(), KoShapeFillWrapper::gradientTransform(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, KoShapeGradientHandles::Handle::LinearEnd, KoShapeGradientHandles::Handle::LinearStart, m_fillVariant, m_shape, KoShapeGradientHandles::Handle::None, KoShapeGradientHandles::Handle::RadialCenter, KoShapeGradientHandles::Handle::RadialFocalPoint, KoShapeGradientHandles::Handle::RadialRadius, and KoShapeFillWrapper::setGradient().

type()

QGradient::Type KoShapeGradientHandles::type

(

)

const

Definition at line 75 of file KoShapeGradientHandles.cpp.

{
    const QGradient *g = gradient();
    return g ? g->type() : QGradient::NoGradient;
}

References gradient().

Member Data Documentation

m_fillVariant

KoFlake::FillVariant KoShapeGradientHandles::m_fillVariant

private

Definition at line 53 of file KoShapeGradientHandles.h.

m_shape

KoShape* KoShapeGradientHandles::m_shape

private

Definition at line 54 of file KoShapeGradientHandles.h.

---

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

• plugins/tools/defaulttool/defaulttool/KoShapeGradientHandles.h
• plugins/tools/defaulttool/defaulttool/KoShapeGradientHandles.cpp