KisMirrorAxis Class Reference

#include <kis_mirror_axis.h>

Inheritance diagram for KisMirrorAxis:

Classes
class	Private

Signals
void	handleSizeChanged ()
void	sigConfigChanged ()

Public Member Functions
float	handleSize () const
	KisMirrorAxis (KisCanvasResourceProvider *provider, QPointer< KisView > parent)
const KisMirrorAxisConfig &	mirrorAxisConfig () const
void	setHandleSize (float newSize)
void	setMirrorAxisConfig (const KisMirrorAxisConfig &config)
void	setVisible (bool v) override
	~KisMirrorAxis () override
Public Member Functions inherited from KisCanvasDecoration
const QString &	id () const
	KisCanvasDecoration (const QString &id, QPointer< KisView >parent)
virtual void	notifyWindowMinimized (bool minimized)
void	paint (QPainter &gc, const QRectF &updateRect, const KisCoordinatesConverter *converter, KisCanvas2 *canvas)
int	priority () const
void	setView (QPointer< KisView > imageView)
bool	visible () const
	~KisCanvasDecoration () override
Public Member Functions inherited from KisShared
bool	deref ()
bool	ref ()
int	refCount ()
QAtomicInt *	sharedWeakReference ()

Protected Member Functions
void	drawDecoration (QPainter &gc, const QRectF &updateArea, const KisCoordinatesConverter *converter, KisCanvas2 *canvas) override
bool	eventFilter (QObject *target, QEvent *event) override
void	toggleMirrorActions ()
Protected Member Functions inherited from KisCanvasDecoration
int	decorationThickness () const
void	setPriority (int value)
QPointer< KisView >	view () const
Protected Member Functions inherited from KisShared
	KisShared ()
	~KisShared ()

Properties
float	handleSize

Private Slots
void	mirrorModeChanged ()
void	moveHorizontalAxisToCenter ()
void	moveVerticalAxisToCenter ()

Private Attributes
const QScopedPointer< Private >	d

Additional Inherited Members
Public Slots inherited from KisCanvasDecoration
void	toggleVisibility ()
Static Public Member Functions inherited from KisCanvasDecoration
static bool	comparePriority (KisCanvasDecorationSP decoration1, KisCanvasDecorationSP decoration2)

Detailed Description

Definition at line 19 of file kis_mirror_axis.h.

Constructor & Destructor Documentation

KisMirrorAxis()

KisMirrorAxis::KisMirrorAxis	(	KisCanvasResourceProvider *	provider,
		QPointer< KisView >	parent )

Definition at line 87 of file kis_mirror_axis.cpp.

    : KisCanvasDecoration("mirror_axis", parent)
    , d(new Private(this))
{
    d->resourceProvider = provider;
    connect(d->resourceProvider, SIGNAL(mirrorModeChanged()), SLOT(mirrorModeChanged()));
    connect(d->resourceProvider, SIGNAL(moveMirrorVerticalCenter()), SLOT(moveVerticalAxisToCenter()));
    connect(d->resourceProvider, SIGNAL(moveMirrorHorizontalCenter()), SLOT(moveHorizontalAxisToCenter()));
 
    d->config.setMirrorHorizontal(d->resourceProvider->mirrorHorizontal());
    d->config.setMirrorVertical(d->resourceProvider->mirrorVertical());
    d->horizontalIcon = KisIconUtils::loadIcon("mirrorAxis-HorizontalMove").pixmap(d->config.handleSize(), QIcon::Normal, QIcon::On);
    d->verticalIcon = KisIconUtils::loadIcon("mirrorAxis-VerticalMove").pixmap(d->config.handleSize(), QIcon::Normal, QIcon::On);
    d->horizontalHandleIcon = KisIconUtils::loadIcon("transform-move").pixmap(d->config.handleSize(), QIcon::Normal, QIcon::On);
    d->verticalHandleIcon = KisIconUtils::loadIcon("transform-move").pixmap(d->config.handleSize(), QIcon::Normal, QIcon::On);
    setVisible(d->config.mirrorHorizontal() || d->config.mirrorVertical());
 
    d->image = parent->canvasBase()->image();
}

References connect(), d, KisIconUtils::loadIcon(), mirrorModeChanged(), moveHorizontalAxisToCenter(), moveVerticalAxisToCenter(), and setVisible().

~KisMirrorAxis()

KisMirrorAxis::~KisMirrorAxis ( )

override

Definition at line 107 of file kis_mirror_axis.cpp.

{
}

Member Function Documentation

drawDecoration()

void KisMirrorAxis::drawDecoration ( QPainter & gc, const QRectF & updateArea, const KisCoordinatesConverter * converter, KisCanvas2 * canvas )

overrideprotectedvirtual

Implements KisCanvasDecoration.

Definition at line 130 of file kis_mirror_axis.cpp.

{
    Q_UNUSED(updateArea);
    Q_UNUSED(converter);
    Q_UNUSED(canvas);
 
    if (!view()->isCurrent()) {
        return;
    }
 
    gc.save();
 
    QPen pen1(QColor(0, 0, 0, 64), 2 * decorationThickness(), Qt::DashDotDotLine, Qt::RoundCap, Qt::RoundJoin);
    pen1.setCosmetic(true);
    QPen pen2 = pen1;
    pen2.setColor(QColor(0, 0, 0, 128));
    pen2.setStyle(Qt::SolidLine);
    QPen pen3 = pen2;
    pen3.setWidth(1 * decorationThickness());
    gc.setPen(pen3);
    gc.setBrush(Qt::white);
    gc.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
 
    QOpenGLContext *ctx = QOpenGLContext::currentContext();
    bool hasMultisample = false;
    if (ctx) {
        hasMultisample = ((gc.paintEngine()->type() == QPaintEngine::OpenGL2)
                          && (ctx->hasExtension("GL_ARB_multisample") || ctx->hasExtension("GL_EXT_multisample_compatibility")));
 
        // QPainter cannot anti-alias the edges of circles etc. when using OpenGL
        // So instead, use native OpenGL anti-aliasing when available.
        if (hasMultisample) {
            gc.beginNativePainting();
            ctx->functions()->glEnable(GL_MULTISAMPLE_EXT);
            gc.endNativePainting();
        }
    }
 
    float halfHandleSize = d->config.handleSize() / 2;
 
    const qreal dpr = canvas->canvasWidget()->devicePixelRatioF();
    d->recomputeVisibleAxes(QRect(gc.viewport().topLeft() / dpr, gc.viewport().size() / dpr));
 
    if(d->config.mirrorHorizontal() && !d->config.hideHorizontalDecoration()) {
        if (!d->horizontalAxis.isNull()) {
            // QPointF horizontalIndicatorCenter = d->horizontalAxis.unitVector().pointAt(15);
            // QRectF horizontalIndicator = QRectF(horizontalIndicatorCenter.x() - halfHandleSize, horizontalIndicatorCenter.y() - halfHandleSize, d->config.handleSize(), d->config.handleSize());
 
            float horizontalHandlePosition = qBound<float>(d->minHandlePosition, d->config.horizontalHandlePosition(), d->horizontalAxis.length() - d->minHandlePosition);
            QPointF horizontalHandleCenter = d->horizontalAxis.unitVector().pointAt(horizontalHandlePosition);
            d->horizontalHandle = QRectF(horizontalHandleCenter.x() - halfHandleSize, horizontalHandleCenter.y() - halfHandleSize, d->config.handleSize(), d->config.handleSize());
 
            gc.setPen(pen1);
            gc.drawLine(d->horizontalAxis);
 
            // gc.drawEllipse(horizontalIndicator);
            //  gc.drawPixmap(horizontalIndicator.adjusted(5, 5, -5, -5).toRect(), d->horizontalIcon);
 
            // don't draw the handles if we are locking the axis for movement
            if (!d->config.lockHorizontal()) {
                gc.setPen(pen2);
                gc.drawEllipse(d->horizontalHandle);
                gc.drawPixmap(d->horizontalHandle.adjusted(5, 5, -5, -5).toRect(), d->horizontalIcon);
            }
 
        } else {
            d->horizontalHandle = QRectF();
        }
    }
 
    if(d->config.mirrorVertical() && !d->config.hideVerticalDecoration()) {
        if (!d->verticalAxis.isNull()) {
 
            gc.setPen(pen1);
            gc.drawLine(d->verticalAxis);
 
 
            // QPointF verticalIndicatorCenter = d->verticalAxis.unitVector().pointAt(15);
            // QRectF verticalIndicator = QRectF(verticalIndicatorCenter.x() - halfHandleSize, verticalIndicatorCenter.y() - halfHandleSize, d->config.handleSize(), d->config.handleSize());
 
            float verticalHandlePosition = qBound<float>(d->minHandlePosition, d->config.verticalHandlePosition(), d->verticalAxis.length() - d->minHandlePosition);
            QPointF verticalHandleCenter = d->verticalAxis.unitVector().pointAt(verticalHandlePosition);
            d->verticalHandle = QRectF(verticalHandleCenter.x() - halfHandleSize, verticalHandleCenter.y() - halfHandleSize, d->config.handleSize(), d->config.handleSize());
 
            // don't draw the handles if we are locking the axis for movement
            if (!d->config.lockVertical()) {
                gc.setPen(pen2);
                gc.drawEllipse(d->verticalHandle);
                gc.drawPixmap(d->verticalHandle.adjusted(5, 5, -5, -5).toRect(), d->verticalIcon);
            }
 
        } else {
            d->verticalHandle = QRectF();
        }
    }
 
    if (hasMultisample) {
        gc.beginNativePainting();
        ctx->functions()->glDisable(GL_MULTISAMPLE_EXT);
        gc.endNativePainting();
    }
 
    gc.restore();
 
}

References KisCanvas2::canvasWidget, d, KisCanvasDecoration::decorationThickness(), and KisCanvasDecoration::view().

eventFilter()

bool KisMirrorAxis::eventFilter ( QObject * target, QEvent * event )

overrideprotected

Definition at line 263 of file kis_mirror_axis.cpp.

{
    if (!visible()) return false;
 
    QObject *expectedCanvasWidget = view() ?
                view()->canvasBase()->canvasWidget() : 0;
 
    if (!expectedCanvasWidget || target != expectedCanvasWidget) return false;
 
    if (event->type() == QEvent::MouseButtonPress || event->type() == QEvent::TabletPress
        || event->type() == QEvent::TouchBegin) {
        const QScopedPointer<KoPointerEvent> pointerEvent(getKoPointerEvent(event));
        const QPoint pos = !pointerEvent.isNull() ? pointerEvent->pos() : QPoint(77,77);
 
        if(d->config.mirrorHorizontal() && d->horizontalHandle.contains(pos) && !d->config.lockHorizontal() && !d->config.hideHorizontalDecoration() ) {
            d->xActive = true;
            QApplication::setOverrideCursor(Qt::ClosedHandCursor);
            event->accept();
            return true;
        }
 
        if(d->config.mirrorVertical() && d->verticalHandle.contains(pos) && !d->config.lockVertical() && !d->config.hideVerticalDecoration()) {
            d->yActive = true;
            QApplication::setOverrideCursor(Qt::ClosedHandCursor);
            event->accept();
            return true;
        }
    }
    if (event->type() == QEvent::MouseMove || event->type() == QEvent::TabletMove
        || event->type() == QEvent::TouchUpdate) {
        const QScopedPointer<KoPointerEvent> pointerEvent(getKoPointerEvent(event));
        const QPoint pos = !pointerEvent.isNull() ? pointerEvent->pos() : QPoint(77,77);
 
        if(d->xActive) {
            float axisX = view()->viewConverter()->widgetToImage<QPoint>(pos).x();
            // axisX should be either int or int + 0.5
            axisX *= 2; // to be able to choose in the middle of the pixel
            axisX = round(axisX); // find the closest acceptable point
            axisX = axisX/2; // return to the original space
 
 
            d->setAxisPosition(axisX, d->config.axisPosition().y());
            d->config.setHorizontalHandlePosition(KisAlgebra2D::dotProduct<QPointF>(pos - d->horizontalAxis.p1(), d->horizontalAxis.unitVector().p2() - d->horizontalAxis.p1()));
            Q_EMIT sigConfigChanged();
 
            event->accept();
            view()->showFloatingMessage(i18n("X: %1 px",QString::number(d->config.axisPosition().x(), 'f', 1))
                                        , QIcon(), 1000, KisFloatingMessage::High,  Qt::AlignLeft | Qt::TextWordWrap | Qt::AlignVCenter);
            return true;
        }
        if(d->yActive) {
            float axisY = view()->viewConverter()->widgetToImage<QPoint>(pos).y();
            // axisX should be either int or int + 0.5
            axisY *= 2; // to be able to choose in the middle of the pixel
            axisY = round(axisY); // find the closest acceptable point
            axisY = axisY/2; // return to the original space
 
            d->setAxisPosition(d->config.axisPosition().x(), axisY);
            d->config.setVerticalHandlePosition(KisAlgebra2D::dotProduct<QPointF>(pos - d->verticalAxis.p1(), d->verticalAxis.unitVector().p2() - d->verticalAxis.p1()));
            Q_EMIT sigConfigChanged();
 
            event->accept();
            view()->showFloatingMessage(i18n("Y: %1 px",QString::number(d->config.axisPosition().y(), 'f', 1))
                                        , QIcon(), 1000, KisFloatingMessage::High, Qt::AlignLeft | Qt::TextWordWrap | Qt::AlignVCenter);
            return true;
        }
        if(d->config.mirrorHorizontal() && !d->config.hideHorizontalDecoration()) {
            if(d->horizontalHandle.contains(pos) && !d->config.lockHorizontal()) {
                if(!d->horizontalContainsCursor) {
                    QApplication::setOverrideCursor(Qt::OpenHandCursor);
                    d->horizontalContainsCursor = true;
                }
            } else if(d->horizontalContainsCursor) {
                QApplication::restoreOverrideCursor();
                d->horizontalContainsCursor = false;
            }
        }
        if(d->config.mirrorVertical() && !d->config.hideVerticalDecoration()) {
            if(d->verticalHandle.contains(pos) && !d->config.lockVertical()) {
                if(!d->verticalContainsCursor) {
                    QApplication::setOverrideCursor(Qt::OpenHandCursor);
                    d->verticalContainsCursor = true;
                }
            } else if(d->verticalContainsCursor) {
                QApplication::restoreOverrideCursor();
                d->verticalContainsCursor = false;
            }
        }
    }
    if (event->type() == QEvent::MouseButtonRelease || event->type() == QEvent::TabletRelease
        || event->type() == QEvent::TouchEnd || event->type() == QEvent::TouchCancel) {
 
        if(d->xActive) {
            while (QApplication::overrideCursor()) {
                QApplication::restoreOverrideCursor();
            }
            d->xActive = false;
            event->accept();
            return true;
        }
        if(d->yActive) {
            while (QApplication::overrideCursor()) {
                QApplication::restoreOverrideCursor();
            }
            d->yActive = false;
            event->accept();
            return true;
        }
    }
 
    return QObject::eventFilter(target, event);
}

References d, getKoPointerEvent(), KisFloatingMessage::High, sigConfigChanged(), target(), KisCanvasDecoration::view(), and KisCanvasDecoration::visible().

handleSize()

float KisMirrorAxis::handleSize

(

)

const

Definition at line 111 of file kis_mirror_axis.cpp.

{
    return d->config.handleSize();
}

References d.

handleSizeChanged

void KisMirrorAxis::handleSizeChanged ( )

signal

mirrorAxisConfig()

const KisMirrorAxisConfig & KisMirrorAxis::mirrorAxisConfig

(

)

const

Definition at line 436 of file kis_mirror_axis.cpp.

{
    return d->config;
}

References d.

mirrorModeChanged

void KisMirrorAxis::mirrorModeChanged ( )

privateslot

Definition at line 376 of file kis_mirror_axis.cpp.

{
    if (!view()->isCurrent()) {
        return;
    }
 
    d->config.setMirrorHorizontal(d->resourceProvider->mirrorHorizontal());
    d->config.setMirrorVertical(d->resourceProvider->mirrorVertical());
 
    d->config.setLockHorizontal(d->resourceProvider->mirrorHorizontalLock());
    d->config.setLockVertical(d->resourceProvider->mirrorVerticalLock());
 
    d->config.setHideHorizontalDecoration(d->resourceProvider->mirrorHorizontalHideDecorations());
    d->config.setHideVerticalDecoration(d->resourceProvider->mirrorVerticalHideDecorations());
 
    setVisible(d->config.mirrorHorizontal() || d->config.mirrorVertical());
 
    Q_EMIT sigConfigChanged();
}

References d, setVisible(), sigConfigChanged(), and KisCanvasDecoration::view().

moveHorizontalAxisToCenter

void KisMirrorAxis::moveHorizontalAxisToCenter ( )

privateslot

Definition at line 465 of file kis_mirror_axis.cpp.

{
    if (!view()->isCurrent()) {
        return;
    }
 
    d->setAxisPosition(d->image->width()/2, d->config.axisPosition().y());
    Q_EMIT sigConfigChanged();
}

References d, sigConfigChanged(), and KisCanvasDecoration::view().

moveVerticalAxisToCenter

void KisMirrorAxis::moveVerticalAxisToCenter ( )

privateslot

Definition at line 475 of file kis_mirror_axis.cpp.

{
    if (!view()->isCurrent()) {
        return;
    }
 
    d->setAxisPosition(d->config.axisPosition().x(), d->image->height()/2 );
    Q_EMIT sigConfigChanged();
}

References d, sigConfigChanged(), and KisCanvasDecoration::view().

setHandleSize()

void KisMirrorAxis::setHandleSize

(

float

newSize

)

Definition at line 116 of file kis_mirror_axis.cpp.

{
    if(d->config.handleSize() != newSize) {
        d->config.setHandleSize(newSize);
        d->horizontalIcon = KisIconUtils::loadIcon("symmetry-horizontal").pixmap(d->config.handleSize(), QIcon::Normal, QIcon::On);
        d->verticalIcon = KisIconUtils::loadIcon("symmetry-vertical").pixmap(d->config.handleSize(), QIcon::Normal, QIcon::On);
        d->horizontalHandleIcon = KisIconUtils::loadIcon("transform-move").pixmap(d->config.handleSize(), QIcon::Normal, QIcon::On);
        d->verticalHandleIcon = KisIconUtils::loadIcon("transform-move").pixmap(d->config.handleSize(), QIcon::Normal, QIcon::On);
        d->minHandlePosition = d->sideMargin + newSize;
        Q_EMIT handleSizeChanged();
        Q_EMIT sigConfigChanged();
    }
}

References d, handleSizeChanged(), KisIconUtils::loadIcon(), and sigConfigChanged().

setMirrorAxisConfig()

void KisMirrorAxis::setMirrorAxisConfig

(

const KisMirrorAxisConfig &

config

)

Definition at line 411 of file kis_mirror_axis.cpp.

{
    if (config != d->config) {
        KisSignalsBlocker blocker(d->resourceProvider);
 
        d->config = config;
 
        d->resourceProvider->setMirrorHorizontal(d->config.mirrorHorizontal());
        d->resourceProvider->setMirrorVertical(d->config.mirrorVertical());
 
        d->resourceProvider->setMirrorHorizontalLock(d->config.lockHorizontal());
        d->resourceProvider->setMirrorVerticalLock(d->config.lockVertical());
 
        d->resourceProvider->setMirrorHorizontalHideDecorations(d->config.hideHorizontalDecoration());
        d->resourceProvider->setMirrorVerticalHideDecorations(d->config.hideVerticalDecoration());
 
        if (view()) {
            view()->canvasBase()->updateCanvas();
        }
    }
 
    toggleMirrorActions();
    setVisible(d->config.mirrorHorizontal() || d->config.mirrorVertical());
}

References d, KisMirrorAxisConfig::setMirrorHorizontal(), setVisible(), toggleMirrorActions(), and KisCanvasDecoration::view().

setVisible()

void KisMirrorAxis::setVisible ( bool v )

overridevirtual

Set if the decoration is visible or not.

Reimplemented from KisCanvasDecoration.

Definition at line 396 of file kis_mirror_axis.cpp.

{
    KisCanvasDecoration::setVisible(v);
 
 
    KisInputManager *inputManager = view() ? view()->canvasBase()->globalInputManager() : 0;
    if (!inputManager) return;
 
    if (v) {
        inputManager->attachPriorityEventFilter(this);
    } else {
        inputManager->detachPriorityEventFilter(this);
    }
}

References KisInputManager::attachPriorityEventFilter(), KisInputManager::detachPriorityEventFilter(), KisCanvasDecoration::setVisible(), v, and KisCanvasDecoration::view().

sigConfigChanged

void KisMirrorAxis::sigConfigChanged ( )

signal

toggleMirrorActions()

void KisMirrorAxis::toggleMirrorActions ( )

protected

Definition at line 441 of file kis_mirror_axis.cpp.

{
    KisKActionCollection* collection = view()->viewManager()->actionCollection();
    // first uncheck the action, then set according to config;
    // otherwise the connected KisHighlightedToolButton's highlight color is not
    // properly set
    collection->action("hmirror_action")->setChecked(false);
    collection->action("vmirror_action")->setChecked(false);
 
    if (d->config.mirrorHorizontal()) {
        collection->action("hmirror_action")->setChecked(d->config.mirrorHorizontal());
    }
 
    if (d->config.mirrorVertical()) {
        collection->action("vmirror_action")->setChecked(d->config.mirrorVertical());
    }
 
    collection->action("mirrorX-lock")->setChecked(d->config.lockHorizontal());
    collection->action("mirrorY-lock")->setChecked(d->config.lockVertical());
 
    collection->action("mirrorX-hideDecorations")->setChecked(d->config.hideHorizontalDecoration());
    collection->action("mirrorY-hideDecorations")->setChecked(d->config.hideVerticalDecoration());
}

References KisKActionCollection::action(), d, and KisCanvasDecoration::view().

Member Data Documentation

d

const QScopedPointer<Private> KisMirrorAxis::d

private

Definition at line 46 of file kis_mirror_axis.h.

Property Documentation

handleSize

float KisMirrorAxis::handleSize

readwrite

Definition at line 22 of file kis_mirror_axis.h.

---

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

• libs/ui/canvas/kis_mirror_axis.h
• libs/ui/canvas/kis_mirror_axis.cpp