summaryrefslogtreecommitdiffstats
path: root/kolourpaint/kpviewscrollablecontainer.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit47d455dd55be855e4cc691c32f687f723d9247ee (patch)
tree52e236aaa2576bdb3840ebede26619692fed6d7d /kolourpaint/kpviewscrollablecontainer.cpp
downloadtdegraphics-47d455dd55be855e4cc691c32f687f723d9247ee.tar.gz
tdegraphics-47d455dd55be855e4cc691c32f687f723d9247ee.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegraphics@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kolourpaint/kpviewscrollablecontainer.cpp')
-rw-r--r--kolourpaint/kpviewscrollablecontainer.cpp1390
1 files changed, 1390 insertions, 0 deletions
diff --git a/kolourpaint/kpviewscrollablecontainer.cpp b/kolourpaint/kpviewscrollablecontainer.cpp
new file mode 100644
index 00000000..637f71b7
--- /dev/null
+++ b/kolourpaint/kpviewscrollablecontainer.cpp
@@ -0,0 +1,1390 @@
+
+/*
+ Copyright (c) 2003,2004,2005 Clarence Dang <dang@kde.org>
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+
+ 1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#define DEBUG_KP_VIEW_SCROLLABLE_CONTAINER 0
+
+#include <kpviewscrollablecontainer.h>
+
+#include <qcursor.h>
+#include <qpainter.h>
+#include <qpen.h>
+#include <qpixmap.h>
+#include <qtimer.h>
+
+#include <kdebug.h>
+#include <klocale.h>
+
+#include <kpdefs.h>
+#include <kppixmapfx.h>
+#include <kpview.h>
+#include <kpwidgetmapper.h>
+
+
+// (Pulled from out of Thurston's hat)
+static const int DragScrollLeftTopMargin = 0;
+static const int DragScrollRightBottomMargin = 16; // scrollbarish
+static const int DragScrollInterval = 1000 / 10;
+static const int DragScrollInitialInterval = DragScrollInterval * 2;
+static const int DragScrollNumPixels = 5;
+static const int DragDistanceFromRectMaxFor1stMultiplier = 50;
+static const int DragDistanceFromRectMaxFor2ndMultiplier = 100;
+
+static const int GripSize = 7;
+static const int GripHandleSize = 7;
+
+
+kpGrip::kpGrip (GripType type,
+ QWidget *parent, const char *name)
+ : QWidget (parent, name),
+ m_type (type),
+ m_startPoint (KP_INVALID_POINT),
+ m_currentPoint (KP_INVALID_POINT),
+ m_shouldReleaseMouseButtons (false)
+{
+ setCursor (cursorForType (m_type));
+
+ setMouseTracking (true); // mouseMoveEvent's even when no mousebtn down
+
+ updatePixmap ();
+}
+
+kpGrip::~kpGrip ()
+{
+}
+
+
+// public
+kpGrip::GripType kpGrip::type () const
+{
+ return m_type;
+}
+
+
+// public static
+const QCursor &kpGrip::cursorForType (GripType type)
+{
+ switch (type)
+ {
+ case Bottom:
+ return Qt::sizeVerCursor;
+ break; // one day you'll forget
+
+ case Right:
+ return Qt::sizeHorCursor;
+ break; // one day you'll forget
+
+ case BottomRight:
+ return Qt::sizeFDiagCursor;
+ break; // one day you'll forget
+ }
+
+ return Qt::arrowCursor;
+}
+
+
+// public
+QRect kpGrip::hotRect (bool toGlobal) const
+{
+ QRect ret;
+
+ switch (m_type)
+ {
+ case Bottom:
+ {
+ const int handleX = (width () - GripHandleSize) / 2;
+ ret = QRect (handleX, 0,
+ GripHandleSize, height ());
+ break;
+ }
+ case Right:
+ {
+ const int handleY = (height () - GripHandleSize) / 2;
+ ret = QRect (0, handleY,
+ width (), GripHandleSize);
+ break;
+ }
+ case BottomRight:
+ // pixmap all opaque
+ ret = rect ();
+ break;
+
+ default:
+ return QRect ();
+ }
+
+ return (toGlobal ? QRect (mapToGlobal (ret.topLeft ()),
+ mapToGlobal (ret.bottomRight ()))
+ : ret);
+}
+
+
+// public
+bool kpGrip::isDrawing () const
+{
+ return (m_startPoint != KP_INVALID_POINT);
+}
+
+
+// public
+QString kpGrip::haventBegunDrawUserMessage () const
+{
+ return i18n ("Left drag the handle to resize the image.");
+}
+
+
+// public
+QString kpGrip::userMessage () const
+{
+ return m_userMessage;
+}
+
+// public
+void kpGrip::setUserMessage (const QString &message)
+{
+ // Don't do NOP checking here since another grip might have changed
+ // the message so an apparent NOP for this grip is not a NOP in the
+ // global sense (kpViewScrollableContainer::slotGripStatusMessageChanged()).
+
+ m_userMessage = message;
+ emit statusMessageChanged (message);
+}
+
+
+// protected
+void kpGrip::updatePixmap ()
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpGrip::updatePixmap() rect=" << rect () << endl;
+#endif
+ if (width () <= 0 || height () <= 0)
+ return;
+
+ QPixmap pixmap (width (), height ());
+ pixmap.fill (colorGroup ().highlight ());
+ kpPixmapFX::ensureTransparentAt (&pixmap, pixmap.rect ());
+ const QRect hr = hotRect ();
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "\thotRect=" << hr << endl;
+#endif
+ if (hr.isValid ())
+ kpPixmapFX::ensureOpaqueAt (&pixmap, hr);
+
+ setBackgroundPixmap (pixmap);
+ if (pixmap.mask ())
+ setMask (*pixmap.mask ());
+}
+
+
+// protected
+void kpGrip::cancel ()
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpGrip::cancel()" << endl;
+#endif
+ if (m_currentPoint == KP_INVALID_POINT)
+ return;
+
+ m_startPoint = KP_INVALID_POINT;
+ m_currentPoint = KP_INVALID_POINT;
+
+ setUserMessage (i18n ("Resize Image: Let go of all the mouse buttons."));
+ setCursor (Qt::arrowCursor);
+ m_shouldReleaseMouseButtons = true;
+
+ releaseKeyboard ();
+ emit cancelledDraw ();
+}
+
+
+// protected virtual [base QWidget]
+void kpGrip::keyReleaseEvent (QKeyEvent *e)
+{
+ if (m_startPoint != KP_INVALID_POINT &&
+ e->key () == Qt::Key_Escape)
+ {
+ cancel ();
+ }
+}
+
+// protected virtual [base QWidget]
+void kpGrip::mousePressEvent (QMouseEvent *e)
+{
+ if (m_startPoint == KP_INVALID_POINT &&
+ (e->stateAfter () & Qt::MouseButtonMask) == Qt::LeftButton)
+ {
+ m_startPoint = e->pos ();
+ m_currentPoint = e->pos ();
+ emit beganDraw ();
+ grabKeyboard ();
+
+ setUserMessage (i18n ("Resize Image: Right click to cancel."));
+ setCursor (cursorForType (m_type));
+ }
+ else
+ {
+ if (m_startPoint != KP_INVALID_POINT)
+ cancel ();
+ }
+}
+
+// public
+QPoint kpGrip::viewDeltaPoint () const
+{
+ if (m_startPoint == KP_INVALID_POINT)
+ return KP_INVALID_POINT;
+
+ const QPoint point = mapFromGlobal (QCursor::pos ());
+
+ // TODO: this is getting out of sync with m_currentPoint
+
+ return QPoint (((m_type & Right) ? point.x () - m_startPoint.x () : 0),
+ ((m_type & Bottom) ? point.y () - m_startPoint.y () : 0));
+
+}
+
+// public
+void kpGrip::mouseMovedTo (const QPoint &point, bool dueToDragScroll)
+{
+ if (m_startPoint == KP_INVALID_POINT)
+ return;
+
+ m_currentPoint = point;
+
+ emit continuedDraw (((m_type & Right) ? point.x () - m_startPoint.x () : 0),
+ ((m_type & Bottom) ? point.y () - m_startPoint.y () : 0),
+ dueToDragScroll);
+}
+
+// protected virtual [base QWidget]
+void kpGrip::mouseMoveEvent (QMouseEvent *e)
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpGrip::mouseMoveEvent() m_startPoint=" << m_startPoint
+ << " stateAfter=" << e->stateAfter ()
+ << endl;
+#endif
+
+ if (m_startPoint == KP_INVALID_POINT)
+ {
+ if ((e->stateAfter () & Qt::MouseButtonMask) == 0)
+ setUserMessage (haventBegunDrawUserMessage ());
+ return;
+ }
+
+ mouseMovedTo (e->pos (), false/*not due to drag scroll*/);
+}
+
+// protected virtual [base QWidget]
+void kpGrip::mouseReleaseEvent (QMouseEvent *e)
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpGrip::mouseReleaseEvent() m_startPoint=" << m_startPoint
+ << " stateAfter=" << e->stateAfter ()
+ << endl;
+#endif
+
+ if (m_startPoint != KP_INVALID_POINT)
+ {
+ const int dx = m_currentPoint.x () - m_startPoint.x (),
+ dy = m_currentPoint.y () - m_startPoint.y ();
+
+ m_currentPoint = KP_INVALID_POINT;
+ m_startPoint = KP_INVALID_POINT;
+
+ releaseKeyboard ();
+ emit endedDraw ((m_type & Right) ? dx : 0,
+ (m_type & Bottom) ? dy : 0);
+ }
+
+ if ((e->stateAfter () & Qt::MouseButtonMask) == 0)
+ {
+ m_shouldReleaseMouseButtons = false;
+ setUserMessage (QString::null);
+ setCursor (cursorForType (m_type));
+
+ releaseKeyboard ();
+ emit releasedAllButtons ();
+ }
+}
+
+
+// protected virtual [base QWidget]
+void kpGrip::resizeEvent (QResizeEvent *)
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpGrip::resizeEvent()" << endl;
+#endif
+ updatePixmap ();
+}
+
+
+// protected virtual [base QWidget]
+void kpGrip::enterEvent (QEvent * /*e*/)
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpGrip::enterEvent()"
+ << " m_startPoint=" << m_startPoint
+ << " shouldReleaseMouseButtons="
+ << m_shouldReleaseMouseButtons << endl;
+#endif
+
+ if (m_startPoint == KP_INVALID_POINT &&
+ !m_shouldReleaseMouseButtons)
+ {
+ #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "\tsending message" << endl;
+ #endif
+ setUserMessage (haventBegunDrawUserMessage ());
+ }
+}
+
+// protected virtual [base QWidget]
+void kpGrip::leaveEvent (QEvent * /*e*/)
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpGrip::leaveEvent()"
+ << " m_startPoint=" << m_startPoint
+ << " shouldReleaseMouseButtons="
+ << m_shouldReleaseMouseButtons << endl;
+#endif
+ if (m_startPoint == KP_INVALID_POINT &&
+ !m_shouldReleaseMouseButtons)
+ {
+ setUserMessage (QString::null);
+ }
+}
+
+
+// protected virtual [base QWidget]
+void kpGrip::paintEvent (QPaintEvent *e)
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER && 0
+ kdDebug () << "kpGrip::paintEvent(" << e->rect () << ")" << endl;
+#endif
+ QWidget::paintEvent (e);
+}
+
+
+// TODO: Are we checking for m_view == 0 often enough?
+kpViewScrollableContainer::kpViewScrollableContainer (kpMainWindow *parent,
+ const char *name)
+ : QScrollView ((QWidget *) parent, name, Qt::WStaticContents | Qt::WNoAutoErase),
+ m_mainWindow (parent),
+ m_contentsXSoon (-1), m_contentsYSoon (-1),
+ m_view (0),
+ m_bottomGrip (new kpGrip (kpGrip::Bottom, viewport (), "Bottom Grip")),
+ m_rightGrip (new kpGrip (kpGrip::Right, viewport (), "Right Grip")),
+ m_bottomRightGrip (new kpGrip (kpGrip::BottomRight, viewport (), "BottomRight Grip")),
+ m_docResizingGrip (0),
+ m_dragScrollTimer (new QTimer (this)),
+ m_zoomLevel (100),
+ m_scrollTimerRunOnce (false),
+ m_resizeRoundedLastViewX (-1), m_resizeRoundedLastViewY (-1),
+ m_resizeRoundedLastViewDX (0), m_resizeRoundedLastViewDY (0),
+ m_haveMovedFromOriginalDocSize (false)
+
+{
+ m_bottomGrip->setFixedHeight (GripSize);
+ m_bottomGrip->hide ();
+ addChild (m_bottomGrip);
+ connectGripSignals (m_bottomGrip);
+
+ m_rightGrip->setFixedWidth (GripSize);
+ m_rightGrip->hide ();
+ addChild (m_rightGrip);
+ connectGripSignals (m_rightGrip);
+
+ m_bottomRightGrip->setFixedSize (GripSize, GripSize);
+ m_bottomRightGrip->hide ();
+ addChild (m_bottomRightGrip);
+ connectGripSignals (m_bottomRightGrip);
+
+
+ connect (this, SIGNAL (contentsMoving (int, int)),
+ this, SLOT (slotContentsMoving (int, int)));
+
+ connect (m_dragScrollTimer, SIGNAL (timeout ()),
+ this, SLOT (slotDragScroll ()));
+}
+
+kpViewScrollableContainer::~kpViewScrollableContainer ()
+{
+}
+
+
+// public
+int kpViewScrollableContainer::contentsXSoon ()
+{
+ if (m_contentsXSoon < 0)
+ return contentsX ();
+ else
+ return m_contentsXSoon;
+}
+
+// public
+int kpViewScrollableContainer::contentsYSoon ()
+{
+ if (m_contentsYSoon < 0)
+ return contentsY ();
+ else
+ return m_contentsYSoon;
+}
+
+
+// protected
+void kpViewScrollableContainer::connectGripSignals (kpGrip *grip)
+{
+ connect (grip, SIGNAL (beganDraw ()),
+ this, SLOT (slotGripBeganDraw ()));
+ connect (grip, SIGNAL (continuedDraw (int, int, bool)),
+ this, SLOT (slotGripContinuedDraw (int, int, bool)));
+ connect (grip, SIGNAL (cancelledDraw ()),
+ this, SLOT (slotGripCancelledDraw ()));
+ connect (grip, SIGNAL (endedDraw (int, int)),
+ this, SLOT (slotGripEndedDraw (int, int)));
+
+ connect (grip, SIGNAL (statusMessageChanged (const QString &)),
+ this, SLOT (slotGripStatusMessageChanged (const QString &)));
+
+ connect (grip, SIGNAL (releasedAllButtons ()),
+ this, SLOT (recalculateStatusMessage ()));
+}
+
+
+// public
+QSize kpViewScrollableContainer::newDocSize () const
+{
+ return newDocSize (m_resizeRoundedLastViewDX,
+ m_resizeRoundedLastViewDY);
+}
+
+// public
+bool kpViewScrollableContainer::haveMovedFromOriginalDocSize () const
+{
+ return m_haveMovedFromOriginalDocSize;
+}
+
+// public
+QString kpViewScrollableContainer::statusMessage () const
+{
+ return m_gripStatusMessage;
+}
+
+// public
+void kpViewScrollableContainer::clearStatusMessage ()
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER && 1
+ kdDebug () << "kpViewScrollableContainer::clearStatusMessage()" << endl;
+#endif
+ m_bottomRightGrip->setUserMessage (QString::null);
+ m_bottomGrip->setUserMessage (QString::null);
+ m_rightGrip->setUserMessage (QString::null);
+}
+
+
+// protected
+QSize kpViewScrollableContainer::newDocSize (int viewDX, int viewDY) const
+{
+ if (!m_view)
+ return QSize ();
+
+ if (!docResizingGrip ())
+ return QSize ();
+
+ const int docX = (int) m_view->transformViewToDocX (m_view->width () + viewDX);
+ const int docY = (int) m_view->transformViewToDocY (m_view->height () + viewDY);
+
+ return QSize (QMAX (1, docX), QMAX (1, docY));
+}
+
+
+// protected
+void kpViewScrollableContainer::calculateDocResizingGrip ()
+{
+ if (m_bottomRightGrip->isDrawing ())
+ m_docResizingGrip = m_bottomRightGrip;
+ else if (m_bottomGrip->isDrawing ())
+ m_docResizingGrip = m_bottomGrip;
+ else if (m_rightGrip->isDrawing ())
+ m_docResizingGrip = m_rightGrip;
+ else
+ m_docResizingGrip = 0;
+}
+
+// protected
+kpGrip *kpViewScrollableContainer::docResizingGrip () const
+{
+ return m_docResizingGrip;
+}
+
+
+// protected
+int kpViewScrollableContainer::bottomResizeLineWidth () const
+{
+ if (!docResizingGrip ())
+ return -1;
+
+ if (!m_view)
+ return -1;
+
+ if (docResizingGrip ()->type () & kpGrip::Bottom)
+ return QMAX (m_view->zoomLevelY () / 100, 1);
+ else
+ return 1;
+}
+
+// protected
+int kpViewScrollableContainer::rightResizeLineWidth () const
+{
+ if (!docResizingGrip ())
+ return -1;
+
+ if (!m_view)
+ return -1;
+
+ if (docResizingGrip ()->type () & kpGrip::Right)
+ return QMAX (m_view->zoomLevelX () / 100, 1);
+ else
+ return 1;
+}
+
+
+// protected
+QRect kpViewScrollableContainer::bottomResizeLineRect () const
+{
+ if (m_resizeRoundedLastViewX < 0 || m_resizeRoundedLastViewY < 0)
+ return QRect ();
+
+ return QRect (QPoint (0,
+ m_resizeRoundedLastViewY),
+ QPoint (m_resizeRoundedLastViewX - 1,
+ m_resizeRoundedLastViewY + bottomResizeLineWidth () - 1));
+}
+
+// protected
+QRect kpViewScrollableContainer::rightResizeLineRect () const
+{
+ if (m_resizeRoundedLastViewX < 0 || m_resizeRoundedLastViewY < 0)
+ return QRect ();
+
+ return QRect (QPoint (m_resizeRoundedLastViewX,
+ 0),
+ QPoint (m_resizeRoundedLastViewX + rightResizeLineWidth () - 1,
+ m_resizeRoundedLastViewY - 1));
+}
+
+// protected
+QRect kpViewScrollableContainer::bottomRightResizeLineRect () const
+{
+ if (m_resizeRoundedLastViewX < 0 || m_resizeRoundedLastViewY < 0)
+ return QRect ();
+
+ return QRect (QPoint (m_resizeRoundedLastViewX,
+ m_resizeRoundedLastViewY),
+ QPoint (m_resizeRoundedLastViewX + rightResizeLineWidth () - 1,
+ m_resizeRoundedLastViewY + bottomResizeLineWidth () - 1));
+}
+
+
+// TODO: are these 2 correct? Remember that viewport()->x() == 1, viewport()->y() == 1
+
+// protected
+QPoint kpViewScrollableContainer::mapViewToViewport (const QPoint &viewPoint)
+{
+ return viewPoint - QPoint (contentsX (), contentsY ());
+}
+
+// protected
+QRect kpViewScrollableContainer::mapViewToViewport (const QRect &viewRect)
+{
+ if (!viewRect.isValid ())
+ return QRect ();
+
+ QRect ret = viewRect;
+ ret.moveBy (-contentsX (), -contentsY ());
+ return ret;
+}
+
+
+// protected
+QRect kpViewScrollableContainer::mapViewportToGlobal (const QRect &viewportRect)
+{
+ return kpWidgetMapper::toGlobal (viewport (), viewportRect);
+}
+
+// protected
+QRect kpViewScrollableContainer::mapViewToGlobal (const QRect &viewRect)
+{
+ return mapViewportToGlobal (mapViewToViewport (viewRect));
+}
+
+
+// protected
+void kpViewScrollableContainer::repaintWidgetAtResizeLineViewRect (
+ QWidget *widget, const QRect &resizeLineViewRect)
+{
+ const QRect resizeLineGlobalRect = mapViewToGlobal (resizeLineViewRect);
+ const QRect widgetGlobalRect = kpWidgetMapper::toGlobal (widget,
+ widget->rect ());
+
+ const QRect redrawGlobalRect =
+ resizeLineGlobalRect.intersect (widgetGlobalRect);
+
+ const QRect redrawWidgetRect =
+ kpWidgetMapper::fromGlobal (widget, redrawGlobalRect);
+
+
+ if (redrawWidgetRect.isValid ())
+ {
+ // TODO: should be "!widget->testWFlags (Qt::WRepaintNoErase)"
+ // but for some reason, doesn't work for viewport().
+ const bool erase = !dynamic_cast <kpView *> (widget);
+ widget->repaint (redrawWidgetRect, erase);
+ }
+}
+
+// protected
+void kpViewScrollableContainer::repaintWidgetAtResizeLines (QWidget *widget)
+{
+ repaintWidgetAtResizeLineViewRect (widget, rightResizeLineRect ());
+ repaintWidgetAtResizeLineViewRect (widget, bottomResizeLineRect ());
+ repaintWidgetAtResizeLineViewRect (widget, bottomRightResizeLineRect ());
+}
+
+// protected
+void kpViewScrollableContainer::eraseResizeLines ()
+{
+ if (m_resizeRoundedLastViewX >= 0 && m_resizeRoundedLastViewY >= 0)
+ {
+ repaintWidgetAtResizeLines (viewport ());
+ repaintWidgetAtResizeLines (m_view);
+
+ repaintWidgetAtResizeLines (m_bottomGrip);
+ repaintWidgetAtResizeLines (m_rightGrip);
+ repaintWidgetAtResizeLines (m_bottomRightGrip);
+ }
+}
+
+
+// protected
+void kpViewScrollableContainer::drawResizeLines ()
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER && 0
+ kdDebug () << "kpViewScrollableContainer::drawResizeLines()"
+ << " lastViewX=" << m_resizeRoundedLastViewX
+ << " lastViewY=" << m_resizeRoundedLastViewY
+ << endl;
+#endif
+
+
+ QPainter p (viewport (), true/*unclipped*/);
+ p.setRasterOp (Qt::NotROP);
+
+ const QRect rightRect = rightResizeLineRect ();
+ if (rightRect.isValid ())
+ p.fillRect (mapViewToViewport (rightRect), Qt::white);
+
+ const QRect bottomRect = bottomResizeLineRect ();
+ if (bottomRect.isValid ())
+ p.fillRect (mapViewToViewport (bottomRect), Qt::white);
+
+ const QRect bottomRightRect = bottomRightResizeLineRect ();
+ if (bottomRightRect.isValid ())
+ p.fillRect (mapViewToViewport (bottomRightRect), Qt::white);
+
+ p.end ();
+}
+
+
+// protected
+void kpViewScrollableContainer::updateResizeLines (int viewX, int viewY,
+ int viewDX, int viewDY)
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER && 0
+ kdDebug () << "kpViewScrollableContainer::updateResizeLines("
+ << viewX << "," << viewY << ")"
+ << " oldViewX=" << m_resizeRoundedLastViewX
+ << " oldViewY=" << m_resizeRoundedLastViewY
+ << " viewDX=" << viewDX
+ << " viewDY=" << viewDY
+ << endl;
+#endif
+
+ eraseResizeLines ();
+
+
+ if (viewX >= 0 && viewY >= 0)
+ {
+ m_resizeRoundedLastViewX = (int) m_view->transformDocToViewX ((int) m_view->transformViewToDocX (viewX));
+ m_resizeRoundedLastViewY = (int) m_view->transformDocToViewY ((int) m_view->transformViewToDocY (viewY));
+
+ m_resizeRoundedLastViewDX = viewDX;
+ m_resizeRoundedLastViewDY = viewDY;
+ }
+ else
+ {
+ m_resizeRoundedLastViewX = -1;
+ m_resizeRoundedLastViewY = -1;
+
+ m_resizeRoundedLastViewDX = 0;
+ m_resizeRoundedLastViewDY = 0;
+ }
+
+ // TODO: This is suboptimal since if another window pops up on top of
+ // KolourPaint then disappears, the lines are not redrawn
+ // (although this doesn't happen very frequently since we grab the
+ // keyboard and mouse when resizing):
+ //
+ // e.g. sleep 5 && gedit & sleep 10 && killall gedit
+ //
+ // Should be done in the paintEvent's of every child of the
+ // scrollview.
+ drawResizeLines ();
+}
+
+
+// protected slot
+void kpViewScrollableContainer::slotGripBeganDraw ()
+{
+ if (!m_view)
+ return;
+
+ calculateDocResizingGrip ();
+
+ m_haveMovedFromOriginalDocSize = false;
+
+ updateResizeLines (m_view->width (), m_view->height (),
+ 0/*viewDX*/, 0/*viewDY*/);
+
+ emit beganDocResize ();
+}
+
+// protected slot
+void kpViewScrollableContainer::slotGripContinuedDraw (int inViewDX, int inViewDY,
+ bool dueToDragScroll)
+{
+ int viewDX = inViewDX,
+ viewDY = inViewDY;
+
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpViewScrollableContainer::slotGripContinuedDraw("
+ << viewDX << "," << viewDY << ") size="
+ << newDocSize (viewDX, viewDY)
+ << " dueToDragScroll=" << dueToDragScroll
+ << endl;
+#endif
+
+ if (!m_view)
+ return;
+
+ if (!dueToDragScroll &&
+ beginDragScroll (QPoint (), QPoint (), m_view->zoomLevelX ()))
+ {
+ const QPoint newViewDeltaPoint = docResizingGrip ()->viewDeltaPoint ();
+ viewDX = newViewDeltaPoint.x ();
+ viewDY = newViewDeltaPoint.y ();
+ #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "\tdrag scrolled - new view delta point="
+ << newViewDeltaPoint
+ << endl;
+ #endif
+ }
+
+ m_haveMovedFromOriginalDocSize = true;
+
+ updateResizeLines (QMAX (1, QMAX (m_view->width () + viewDX, (int) m_view->transformDocToViewX (1))),
+ QMAX (1, QMAX (m_view->height () + viewDY, (int) m_view->transformDocToViewY (1))),
+ viewDX, viewDY);
+
+ emit continuedDocResize (newDocSize ());
+}
+
+// protected slot
+void kpViewScrollableContainer::slotGripCancelledDraw ()
+{
+ m_haveMovedFromOriginalDocSize = false;
+
+ updateResizeLines (-1, -1, 0, 0);
+
+ calculateDocResizingGrip ();
+
+ emit cancelledDocResize ();
+
+ endDragScroll ();
+}
+
+// protected slot
+void kpViewScrollableContainer::slotGripEndedDraw (int viewDX, int viewDY)
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpViewScrollableContainer::slotGripEndedDraw("
+ << viewDX << "," << viewDY << ") size="
+ << newDocSize (viewDX, viewDY)
+ << endl;
+#endif
+
+ if (!m_view)
+ return;
+
+ const QSize newSize = newDocSize (viewDX, viewDY);
+
+ m_haveMovedFromOriginalDocSize = false;
+
+ // must erase lines before view size changes
+ updateResizeLines (-1, -1, 0, 0);
+
+ calculateDocResizingGrip ();
+
+ emit endedDocResize (newSize);
+
+ endDragScroll ();
+}
+
+
+// protected slot
+void kpViewScrollableContainer::slotGripStatusMessageChanged (const QString &string)
+{
+ if (string == m_gripStatusMessage)
+ return;
+
+ m_gripStatusMessage = string;
+ emit statusMessageChanged (string);
+}
+
+
+// public slot
+void kpViewScrollableContainer::recalculateStatusMessage ()
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpViewScrollabelContainer::recalculateStatusMessage()" << endl;
+ kdDebug () << "\tQCursor::pos=" << QCursor::pos ()
+ << " global visibleRect="
+ << kpWidgetMapper::toGlobal (this,
+ QRect (0, 0, visibleWidth (), visibleHeight ()))
+ << " brGrip.hotRect=" << m_bottomRightGrip->hotRect (true)
+ << " bGrip.hotRect=" << m_bottomGrip->hotRect (true)
+ << " rGrip.hotRect=" << m_rightGrip->hotRect (true)
+ << endl;
+#endif
+
+ // HACK: After dragging to a new size, handles move so that they are now
+ // under the mouse pointer but no mouseMoveEvent() is generated for
+ // any grip. This also handles the case of cancelling over any
+ // grip.
+ //
+ if (kpWidgetMapper::toGlobal (this,
+ QRect (0, 0, visibleWidth (), visibleHeight ()))
+ .contains (QCursor::pos ()))
+ {
+ if (m_bottomRightGrip->isShown () &&
+ m_bottomRightGrip->hotRect (true/*to global*/)
+ .contains (QCursor::pos ()))
+ {
+ m_bottomRightGrip->setUserMessage (i18n ("Left drag the handle to resize the image."));
+ }
+ else if (m_bottomGrip->isShown () &&
+ m_bottomGrip->hotRect (true/*to global*/)
+ .contains (QCursor::pos ()))
+ {
+ m_bottomGrip->setUserMessage (i18n ("Left drag the handle to resize the image."));
+ }
+ else if (m_rightGrip->isShown () &&
+ m_rightGrip->hotRect (true/*to global*/)
+ .contains (QCursor::pos ()))
+ {
+ m_rightGrip->setUserMessage (i18n ("Left drag the handle to resize the image."));
+ }
+ else
+ {
+ clearStatusMessage ();
+ }
+ }
+ else
+ {
+ clearStatusMessage ();
+ }
+}
+
+
+// protected slot
+void kpViewScrollableContainer::slotContentsMoving (int x, int y)
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpViewScrollableContainer::slotContentsMoving("
+ << x << "," << y << ")"
+ << " contentsX=" << contentsX ()
+ << " contentsY=" << contentsY () << endl;
+#endif
+
+ m_contentsXSoon = x, m_contentsYSoon = y;
+ emit contentsMovingSoon (m_contentsXSoon, m_contentsYSoon);
+
+ // Reduce flicker - don't let QScrollView scroll to-be-erased lines
+ eraseResizeLines ();
+
+ QTimer::singleShot (0, this, SLOT (slotContentsMoved ()));
+}
+
+// protected slot
+void kpViewScrollableContainer::slotContentsMoved ()
+{
+ m_contentsXSoon = m_contentsYSoon = -1;
+
+ kpGrip *grip = docResizingGrip ();
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpViewScrollableContainer::slotContentsMoved()"
+ << " grip=" << grip
+ << " contentsX=" << contentsX ()
+ << " contentsY=" << contentsY () << endl;
+#endif
+ if (!grip)
+ return;
+
+ grip->mouseMovedTo (grip->mapFromGlobal (QCursor::pos ()),
+ true/*moved due to drag scroll*/);
+}
+
+
+// protected
+void kpViewScrollableContainer::disconnectViewSignals ()
+{
+ disconnect (m_view, SIGNAL (sizeChanged (const QSize &)),
+ this, SLOT (updateGrips ()));
+ disconnect (m_view, SIGNAL (destroyed ()),
+ this, SLOT (slotViewDestroyed ()));
+}
+
+// protected
+void kpViewScrollableContainer::connectViewSignals ()
+{
+ connect (m_view, SIGNAL (sizeChanged (const QSize &)),
+ this, SLOT (updateGrips ()));
+ connect (m_view, SIGNAL (destroyed ()),
+ this, SLOT (slotViewDestroyed ()));
+}
+
+
+// public virtual [base QScrollView]
+void kpViewScrollableContainer::addChild (QWidget *widget, int x, int y)
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpViewScrollableContainer::addChild(" << widget
+ << "," << x << "," << y << endl;
+#endif
+
+ QScrollView::addChild (widget, x, y);
+
+ kpView *view = dynamic_cast <kpView *> (widget);
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "\tcast to kpView: " << view << endl;
+#endif
+ if (view)
+ {
+ setView (view);
+ }
+}
+
+
+// public
+kpView *kpViewScrollableContainer::view () const
+{
+ return m_view;
+}
+
+// public
+void kpViewScrollableContainer::setView (kpView *view)
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpViewScrollableContainer::setView(" << view << ")" << endl;
+#endif
+
+ if (m_view == view)
+ return;
+
+ if (m_view)
+ {
+ disconnectViewSignals ();
+ }
+
+ m_view = view;
+
+ updateGrips ();
+
+ if (m_view)
+ {
+ connectViewSignals ();
+ }
+}
+
+
+// public slot
+void kpViewScrollableContainer::updateGrips ()
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpViewScrollableContainer::updateGrips() m_view="
+ << m_view << endl;
+#endif
+
+ if (m_view)
+ {
+ m_bottomGrip->setFixedWidth (m_view->width ());
+ moveChild (m_bottomGrip, 0, m_view->height ());
+
+ m_rightGrip->setFixedHeight (m_view->height ());
+ moveChild (m_rightGrip, m_view->width (), 0);
+
+ moveChild (m_bottomRightGrip, m_view->width (), m_view->height ());
+ }
+
+ m_bottomGrip->setShown (bool (m_view));
+ m_rightGrip->setShown (bool (m_view));
+ m_bottomRightGrip->setShown (bool (m_view));
+
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "\tcontentsRect=" << contentsRect ()
+ << " visibleRect=" << visibleRect ()
+ << " viewportRect=" << viewport ()->rect ()
+ << endl;
+#endif
+
+ if (m_view)
+ {
+ resizeContents (m_view->width () + m_rightGrip->width (),
+ m_view->height () + m_bottomGrip->height ());
+ }
+ else
+ {
+ resizeContents (0, 0);
+ }
+
+ recalculateStatusMessage ();
+}
+
+// protected slot
+void kpViewScrollableContainer::slotViewDestroyed ()
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpViewScrollableContainer::slotViewDestroyed() m_view="
+ << m_view << endl;
+#endif
+
+ m_view = 0;
+ updateGrips ();
+}
+
+
+// public slot
+bool kpViewScrollableContainer::beginDragScroll (const QPoint &/*docPoint*/,
+ const QPoint &/*lastDocPoint*/,
+ int zoomLevel,
+ bool *didSomething)
+{
+ if (didSomething)
+ *didSomething = false;
+
+ m_zoomLevel = zoomLevel;
+
+ const QPoint p = mapFromGlobal (QCursor::pos ());
+
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpViewScrollableContainer::beginDragScroll() p=" << p
+ << " dragScrollTimerRunOnce=" << m_scrollTimerRunOnce
+ << endl;
+#endif
+
+ bool stopDragScroll = true;
+ bool scrolled = false;
+
+ if (!noDragScrollRect ().contains (p))
+ {
+ if (m_dragScrollTimer->isActive ())
+ {
+ if (m_scrollTimerRunOnce)
+ {
+ scrolled = slotDragScroll ();
+ }
+ }
+ else
+ {
+ m_scrollTimerRunOnce = false;
+ m_dragScrollTimer->start (DragScrollInitialInterval);
+ }
+
+ stopDragScroll = false;
+ }
+
+ if (stopDragScroll)
+ m_dragScrollTimer->stop ();
+
+ if (didSomething)
+ *didSomething = scrolled;
+
+ return scrolled;
+}
+
+// public slot
+bool kpViewScrollableContainer::beginDragScroll (const QPoint &docPoint,
+ const QPoint &lastDocPoint,
+ int zoomLevel)
+{
+ return beginDragScroll (docPoint, lastDocPoint, zoomLevel,
+ 0/*don't want scrolled notification*/);
+}
+
+
+// public slot
+bool kpViewScrollableContainer::endDragScroll ()
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpViewScrollableContainer::endDragScroll()" << endl;
+#endif
+
+ if (m_dragScrollTimer->isActive ())
+ {
+ m_dragScrollTimer->stop ();
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+}
+
+
+static const int distanceFromRectToMultiplier (int dist)
+{
+ if (dist < 0)
+ return 0;
+ else if (dist < DragDistanceFromRectMaxFor1stMultiplier)
+ return 1;
+ else if (dist < DragDistanceFromRectMaxFor2ndMultiplier)
+ return 2;
+ else
+ return 4;
+}
+
+
+// protected slot
+bool kpViewScrollableContainer::slotDragScroll (bool *didSomething)
+{
+ bool scrolled = false;
+
+ if (didSomething)
+ *didSomething = false;
+
+
+ const QRect rect = noDragScrollRect ();
+ const QPoint pos = mapFromGlobal (QCursor::pos ());
+
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpViewScrollableContainer::slotDragScroll()"
+ << " noDragScrollRect=" << rect
+ << " pos=" << pos
+ << " contentsX=" << contentsX ()
+ << " contentsY=" << contentsY () << endl;
+#endif
+
+ int dx = 0, dy = 0;
+ int dxMultiplier = 0, dyMultiplier = 0;
+
+ if (pos.x () < rect.left ())
+ {
+ dx = -DragScrollNumPixels;
+ dxMultiplier = distanceFromRectToMultiplier (rect.left () - pos.x ());
+ }
+ else if (pos.x () > rect.right ())
+ {
+ dx = +DragScrollNumPixels;
+ dxMultiplier = distanceFromRectToMultiplier (pos.x () - rect.right ());
+ }
+
+ if (pos.y () < rect.top ())
+ {
+ dy = -DragScrollNumPixels;
+ dyMultiplier = distanceFromRectToMultiplier (rect.top () - pos.y ());
+ }
+ else if (pos.y () > rect.bottom ())
+ {
+ dy = +DragScrollNumPixels;
+ dyMultiplier = distanceFromRectToMultiplier (pos.y () - rect.bottom ());
+ }
+
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER && 0
+ kdDebug () << "kpViewScrollableContainer::slotDragScroll()"
+ << " dx=" << dx << " * " << dxMultiplier
+ << " dy=" << dy << " * " << dyMultiplier
+ << " zoomLevel=" << m_zoomLevel
+ << endl;
+#endif
+
+ dx *= dxMultiplier;// * QMAX (1, m_zoomLevel / 100);
+ dy *= dyMultiplier;// * QMAX (1, m_zoomLevel / 100);
+
+ if (dx || dy)
+ {
+ const int oldContentsX = contentsX (),
+ oldContentsY = contentsY ();
+
+ scrollBy (dx, dy);
+
+ #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER && 1
+ kdDebug () << "\tafter scrollBy():"
+ << " contentsX=" << contentsX ()
+ << " contentsY=" << contentsY () << endl;
+ #endif
+
+ scrolled = (oldContentsX != contentsX () ||
+ oldContentsY != contentsY ());
+
+ if (scrolled)
+ {
+ QRegion region = QRect (contentsX (), contentsY (),
+ visibleWidth (), visibleHeight ());
+ region -= QRect (oldContentsX, oldContentsY,
+ visibleWidth (), visibleHeight ());
+
+ // Repaint newly exposed region immediately to reduce tearing
+ // of scrollView.
+ m_view->repaint (region, false/*no erase*/);
+ }
+ }
+
+
+ m_dragScrollTimer->changeInterval (DragScrollInterval);
+ m_scrollTimerRunOnce = true;
+
+
+ if (didSomething)
+ *didSomething = scrolled;
+
+ return scrolled;
+}
+
+// protected virtual [base QScrollView]
+void kpViewScrollableContainer::contentsDragMoveEvent (QDragMoveEvent *e)
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpViewScrollableContainer::contentsDragMoveEvent"
+ << e->pos ()
+ << endl;
+#endif
+
+ QScrollView::contentsDragMoveEvent (e);
+}
+
+// protected slot
+bool kpViewScrollableContainer::slotDragScroll ()
+{
+ return slotDragScroll (0/*don't want scrolled notification*/);
+}
+
+
+// protected virtual [base QScrollView]
+void kpViewScrollableContainer::contentsMouseMoveEvent (QMouseEvent *e)
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpViewScrollableContainer::contentsMouseMoveEvent"
+ << e->pos ()
+ << endl;
+#endif
+
+ QScrollView::contentsMouseMoveEvent (e);
+}
+
+// protected virtual [base QScrollView]
+void kpViewScrollableContainer::mouseMoveEvent (QMouseEvent *e)
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpViewScrollableContainer::mouseMoveEvent"
+ << e->pos ()
+ << endl;
+#endif
+
+ QScrollView::mouseMoveEvent (e);
+}
+
+
+// protected virtual [base QScrollView]
+void kpViewScrollableContainer::contentsWheelEvent (QWheelEvent *e)
+{
+ e->ignore ();
+
+ if (m_view)
+ m_view->wheelEvent (e);
+
+ if (!e->isAccepted ())
+ QScrollView::contentsWheelEvent (e);
+}
+
+
+QRect kpViewScrollableContainer::noDragScrollRect () const
+{
+ return QRect (DragScrollLeftTopMargin, DragScrollLeftTopMargin,
+ width () - DragScrollLeftTopMargin - DragScrollRightBottomMargin,
+ height () - DragScrollLeftTopMargin - DragScrollRightBottomMargin);
+}
+
+// protected virtual [base QScrollView]
+bool kpViewScrollableContainer::eventFilter (QObject *watchedObject, QEvent *event)
+{
+ return QScrollView::eventFilter (watchedObject, event);
+}
+
+// protected virtual [base QScrollView]
+void kpViewScrollableContainer::viewportPaintEvent (QPaintEvent *e)
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
+ kdDebug () << "kpViewScrollableContainer::viewportPaintEvent("
+ << e->rect ()
+ << ")" << endl;
+#endif
+
+ QScrollView::viewportPaintEvent (e);
+}
+
+// protected virtual [base QFrame]
+void kpViewScrollableContainer::paintEvent (QPaintEvent *e)
+{
+#if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER && 0
+ kdDebug () << "kpViewScrollableContainer::paintEvent("
+ << e->rect ()
+ << ")" << endl;
+#endif
+
+ QScrollView::paintEvent (e);
+}
+
+// protected virtual [base QScrollView]
+void kpViewScrollableContainer::resizeEvent (QResizeEvent *e)
+{
+ QScrollView::resizeEvent (e);
+
+ emit resized ();
+}
+
+
+#include <kpviewscrollablecontainer.moc>