OverviewDockerPage Class Reference

#include <overviewdocker_page.h>

Inheritance diagram for OverviewDockerPage:

Public Slots
void	mirrorUpdateIcon ()
void	rotateCanvasView (qreal rotation)
void	setPinControls (bool pin)
void	updateRotationSlider (qreal rotation)

Public Member Functions
	OverviewDockerPage (QWidget *parent=0, const char *name=0, Qt::WindowFlags f=Qt::WindowFlags())
void	setCanvas (KoCanvasBase *canvas)
void	unsetCanvas ()
	~OverviewDockerPage () override

Protected Member Functions
void	enterEvent (QEnterEvent *event) override
bool	event (QEvent *e) override
bool	eventFilter (QObject *o, QEvent *e) override
void	leaveEvent (QEvent *) override
void	resizeEvent (QResizeEvent *) override

Private Slots
void	hideControls (int delay) const
void	on_overviewWidget_signalDraggingFinished ()
void	on_overviewWidget_signalDraggingStarted ()
void	showControls (int delay) const

Private Member Functions
void	layoutMainWidgets ()

Private Attributes
bool	m_areControlsHidden {false}
QPointer< KisCanvas2 >	m_canvas
QWidget *	m_controlsContainer {nullptr}
QVBoxLayout *	m_controlsLayout {nullptr}
QHBoxLayout *	m_controlsSecondRowLayout {nullptr}
double	m_cumulatedMouseDistanceSquared {0.0}
bool	m_cursorIsHover {false}
bool	m_isDraggingWithTouch {false}
bool	m_isTouching {false}
QPointF	m_lastOverviewMousePos
QPointF	m_lastTouchPos
QToolButton *	m_mirrorCanvas {nullptr}
OverviewWidget *	m_overviewWidget {nullptr}
bool	m_pinControls {true}
QToolButton *	m_pinControlsButton {nullptr}
KisAngleSelector *	m_rotateAngleSelector {nullptr}
QVariantAnimation	m_showControlsAnimation
QTimer	m_showControlsTimer
int	m_touchPointId {0}
QWidget *	m_zoomSlider {nullptr}

Static Private Attributes
static constexpr double	showControlsAnimationDuration {150.0}
static constexpr double	showControlsAreaRadius {4.0}
static constexpr int	showControlsTimerDuration {500}
static constexpr double	touchDragDistance {8.0}
static constexpr double	touchDragDistanceSquared {touchDragDistance * touchDragDistance}

Detailed Description

Definition at line 23 of file overviewdocker_page.h.

Constructor & Destructor Documentation

OverviewDockerPage()

OverviewDockerPage::OverviewDockerPage	(	QWidget *	parent = 0,
		const char *	name = 0,
		Qt::WindowFlags	f = Qt::WindowFlags() )

Definition at line 37 of file overviewdocker_page.cpp.

    : QWidget(parent, f)
    , m_lastOverviewMousePos(0.0, 0.0)
{
    setObjectName(name);
 
    m_overviewWidget = new OverviewWidget(this);
    m_overviewWidget->setMinimumHeight(50);
    m_overviewWidget->setBackgroundRole(QPalette::Base);
    // paints background role before paint()
    m_overviewWidget->setAutoFillBackground(true);
    m_overviewWidget->setAttribute(Qt::WA_AcceptTouchEvents, true);
    m_overviewWidget->installEventFilter(this);
    connect(m_overviewWidget, SIGNAL(signalDraggingStarted()), SLOT(on_overviewWidget_signalDraggingStarted()));
    connect(m_overviewWidget, SIGNAL(signalDraggingFinished()), SLOT(on_overviewWidget_signalDraggingFinished()));
 
    m_controlsContainer = new QWidget(this);
 
    m_controlsLayout = new QVBoxLayout;
    m_controlsLayout->setContentsMargins(2, 2, 2, 2);
    m_controlsLayout->setSpacing(2);
    m_controlsContainer->setLayout(m_controlsLayout);
 
    m_showControlsTimer.setSingleShot(true);
 
    m_showControlsAnimation.setEasingCurve(QEasingCurve(QEasingCurve::InOutCubic));
    connect(&m_showControlsAnimation, &QVariantAnimation::valueChanged, this, &OverviewDockerPage::layoutMainWidgets);
 
    KConfigGroup config = KSharedConfig::openConfig()->group("OverviewDocker");
    m_pinControls = config.readEntry("pinControls", true);
    m_areControlsHidden = !m_pinControls;
 
    setEnabled(false);
}

References connect(), layoutMainWidgets(), m_areControlsHidden, m_controlsContainer, m_controlsLayout, m_overviewWidget, m_pinControls, m_showControlsAnimation, m_showControlsTimer, on_overviewWidget_signalDraggingFinished(), and on_overviewWidget_signalDraggingStarted().

~OverviewDockerPage()

OverviewDockerPage::~OverviewDockerPage ( )

override

Definition at line 72 of file overviewdocker_page.cpp.

{
    KConfigGroup config = KSharedConfig::openConfig()->group("OverviewDocker");
    config.writeEntry("pinControls", m_pinControls);
}

References m_pinControls.

Member Function Documentation

enterEvent()

void OverviewDockerPage::enterEvent ( QEnterEvent * event )

overrideprotected

Definition at line 243 of file overviewdocker_page.cpp.

{
    m_cursorIsHover = true;
    if (isEnabled() && !m_pinControls) {
        showControls(showControlsTimerDuration);
    }
}

event()

bool OverviewDockerPage::event ( QEvent * e )

overrideprotected

Definition at line 252 of file overviewdocker_page.cpp.

{
    if (e->type() == QEvent::StyleChange || e->type() == QEvent::FontChange) {
        resizeEvent(nullptr);
    }
    return QWidget::event(e);
}

References resizeEvent().

eventFilter()

bool OverviewDockerPage::eventFilter ( QObject * o, QEvent * e )

overrideprotected

Definition at line 260 of file overviewdocker_page.cpp.

{
    if (!isEnabled()) {
        return false;
    }
 
    if (o == m_overviewWidget) {
        // Filter out the mouse events if we are touching the overview widget
        // and the event was not synthesized in this function  from the touch events
        if (e->type() == QEvent::MouseButtonPress) {
            if (m_isTouching) {
                return static_cast<QMouseEvent*>(e)->source() != Qt::MouseEventSynthesizedByApplication;
            }
 
        } else if (e->type() == QEvent::MouseButtonRelease) {
            if (m_isTouching) {
                return static_cast<QMouseEvent*>(e)->source() != Qt::MouseEventSynthesizedByApplication;
            }
 
        } else if (e->type() == QEvent::MouseMove) {
            if (m_isTouching) {
                return static_cast<QMouseEvent*>(e)->source() != Qt::MouseEventSynthesizedByApplication;
            }
            if (!m_overviewWidget->isDragging() && m_areControlsHidden && !m_pinControls) {
                QMouseEvent *me = static_cast<QMouseEvent*>(e);
                constexpr double showControlsAreaRadiusSquared = showControlsAreaRadius * showControlsAreaRadius;
                const QPointF d = me->localPos() - m_lastOverviewMousePos;
                const double distanceSquared = d.x() * d.x() + d.y() * d.y();
                if (distanceSquared > m_cumulatedMouseDistanceSquared) {
                    if (distanceSquared >= showControlsAreaRadiusSquared) {
                        showControls(showControlsTimerDuration);
                        m_lastOverviewMousePos = me->localPos();
                        m_cumulatedMouseDistanceSquared = 0.0;
                    } else {
                        m_cumulatedMouseDistanceSquared = distanceSquared;
                    }
                }
            }
 
        } else if (e->type() == QEvent::TouchBegin) {
            if (!m_isTouching) {
                QTouchEvent *te = static_cast<QTouchEvent*>(e);
                m_isTouching = true;
                // Store the first touch point. We will only track this one
                m_touchPointId = te->touchPoints().first().id();
                m_lastTouchPos = te->touchPoints().first().pos();
            }
            // Accept the event so that other touch events keep coming
            e->accept();
            return true;
 
        } else if (e->type() == QEvent::TouchUpdate) {
            if (!m_isTouching) {
                return true;
            }
            QTouchEvent *te = static_cast<QTouchEvent*>(e);
            // Get the touch point position
            QPointF currentPosition;
            for (const QTouchEvent::TouchPoint &touchPoint : te->touchPoints()) {
                if (touchPoint.id() == m_touchPointId) {
                    // If the touch point wasn't moved, this event wasn't
                    // generated from our touch point
                    if (touchPoint.state() == Qt::TouchPointStationary) {
                        return true;
                    }
                    currentPosition = touchPoint.pos();
                    break;
                }
            }
            if (!m_isDraggingWithTouch) {
                // Compute distance
                const QPointF delta = currentPosition - m_lastTouchPos;
                const qreal distanceSquared = delta.x() * delta.x() + delta.y() * delta.y();
                if (distanceSquared >= touchDragDistanceSquared) {
                    m_isDraggingWithTouch = true;
                    // synthesize mouse press event
                    QMouseEvent *se = new QMouseEvent(QEvent::MouseButtonPress,
                                                      m_lastTouchPos, QPointF(), QPointF(),
                                                      Qt::LeftButton, Qt::LeftButton, Qt::NoModifier,
                                                      Qt::MouseEventSynthesizedByApplication);
                    qApp->sendEvent(m_overviewWidget, se);
                }
            }
            if (m_isDraggingWithTouch) {
                // Synthesize mouse move event
                QMouseEvent *se = new QMouseEvent(QEvent::MouseMove,
                                                  currentPosition, QPointF(), QPointF(),
                                                  Qt::LeftButton, Qt::LeftButton, Qt::NoModifier,
                                                  Qt::MouseEventSynthesizedByApplication);
                qApp->sendEvent(m_overviewWidget, se);
                // Update
                m_lastTouchPos = currentPosition;
            }
            return true;
 
        } else if (e->type() == QEvent::TouchEnd || e->type() == QEvent::TouchCancel) {
            if (!m_isTouching) {
                return true;
            }
            QTouchEvent *te = static_cast<QTouchEvent*>(e);
            if (e->type() == QEvent::TouchEnd) {
                // If the touch point is not in the released state
                // then this event wasn't generated from our touch point
                for (const QTouchEvent::TouchPoint &touchPoint : te->touchPoints()) {
                    if (touchPoint.id() == m_touchPointId) {
                        if (touchPoint.state() != Qt::TouchPointReleased) {
                            return true;
                        }
                        break;
                    }
                }
            }
            // If we are dragging then synthesize mouse release event.
            // Show/hide the controls otherwise
            if (m_isDraggingWithTouch) {
                QMouseEvent *se = new QMouseEvent(QEvent::MouseButtonRelease,
                                                  m_lastTouchPos, QPointF(), QPointF(),
                                                  Qt::LeftButton, Qt::LeftButton, Qt::NoModifier,
                                                  Qt::MouseEventSynthesizedByApplication);
                qApp->sendEvent(m_overviewWidget, se);
            } else if (e->type() == QEvent::TouchEnd) {
                m_pinControls = m_areControlsHidden;
                KisSignalsBlocker blocker(m_pinControlsButton);
                m_pinControlsButton->setChecked(m_pinControls);
                if (m_areControlsHidden) {
                    showControls(0);
                } else {
                    hideControls(0);
                }
            }
            // Reset
            m_isTouching = false;
            m_isDraggingWithTouch = false;
            return true;
        }
    }
    return false;
}

References hideControls(), OverviewWidget::isDragging(), m_areControlsHidden, m_cumulatedMouseDistanceSquared, m_isDraggingWithTouch, m_isTouching, m_lastOverviewMousePos, m_lastTouchPos, m_overviewWidget, m_pinControls, m_pinControlsButton, m_touchPointId, showControls(), showControlsAreaRadius, showControlsTimerDuration, source(), and touchDragDistanceSquared.

hideControls

void OverviewDockerPage::hideControls ( int delay ) const

privateslot

Definition at line 461 of file overviewdocker_page.cpp.

{
    auto animFunction =
        [this]() -> void
        {
            int animationDuration;
            qreal animationStartValue;
 
            if (!m_areControlsHidden) {
                if (m_showControlsAnimation.state() == QVariantAnimation::Running) {
                    m_showControlsAnimation.stop();
                    animationDuration =
                        static_cast<int>(std::round(m_showControlsAnimation.currentValue().toReal() * showControlsAnimationDuration));
                    animationStartValue = m_showControlsAnimation.currentValue().toReal();
                } else {
                    animationDuration = showControlsAnimationDuration;
                    animationStartValue = 1.0;
                }
            } else {
                animationDuration = 1;
                animationStartValue = 0.0;
            }
 
            m_areControlsHidden = true;
            m_showControlsAnimation.setStartValue(animationStartValue);
            m_showControlsAnimation.setEndValue(0.0);
            m_showControlsAnimation.setDuration(animationDuration);
            m_showControlsAnimation.start();
        };
 
    delay = qMax(delay, 0);
 
    m_showControlsTimer.disconnect();
    connect(&m_showControlsTimer, &QTimer::timeout, animFunction);
    m_showControlsTimer.start(delay);
}

References connect(), m_areControlsHidden, m_showControlsAnimation, m_showControlsTimer, and showControlsAnimationDuration.

layoutMainWidgets()

void OverviewDockerPage::layoutMainWidgets ( )

private

Definition at line 399 of file overviewdocker_page.cpp.

{
    this->setMinimumHeight(m_overviewWidget->minimumHeight() +
                             m_controlsContainer->minimumSizeHint().height());
 
    if (m_showControlsAnimation.state() == QVariantAnimation::Running) {
        const qreal pageHeight = static_cast<qreal>(this->height());
        const qreal controlsContainerHeight = static_cast<qreal>(m_controlsContainer->sizeHint().height());
        const qreal animationProgress = m_showControlsAnimation.currentValue().toReal();
        const int widgetLimitPosition = static_cast<int>(std::round(pageHeight - animationProgress * controlsContainerHeight));
        m_overviewWidget->setGeometry(0, 0, this->width(), widgetLimitPosition);
        m_controlsContainer->setGeometry(0, widgetLimitPosition, this->width(), static_cast<int>(controlsContainerHeight));
    } else {
        const int controlsContainerHeight = m_controlsContainer->sizeHint().height();
        if (m_pinControls || !m_areControlsHidden) {
            const int widgetLimitPosition = this->height() - controlsContainerHeight;
            m_overviewWidget->setGeometry(0, 0, this->width(), widgetLimitPosition);
            m_controlsContainer->setGeometry(0, widgetLimitPosition, this->width(), controlsContainerHeight);
        } else {
            m_overviewWidget->setGeometry(0, 0, this->width(), this->height());
            m_controlsContainer->setGeometry(0, this->height(), this->width(), controlsContainerHeight);
        }
    }
}

References m_areControlsHidden, m_controlsContainer, m_overviewWidget, m_pinControls, and m_showControlsAnimation.

leaveEvent()

void OverviewDockerPage::leaveEvent ( QEvent * )

overrideprotected

Definition at line 231 of file overviewdocker_page.cpp.

{
    m_cursorIsHover = false;
    if (isEnabled() && !m_pinControls) {
        hideControls(0);
        m_cumulatedMouseDistanceSquared = 0.0;
    }
}

References hideControls(), m_cumulatedMouseDistanceSquared, m_cursorIsHover, and m_pinControls.

mirrorUpdateIcon

void OverviewDockerPage::mirrorUpdateIcon ( )

slot

Definition at line 197 of file overviewdocker_page.cpp.

{
    if(!m_mirrorCanvas) return;
    m_mirrorCanvas->setIcon(KisIconUtils::loadIcon("mirror-view-16"));
}

References KisIconUtils::loadIcon(), and m_mirrorCanvas.

on_overviewWidget_signalDraggingFinished

void OverviewDockerPage::on_overviewWidget_signalDraggingFinished ( )

privateslot

Definition at line 505 of file overviewdocker_page.cpp.

{
    if (!m_pinControls && m_areControlsHidden && !m_isTouching) {
        showControls(showControlsTimerDuration);
    }
}

References m_areControlsHidden, m_isTouching, m_pinControls, showControls(), and showControlsTimerDuration.

on_overviewWidget_signalDraggingStarted

void OverviewDockerPage::on_overviewWidget_signalDraggingStarted ( )

privateslot

Definition at line 498 of file overviewdocker_page.cpp.

{
    if (!m_pinControls && m_areControlsHidden && m_showControlsTimer.isActive()) {
        m_showControlsTimer.stop();
    }
}

References m_areControlsHidden, m_pinControls, and m_showControlsTimer.

resizeEvent()

void OverviewDockerPage::resizeEvent ( QResizeEvent * )

overrideprotected

Definition at line 226 of file overviewdocker_page.cpp.

{
    layoutMainWidgets();
}

References layoutMainWidgets().

rotateCanvasView

void OverviewDockerPage::rotateCanvasView ( qreal rotation )

slot

Definition at line 203 of file overviewdocker_page.cpp.

{
    if (!m_canvas) return;
    KisCanvasController *canvasController =
            dynamic_cast<KisCanvasController*>(m_canvas->viewManager()->canvasBase()->canvasController());
    if (canvasController) {
        canvasController->rotateCanvas(rotation-m_canvas->rotationAngle());
    }
}

References m_canvas, and KisCanvasController::rotateCanvas().

setCanvas()

void OverviewDockerPage::setCanvas

(

KoCanvasBase *

canvas

)

Definition at line 78 of file overviewdocker_page.cpp.

{
    if(m_canvas == canvas)
        return;
 
    setEnabled(canvas != nullptr);
 
    if (m_canvas) {
        m_canvas->disconnectCanvasObserver(this);
        m_canvas->image()->disconnect(this);
        m_canvas = nullptr;
    }
 
    if (m_zoomSlider) {
        m_controlsSecondRowLayout->removeWidget(m_zoomSlider);
        delete m_zoomSlider;
        m_zoomSlider = nullptr;
    }
 
    if (m_rotateAngleSelector) {
        m_controlsSecondRowLayout->removeWidget(m_rotateAngleSelector);
        delete m_rotateAngleSelector;
        m_rotateAngleSelector = nullptr;
    }
 
    if (m_mirrorCanvas) {
        m_controlsSecondRowLayout->removeWidget(m_mirrorCanvas);
        delete m_mirrorCanvas;
        m_mirrorCanvas = nullptr;
    }
 
    if (m_pinControlsButton) {
        m_controlsSecondRowLayout->removeWidget(m_pinControlsButton);
        delete m_pinControlsButton;
        m_pinControlsButton = nullptr;
    }
 
    // Delete the stretch
    while (m_controlsSecondRowLayout && m_controlsSecondRowLayout->count() && m_controlsSecondRowLayout->itemAt(0)->spacerItem()) {
        delete m_controlsSecondRowLayout->takeAt(0);
    }
 
    m_controlsLayout->removeItem(m_controlsSecondRowLayout);
 
    delete m_controlsSecondRowLayout;
    m_controlsSecondRowLayout = nullptr;
 
    m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
    m_overviewWidget->setCanvas(m_canvas);
    if (m_canvas && m_canvas->viewManager()) {
        bool usePrintResolutionMode = m_canvas->imageView()->canvasController()->usePrintResolutionMode();
        m_zoomSlider = m_canvas->imageView()->zoomManager()->zoomAction()->createWidget(m_canvas->imageView()->KisView::statusBar());
        KoZoomWidget* zoomWidget = static_cast<KoZoomWidget*>(m_zoomSlider);
        zoomWidget->setZoomInputFlat(false);
        zoomWidget->setUsePrintResolutionMode(usePrintResolutionMode);
        m_controlsLayout->addWidget(m_zoomSlider);
 
        m_rotateAngleSelector = new KisAngleSelector();
        m_rotateAngleSelector->setRange(-360.00, 360.0);
        m_rotateAngleSelector->setAngle(m_canvas->rotationAngle());
        m_rotateAngleSelector->setIncreasingDirection(KisAngleGauge::IncreasingDirection_Clockwise);
        m_rotateAngleSelector->setFlipOptionsMode(KisAngleSelector::FlipOptionsMode_ContextMenu);
        connect(m_rotateAngleSelector, SIGNAL(angleChanged(qreal)), this, SLOT(rotateCanvasView(qreal)), Qt::UniqueConnection);
        connect(m_canvas->canvasController()->proxyObject, SIGNAL(documentRotationChanged(qreal)), this, SLOT(updateRotationSlider(qreal)));
 
        m_mirrorCanvas = new QToolButton();
        QList<QAction *> actions = m_canvas->viewManager()->actionCollection()->actions();
        Q_FOREACH(QAction* action, actions) {
            if (action->objectName()=="mirror_canvas") {
                m_mirrorCanvas->setDefaultAction(action);
            }
        }
        m_mirrorCanvas->setIcon(KisIconUtils::loadIcon("mirror-view-16"));
        m_mirrorCanvas->setAutoRaise(true);
        connect(m_mirrorCanvas, SIGNAL(toggled(bool)), this, SLOT(mirrorUpdateIcon()));
 
        m_pinControlsButton = new QToolButton;
        m_pinControlsButton->setCheckable(true);
        m_pinControlsButton->setChecked(m_pinControls);
        m_pinControlsButton->setToolTip(
            i18nc("Make the controls in the overview docker auto-hide or always visible", "Pin navigation controls")
        );
        m_pinControlsButton->setIcon(KisIconUtils::loadIcon("krita_tool_reference_images"));
        m_pinControlsButton->setAutoRaise(true);
        connect(m_pinControlsButton, SIGNAL(toggled(bool)), SLOT(setPinControls(bool)));
 
        m_controlsSecondRowLayout = new QHBoxLayout();
 
        m_controlsSecondRowLayout->addWidget(m_rotateAngleSelector);
        m_controlsSecondRowLayout->addStretch();
        m_controlsSecondRowLayout->addWidget(m_mirrorCanvas);
        m_controlsSecondRowLayout->addStretch();
        m_controlsSecondRowLayout->addWidget(m_pinControlsButton);
        m_controlsLayout->addLayout(m_controlsSecondRowLayout);
 
        //m_zoomSlider->setVisible(true);
        m_rotateAngleSelector->setVisible(true);
 
        // Show/hide the controls
        if (m_pinControls) {
            showControls(0);
        } else {
            if (m_cursorIsHover) {
                showControls(0);
            } else {
                hideControls(0);
            }
        }
    }
}

References connect(), KisAngleSelector::FlipOptionsMode_ContextMenu, hideControls(), KisAngleGauge::IncreasingDirection_Clockwise, KisIconUtils::loadIcon(), m_canvas, m_controlsLayout, m_controlsSecondRowLayout, m_cursorIsHover, m_mirrorCanvas, m_overviewWidget, m_pinControls, m_pinControlsButton, m_rotateAngleSelector, m_zoomSlider, mirrorUpdateIcon(), rotateCanvasView(), KisAngleSelector::setAngle(), OverviewWidget::setCanvas(), KisAngleSelector::setFlipOptionsMode(), KisAngleSelector::setIncreasingDirection(), setPinControls(), KisAngleSelector::setRange(), KoZoomWidget::setUsePrintResolutionMode(), KoZoomWidget::setZoomInputFlat(), showControls(), and updateRotationSlider().

setPinControls

void OverviewDockerPage::setPinControls ( bool pin )

slot

Definition at line 221 of file overviewdocker_page.cpp.

{
    m_pinControls = pin;
}

References m_pinControls.

showControls

void OverviewDockerPage::showControls ( int delay ) const

privateslot

Definition at line 424 of file overviewdocker_page.cpp.

{
    auto animFunction =
        [this]() -> void
        {
            int animationDuration;
            qreal animationStartValue;
 
            if (m_areControlsHidden) {
                if (m_showControlsAnimation.state() == QVariantAnimation::Running) {
                    m_showControlsAnimation.stop();
                    animationDuration =
                        static_cast<int>(std::round((1.0 - m_showControlsAnimation.currentValue().toReal()) * showControlsAnimationDuration));
                    animationStartValue = m_showControlsAnimation.currentValue().toReal();
                } else {
                    animationDuration = showControlsAnimationDuration;
                    animationStartValue = 0.0;
                }
            } else {
                animationDuration = 1;
                animationStartValue = 1.0;
            }
 
            m_areControlsHidden = false;
            m_showControlsAnimation.setStartValue(animationStartValue);
            m_showControlsAnimation.setEndValue(1.0);
            m_showControlsAnimation.setDuration(animationDuration);
            m_showControlsAnimation.start();
        };
 
    delay = qMax(delay, 0);
 
    m_showControlsTimer.disconnect();
    connect(&m_showControlsTimer, &QTimer::timeout, animFunction);
    m_showControlsTimer.start(delay);
}

References connect(), m_areControlsHidden, m_showControlsAnimation, m_showControlsTimer, and showControlsAnimationDuration.

unsetCanvas()

void OverviewDockerPage::unsetCanvas

(

)

Definition at line 190 of file overviewdocker_page.cpp.

{
    setEnabled(false);
    m_canvas = nullptr;
    m_overviewWidget->setCanvas(0);
}

References m_canvas, m_overviewWidget, and OverviewWidget::setCanvas().

updateRotationSlider

void OverviewDockerPage::updateRotationSlider ( qreal rotation )

slot

Definition at line 213 of file overviewdocker_page.cpp.

{
    if (qAbs(m_rotateAngleSelector->angle() - angle) > 0.01) {
        KisSignalsBlocker l(m_rotateAngleSelector);
        m_rotateAngleSelector->setAngle(m_canvas->rotationAngle());
    }
}

References KisAngleSelector::angle(), m_canvas, m_rotateAngleSelector, and KisAngleSelector::setAngle().

Member Data Documentation

m_areControlsHidden

bool OverviewDockerPage::m_areControlsHidden {false}

mutableprivate

Definition at line 74 of file overviewdocker_page.h.

{false};

m_canvas

QPointer<KisCanvas2> OverviewDockerPage::m_canvas

private

Definition at line 65 of file overviewdocker_page.h.

m_controlsContainer

QWidget* OverviewDockerPage::m_controlsContainer {nullptr}

private

Definition at line 60 of file overviewdocker_page.h.

{nullptr};

m_controlsLayout

QVBoxLayout* OverviewDockerPage::m_controlsLayout {nullptr}

private

Definition at line 57 of file overviewdocker_page.h.

{nullptr};

m_controlsSecondRowLayout

QHBoxLayout* OverviewDockerPage::m_controlsSecondRowLayout {nullptr}

private

Definition at line 58 of file overviewdocker_page.h.

{nullptr};

m_cumulatedMouseDistanceSquared

double OverviewDockerPage::m_cumulatedMouseDistanceSquared {0.0}

private

Definition at line 76 of file overviewdocker_page.h.

{0.0};

m_cursorIsHover

bool OverviewDockerPage::m_cursorIsHover {false}

private

Definition at line 67 of file overviewdocker_page.h.

{false};

m_isDraggingWithTouch

bool OverviewDockerPage::m_isDraggingWithTouch {false}

private

Definition at line 69 of file overviewdocker_page.h.

{false};

m_isTouching

bool OverviewDockerPage::m_isTouching {false}

private

Definition at line 68 of file overviewdocker_page.h.

{false};

m_lastOverviewMousePos

QPointF OverviewDockerPage::m_lastOverviewMousePos

private

Definition at line 75 of file overviewdocker_page.h.

m_lastTouchPos

QPointF OverviewDockerPage::m_lastTouchPos

private

Definition at line 71 of file overviewdocker_page.h.

m_mirrorCanvas

QToolButton* OverviewDockerPage::m_mirrorCanvas {nullptr}

private

Definition at line 63 of file overviewdocker_page.h.

{nullptr};

m_overviewWidget

OverviewWidget* OverviewDockerPage::m_overviewWidget {nullptr}

private

Definition at line 59 of file overviewdocker_page.h.

{nullptr};

m_pinControls

bool OverviewDockerPage::m_pinControls {true}

private

Definition at line 66 of file overviewdocker_page.h.

{true};

m_pinControlsButton

QToolButton* OverviewDockerPage::m_pinControlsButton {nullptr}

private

Definition at line 64 of file overviewdocker_page.h.

{nullptr};

m_rotateAngleSelector

KisAngleSelector* OverviewDockerPage::m_rotateAngleSelector {nullptr}

private

Definition at line 62 of file overviewdocker_page.h.

{nullptr};

m_showControlsAnimation

QVariantAnimation OverviewDockerPage::m_showControlsAnimation

mutableprivate

Definition at line 72 of file overviewdocker_page.h.

m_showControlsTimer

QTimer OverviewDockerPage::m_showControlsTimer

mutableprivate

Definition at line 73 of file overviewdocker_page.h.

m_touchPointId

int OverviewDockerPage::m_touchPointId {0}

private

Definition at line 70 of file overviewdocker_page.h.

{0};

m_zoomSlider

QWidget* OverviewDockerPage::m_zoomSlider {nullptr}

private

Definition at line 61 of file overviewdocker_page.h.

{nullptr};

showControlsAnimationDuration

constexpr double OverviewDockerPage::showControlsAnimationDuration {150.0}

staticconstexprprivate

Definition at line 53 of file overviewdocker_page.h.

{150.0};

showControlsAreaRadius

constexpr double OverviewDockerPage::showControlsAreaRadius {4.0}

staticconstexprprivate

Definition at line 52 of file overviewdocker_page.h.

{4.0};

showControlsTimerDuration

constexpr int OverviewDockerPage::showControlsTimerDuration {500}

staticconstexprprivate

Definition at line 50 of file overviewdocker_page.h.

{500};

touchDragDistance

constexpr double OverviewDockerPage::touchDragDistance {8.0}

staticconstexprprivate

Definition at line 54 of file overviewdocker_page.h.

{8.0};

touchDragDistanceSquared

constexpr double OverviewDockerPage::touchDragDistanceSquared {touchDragDistance * touchDragDistance}

staticconstexprprivate

Definition at line 55 of file overviewdocker_page.h.

{touchDragDistance * touchDragDistance};

---

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

• plugins/dockers/overview/overviewdocker_page.h
• plugins/dockers/overview/overviewdocker_page.cpp