geometrize::scene::ImageTaskGraphicsView Class Reference

The ImageTaskGraphicsView class models a graphics view for viewing the images and shapes used and/or produced by image tasks. More...

#include <imagetaskgraphicsview.h>

Inheritance diagram for geometrize::scene::ImageTaskGraphicsView:

Collaboration diagram for geometrize::scene::ImageTaskGraphicsView:

Classes
class	ImageTaskGraphicsViewImpl

Public Member Functions
	ImageTaskGraphicsView (QWidget *parent=nullptr)
virtual	~ImageTaskGraphicsView ()

Protected Member Functions
void	changeEvent (QEvent *) override

Private Member Functions
void	populateUi ()
bool	viewportEvent (QEvent *event) override
void	wheelEvent (QWheelEvent *event) override
void	mousePressEvent (QMouseEvent *event) override
void	mouseReleaseEvent (QMouseEvent *event) override
void	mouseMoveEvent (QMouseEvent *event) override
void	keyPressEvent (QKeyEvent *event) override
void	keyReleaseEvent (QKeyEvent *event) override

Private Attributes
std::unique_ptr < ImageTaskGraphicsViewImpl >	d

Detailed Description

The ImageTaskGraphicsView class models a graphics view for viewing the images and shapes used and/or produced by image tasks.

Constructor & Destructor Documentation

geometrize::scene::ImageTaskGraphicsView::ImageTaskGraphicsView ( QWidget *  parent = nullptr )

explicit

                                                            : QGraphicsView(parent), d{std::make_unique<ImageTaskGraphicsViewImpl>(this)}
{
    viewport()->setAttribute(Qt::WA_AcceptTouchEvents);
    setInteractive(true);
    setMouseTracking(true);
    setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
    setDragMode(QGraphicsView::ScrollHandDrag);
    setViewportUpdateMode(QGraphicsView::FullViewportUpdate);

    populateUi();
}

Here is the call graph for this function:

geometrize::scene::ImageTaskGraphicsView::~ImageTaskGraphicsView ( )

virtual

{
}

Member Function Documentation

void geometrize::scene::ImageTaskGraphicsView::changeEvent ( QEvent *  event )

overrideprotected

{
    if (event->type() == QEvent::LanguageChange) {
        populateUi();
    }
    QGraphicsView::changeEvent(event);
}

Here is the call graph for this function:

void geometrize::scene::ImageTaskGraphicsView::keyPressEvent ( QKeyEvent *  event )

overrideprivate

{
    QGraphicsView::keyPressEvent(event);
}

void geometrize::scene::ImageTaskGraphicsView::keyReleaseEvent ( QKeyEvent *  event )

overrideprivate

{
    QGraphicsView::keyReleaseEvent(event);
}

void geometrize::scene::ImageTaskGraphicsView::mouseMoveEvent ( QMouseEvent *  event )

overrideprivate

{
    QGraphicsView::mouseMoveEvent(event);
}

void geometrize::scene::ImageTaskGraphicsView::mousePressEvent ( QMouseEvent *  event )

overrideprivate

{
    QGraphicsView::mousePressEvent(event);
}

void geometrize::scene::ImageTaskGraphicsView::mouseReleaseEvent ( QMouseEvent *  event )

overrideprivate

{
    QGraphicsView::mouseReleaseEvent(event);
}

void geometrize::scene::ImageTaskGraphicsView::populateUi ( )

private

{

}

Here is the caller graph for this function:

bool geometrize::scene::ImageTaskGraphicsView::viewportEvent ( QEvent *  event )

overrideprivate

{
    switch(event->type()) {
    case QEvent::TabletMove:
    case QEvent::TabletPress:
    case QEvent::TabletRelease:
    case QEvent::TabletEnterProximity:
    case QEvent::TabletLeaveProximity:
    {
        // Forward an event containing relevant tablet event data to the graphics scene
        const auto customEventData = makeCustomTabletEventData(static_cast<QTabletEvent&>(*event), *this);
        geometrize::scene::CustomTabletEvent customEvent(customEventData, this);
        QCoreApplication::sendEvent(dynamic_cast<geometrize::scene::ImageTaskScene*>(scene()), &customEvent);
        event->accept();
        return true;
    }
    // TODO implement pinch-to-zoom
    /*
    case QEvent::TouchBegin:
    case QEvent::TouchUpdate:
    case QEvent::TouchEnd:
    {
        QTouchEvent *touchEvent = static_cast<QTouchEvent *>(event);
        QList<QTouchEvent::TouchPoint> touchPoints = touchEvent->touchPoints();
        if (touchPoints.count() == 2) {
            // determine scale factor
            const QTouchEvent::TouchPoint &touchPoint0 = touchPoints.first();
            const QTouchEvent::TouchPoint &touchPoint1 = touchPoints.last();
            qreal currentScaleFactor =
                    QLineF(touchPoint0.pos(), touchPoint1.pos()).length()
                    / QLineF(touchPoint0.startPos(), touchPoint1.startPos()).length();
            if (touchEvent->touchPointStates() & Qt::TouchPointReleased) {
                // if one of the fingers is released, remember the current scale
                // factor so that adding another finger later will continue zooming
                // by adding new scale factor to the existing remembered value.
                d->m_totalScaleFactor *= currentScaleFactor;
                currentScaleFactor = 1;
            }
            setTransform(QTransform().scale(d->m_totalScaleFactor * currentScaleFactor,
                                            d->m_totalScaleFactor * currentScaleFactor));
        }
        event->accept();
        return true;
    }
    */
    default:
        break;
    }
    return QGraphicsView::viewportEvent(event);
}

void geometrize::scene::ImageTaskGraphicsView::wheelEvent ( QWheelEvent *  event )

overrideprivate

{
    if(e->modifiers() & Qt::ControlModifier) {
        // Pass down to scene/children in scene if control is pressed
        QGraphicsView::wheelEvent(e);
        return;
    }

    // Handle zooming
    if (e->angleDelta().x() == 0) {
        const QPoint pos{e->pos()};
        const QPointF posf{mapToScene(pos)};

        const double angle{static_cast<double>(e->angleDelta().y())};
        double by{0.0};
        if(angle > 0) {
            by = 1 + (angle / 360 * 0.1);
        } else if (angle < 0) {
            by = 1 - (-angle / 360 * 0.1);
        } else {
            by = 1;
        }

        scale(by, by);

        const int w{viewport()->width()};
        const int h{viewport()->height()};
        const double wf{mapToScene(QPoint(w - 1, 0)).x() -mapToScene(QPoint(0,0)).x()};
        const double hf{mapToScene(QPoint(0, h - 1)).y() - mapToScene(QPoint(0,0)).y()};
        const double lf{posf.x() - pos.x() * wf / w};
        const double tf{posf.y() - pos.y() * hf / h};

        ensureVisible(lf, tf, wf, hf, 0, 0);
        const QPointF newPos{mapToScene(pos)};
        ensureVisible(QRectF(QPointF(lf, tf) - newPos + posf, QSizeF(wf, hf)), 0, 0);

        e->accept();
    }
}

Member Data Documentation

std::unique_ptr<ImageTaskGraphicsViewImpl> geometrize::scene::ImageTaskGraphicsView::d

private

---

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

• /home/travis/build/Tw1ddle/geometrize-docs/geometrize/geometrize/scene/imagetaskgraphicsview.h
• /home/travis/build/Tw1ddle/geometrize-docs/geometrize/geometrize/scene/imagetaskgraphicsview.cpp