KisInfinityManager Class Reference

#include <kis_infinity_manager.h>

Inheritance diagram for KisInfinityManager:

Public Slots
void	imagePositionChanged ()
Public Slots inherited from KisCanvasDecoration
virtual void	setVisible (bool v)
void	toggleVisibility ()

Public Member Functions
	KisInfinityManager (QPointer< KisView >view, KisCanvas2 *canvas)
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
virtual void	setCanvasWidget (KisCanvasWidgetBase *canvas)
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 *obj, QEvent *event) override
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 ()

Private Types
enum	Side {   Right = 0 , Bottom , Left , Top ,   NSides }

Private Member Functions
void	addDecoration (const QRect &areaRect, const QPointF &handlePoint, qreal angle, Side side)

Private Attributes
QPointer< KisCanvas2 >	m_canvas
bool	m_cursorSwitched
QPainterPath	m_decorationPath
bool	m_filteringEnabled
QVector< QTransform >	m_handleTransform
QCursor	m_oldCursor
QVector< QRect >	m_sideRects

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

Detailed Description

Definition at line 22 of file kis_infinity_manager.h.

Member Enumeration Documentation

Side

enum KisInfinityManager::Side

private

Enumerator
Right
Bottom
Left
Top
NSides

Definition at line 37 of file kis_infinity_manager.h.

              {
        Right = 0,
        Bottom,
        Left,
        Top,
 
        NSides
    };

Constructor & Destructor Documentation

KisInfinityManager()

KisInfinityManager::KisInfinityManager	(	QPointer< KisView >	view,
		KisCanvas2 *	canvas )

Definition at line 27 of file kis_infinity_manager.cpp.

  : KisCanvasDecoration(INFINITY_DECORATION_ID, view),
    m_filteringEnabled(false),
    m_cursorSwitched(false),
    m_sideRects(NSides),
    m_canvas(canvas)
{
    connect(canvas, &KisCanvas2::sigCanvasStateChanged,
            this, &KisInfinityManager::imagePositionChanged);
}

References imagePositionChanged(), and KisCanvas2::sigCanvasStateChanged().

Member Function Documentation

addDecoration()

void KisInfinityManager::addDecoration ( const QRect & areaRect, const QPointF & handlePoint, qreal angle, Side side )

inlineprivate

Definition at line 38 of file kis_infinity_manager.cpp.

{
    QTransform t;
    t.rotate(angle);
    t = t * QTransform::fromTranslate(handlePoint.x(), handlePoint.y());
    m_handleTransform << t;
 
    m_decorationPath.addRect(areaRect);
    m_sideRects[side] = areaRect;
}

References m_decorationPath, m_handleTransform, and m_sideRects.

drawDecoration()

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

overrideprotectedvirtual

Implements KisCanvasDecoration.

Definition at line 125 of file kis_infinity_manager.cpp.

{
    Q_UNUSED(updateArea);
    Q_UNUSED(converter);
    Q_UNUSED(canvas);
 
    if (!m_filteringEnabled) return;
 
    gc.save();
    gc.setTransform(QTransform(), false);
 
    KisConfig cfg(true);
    QColor color = cfg.canvasBorderColor();
    KoColor c;
    c.fromQColor(color.darker(115));
    QColor darkerColor = canvas->displayRendererInterface()->convertColorToDisplayColorSpace(c);
    gc.fillPath(m_decorationPath, darkerColor);
    c.fromQColor(color);
    color = canvas->displayRendererInterface()->convertColorToDisplayColorSpace(c);
 
    QPainterPath p = KisAlgebra2D::smallArrow();
 
    Q_FOREACH (const QTransform &t, m_handleTransform) {
        gc.fillPath(t.map(p), color);
    }
 
    gc.restore();
}

References KisConfig::canvasBorderColor(), KoColorDisplayRendererInterface::convertColorToDisplayColorSpace(), KisCanvas2::displayRendererInterface(), KoColor::fromQColor(), m_decorationPath, m_filteringEnabled, m_handleTransform, p, and KisAlgebra2D::smallArrow().

eventFilter()

bool KisInfinityManager::eventFilter ( QObject * obj, QEvent * event )

overrideprotected

We connect our event filter to the global InputManager which is shared among all the canvases. Ideally we should disconnect our event filter whin this canvas is not active, but for now we can just check the destination of the event, if it is correct.

Definition at line 209 of file kis_infinity_manager.cpp.

{
    if (m_canvas == NULL || obj != m_canvas->canvasWidget()) return false;
 
    KIS_ASSERT_RECOVER_NOOP(m_filteringEnabled);
 
    bool retval = false;
 
    switch (event->type()) {
    case QEvent::Enter:
    case QEvent::MouseMove:
    case QEvent::TabletMove: {
        QPoint pos = getPointFromEvent(event);
 
        if (m_decorationPath.contains(pos)) {
            if (!m_cursorSwitched) {
                m_oldCursor = m_canvas->canvasWidget()->cursor();
                m_cursorSwitched = true;
            }
            m_canvas->canvasWidget()->setCursor(Qt::PointingHandCursor);
            retval = true;
        } else if (m_cursorSwitched) {
            m_canvas->canvasWidget()->setCursor(m_oldCursor);
            m_cursorSwitched = false;
        }
        break;
    }
    case QEvent::Leave: {
        if (m_cursorSwitched) {
            m_canvas->canvasWidget()->setCursor(m_oldCursor);
            m_cursorSwitched = false;
        }
        break;
    }
    case QEvent::MouseButtonPress:
    case QEvent::TabletPress: {
        Qt::MouseButton button = getButtonFromEvent(event);
        retval = button == Qt::LeftButton && m_cursorSwitched;
 
        if (button == Qt::RightButton) {
            imagePositionChanged();
        }
 
        break;
    }
    case QEvent::MouseButtonRelease:
    case QEvent::TabletRelease: {
        Qt::MouseButton button = getButtonFromEvent(event);
        retval = button == Qt::LeftButton && m_cursorSwitched;
 
        if (retval) {
            QPoint pos = getPointFromEvent(event);
 
            const KisCoordinatesConverter *converter = m_canvas->coordinatesConverter();
            QRect widgetRect = converter->widgetToImage(m_canvas->canvasWidget()->rect()).toAlignedRect();
            KisImageWSP image = view()->image();
 
            QRect cropRect = image->bounds();
 
            const int hLimit = cropRect.width();
            const int vLimit = cropRect.height();
 
            if (m_sideRects[Right].contains(pos)) {
                cropRect.setRight(expandRight(cropRect.right(), widgetRect.right(), hLimit));
            }
            if (m_sideRects[Bottom].contains(pos)) {
                cropRect.setBottom(expandRight(cropRect.bottom(), widgetRect.bottom(), vLimit));
            }
            if (m_sideRects[Left].contains(pos)) {
                cropRect.setLeft(expandLeft(cropRect.left(), widgetRect.left(), hLimit));
            }
            if (m_sideRects[Top].contains(pos)) {
                cropRect.setTop(expandLeft(cropRect.top(), widgetRect.top(), vLimit));
            }
 
            image->resizeImage(cropRect);
 
            // since resizing the image can cause the cursor to end up on the canvas without a move event,
            // it can get stuck in an overridden state until it is changed by another event,
            // and we don't want that.
            if (m_cursorSwitched) {
                m_canvas->canvasWidget()->setCursor(m_oldCursor);
                m_cursorSwitched = false;
            }
        }
        break;
    }
    default:
        break;
    }
 
    return !retval ? KisCanvasDecoration::eventFilter(obj, event) : true;
}

References Bottom, KisImage::bounds(), button(), expandLeft(), expandRight(), getButtonFromEvent(), getPointFromEvent(), imagePositionChanged(), KIS_ASSERT_RECOVER_NOOP, Left, m_canvas, m_cursorSwitched, m_decorationPath, m_filteringEnabled, m_oldCursor, m_sideRects, KisImage::resizeImage(), Right, Top, KisCanvasDecoration::view(), and KisCoordinatesConverter::widgetToImage().

imagePositionChanged

void KisInfinityManager::imagePositionChanged ( )

slot

Definition at line 49 of file kis_infinity_manager.cpp.

{
    const QRect imageRect = m_canvas->coordinatesConverter()->imageRectInWidgetPixels().toAlignedRect();
    const QRect widgetRect = m_canvas->canvasWidget()->rect();
 
    KisConfig cfg(true);
    qreal vastScrolling = cfg.vastScrolling();
 
    int xReserve = vastScrolling * widgetRect.width();
    int yReserve = vastScrolling * widgetRect.height();
 
    int xThreshold = imageRect.width() - 0.4 * xReserve;
    int yThreshold = imageRect.height() - 0.4 * yReserve;
 
    const int stripeWidth = 48;
 
    int xCut = widgetRect.width() - stripeWidth;
    int yCut = widgetRect.height() - stripeWidth;
 
    m_decorationPath = QPainterPath();
    m_decorationPath.setFillRule(Qt::WindingFill);
 
    m_handleTransform.clear();
 
    m_sideRects.clear();
    m_sideRects.resize(NSides);
 
    bool visible = false;
 
    if (imageRect.x() <= -xThreshold) {
        QRect areaRect(widgetRect.adjusted(xCut, 0, 0, 0));
        QPointF pt = areaRect.center() + QPointF(-0.1 * stripeWidth, 0);
        addDecoration(areaRect, pt, 0, Right);
        visible = true;
    }
 
    if (imageRect.y() <= -yThreshold) {
        QRect areaRect(widgetRect.adjusted(0, yCut, 0, 0));
        QPointF pt = areaRect.center() + QPointF(0, -0.1 * stripeWidth);
        addDecoration(areaRect, pt, 90, Bottom);
        visible = true;
    }
 
    if (imageRect.right() > widgetRect.width() + xThreshold) {
        QRect areaRect(widgetRect.adjusted(0, 0, -xCut, 0));
        QPointF pt = areaRect.center() + QPointF(0.1 * stripeWidth, 0);
        addDecoration(areaRect, pt, 180, Left);
        visible = true;
    }
 
    if (imageRect.bottom() > widgetRect.height() + yThreshold) {
        QRect areaRect(widgetRect.adjusted(0, 0, 0, -yCut));
        QPointF pt = areaRect.center() + QPointF(0, 0.1 * stripeWidth);
        addDecoration(areaRect, pt, 270, Top);
        visible = true;
    }
 
    if (!m_filteringEnabled && visible && this->visible()) {
        KisInputManager *inputManager = m_canvas->globalInputManager();
        if (inputManager) {
            inputManager->attachPriorityEventFilter(this);
        }
 
        m_filteringEnabled = true;
    }
 
    if (m_filteringEnabled && (!visible || !this->visible())) {
        KisInputManager *inputManager = m_canvas->globalInputManager();
        if (inputManager) {
            inputManager->detachPriorityEventFilter(this);
        }
 
        m_filteringEnabled = false;
    }
}

References addDecoration(), KisInputManager::attachPriorityEventFilter(), Bottom, KisInputManager::detachPriorityEventFilter(), Left, m_canvas, m_decorationPath, m_filteringEnabled, m_handleTransform, m_sideRects, NSides, Right, Top, KisConfig::vastScrolling(), and KisCanvasDecoration::visible().

Member Data Documentation

m_canvas

QPointer<KisCanvas2> KisInfinityManager::m_canvas

private

Definition at line 57 of file kis_infinity_manager.h.

m_cursorSwitched

bool KisInfinityManager::m_cursorSwitched

private

Definition at line 51 of file kis_infinity_manager.h.

m_decorationPath

QPainterPath KisInfinityManager::m_decorationPath

private

Definition at line 48 of file kis_infinity_manager.h.

m_filteringEnabled

bool KisInfinityManager::m_filteringEnabled

private

Definition at line 50 of file kis_infinity_manager.h.

m_handleTransform

QVector<QTransform> KisInfinityManager::m_handleTransform

private

Definition at line 53 of file kis_infinity_manager.h.

m_oldCursor

QCursor KisInfinityManager::m_oldCursor

private

Definition at line 52 of file kis_infinity_manager.h.

m_sideRects

QVector<QRect> KisInfinityManager::m_sideRects

private

Definition at line 55 of file kis_infinity_manager.h.

---

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

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