From 47d455dd55be855e4cc691c32f687f723d9247ee Mon Sep 17 00:00:00 2001 From: toma Date: Wed, 25 Nov 2009 17:56:58 +0000 Subject: 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 --- kolourpaint/kpview.cpp | 1910 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1910 insertions(+) create mode 100644 kolourpaint/kpview.cpp (limited to 'kolourpaint/kpview.cpp') diff --git a/kolourpaint/kpview.cpp b/kolourpaint/kpview.cpp new file mode 100644 index 00000000..1f18c659 --- /dev/null +++ b/kolourpaint/kpview.cpp @@ -0,0 +1,1910 @@ + +/* + Copyright (c) 2003,2004,2005 Clarence Dang + 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 0 +#define DEBUG_KP_VIEW_RENDERER ((DEBUG_KP_VIEW && 0) || 0) + + +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if DEBUG_KP_VIEW || DEBUG_KP_VIEW_RENDERER + #include +#endif + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +struct kpViewPrivate +{ + // sync: kpView::paintEvent() + // + // Normally, these pointers must be valid while the kpView is alive. + // Generally, the objects they point to are deleted only after kpView + // is deleted. + // + // However, sometimes we use deleteLater() for the kpView. + // Before the delayed deletion is executed, those objects are deleted + // and then our paintEvent() is called. paintEvent() must therefore + // have some way of realising that those objects have been deleted so + // we use guardded pointers. + // + // For more details, see SVN commit: + // "r385274 | dang | 2005-02-02 22:08:27 +1100 (Wed, 02 Feb 2005) | 21 lines". + QGuardedPtr m_document; + QGuardedPtr m_toolToolBar; + QGuardedPtr m_viewManager; + QGuardedPtr m_buddyView; + QGuardedPtr m_scrollableContainer; + + int m_hzoom, m_vzoom; + QPoint m_origin; + bool m_showGrid; + bool m_isBuddyViewScrollableContainerRectangleShown; + QRect m_buddyViewScrollableContainerRectangle; + + QRegion m_queuedUpdateArea; + QPixmap *m_backBuffer; +}; + + +kpView::kpView (kpDocument *document, + kpToolToolBar *toolToolBar, + kpViewManager *viewManager, + kpView *buddyView, + kpViewScrollableContainer *scrollableContainer, + QWidget *parent, const char *name) + + : QWidget (parent, name, Qt::WNoAutoErase/*no flicker*/), + d (new kpViewPrivate ()) +{ + d->m_document = document; + d->m_toolToolBar = toolToolBar; + d->m_viewManager = viewManager; + d->m_buddyView = buddyView; + d->m_scrollableContainer = scrollableContainer; + + d->m_hzoom = 100, d->m_vzoom = 100; + d->m_origin = QPoint (0, 0); + d->m_showGrid = false; + d->m_isBuddyViewScrollableContainerRectangleShown = false; + + d->m_backBuffer = 0; + + + setBackgroundMode (Qt::NoBackground); // no flicker + setFocusPolicy (QWidget::WheelFocus); + setMouseTracking (true); // mouseMoveEvent's even when no mousebtn down + setKeyCompression (true); + setInputMethodEnabled (true); // ensure using InputMethod +} + +kpView::~kpView () +{ + setHasMouse (false); + + delete d->m_backBuffer; + delete d; +} + + +// public +kpDocument *kpView::document () const +{ + return d->m_document; +} + +// protected +kpSelection *kpView::selection () const +{ + return document () ? document ()->selection () : 0; +} + +// public +kpToolToolBar *kpView::toolToolBar () const +{ + return d->m_toolToolBar; +} + +// protected +kpTool *kpView::tool () const +{ + return toolToolBar () ? toolToolBar ()->tool () : 0; +} + +// public +kpViewManager *kpView::viewManager () const +{ + return d->m_viewManager; +} + +// public +kpView *kpView::buddyView () const +{ + return d->m_buddyView; +} + +// public +kpViewScrollableContainer *kpView::buddyViewScrollableContainer () const +{ + return (buddyView () ? buddyView ()->scrollableContainer () : 0); +} + +// public +kpViewScrollableContainer *kpView::scrollableContainer () const +{ + return d->m_scrollableContainer; +} + + +// public +int kpView::zoomLevelX (void) const +{ + return d->m_hzoom; +} + +// public +int kpView::zoomLevelY (void) const +{ + return d->m_vzoom; +} + +// public virtual +void kpView::setZoomLevel (int hzoom, int vzoom) +{ + if (hzoom == d->m_hzoom && vzoom == d->m_vzoom) + return; + + if (hzoom <= 0 || vzoom <= 0) + return; + + d->m_hzoom = hzoom; + d->m_vzoom = vzoom; + + if (viewManager ()) + viewManager ()->updateView (this); + + emit zoomLevelChanged (hzoom, vzoom); +} + + +// public +QPoint kpView::origin () const +{ + return d->m_origin; +} + +// public virtual +void kpView::setOrigin (const QPoint &origin) +{ +#if DEBUG_KP_VIEW + kdDebug () << "kpView(" << name () << ")::setOrigin" << origin << endl; +#endif + + if (origin == d->m_origin) + { + #if DEBUG_KP_VIEW + kdDebug () << "\tNOP" << endl; + #endif + return; + } + + d->m_origin = origin; + + if (viewManager ()) + viewManager ()->updateView (this); + + emit originChanged (origin); +} + + +// public +bool kpView::canShowGrid () const +{ + // (minimum zoom level < 400% would probably be reported as a bug by + // users who thought that the grid was a part of the image!) + return ((zoomLevelX () >= 400 && zoomLevelX () % 100 == 0) && + (zoomLevelY () >= 400 && zoomLevelY () % 100 == 0)); +} + +// public +bool kpView::isGridShown () const +{ + return d->m_showGrid; +} + +// public +void kpView::showGrid (bool yes) +{ + if (d->m_showGrid == yes) + return; + + if (yes && !canShowGrid ()) + return; + + d->m_showGrid = yes; + + if (viewManager ()) + viewManager ()->updateView (this); +} + + +// public +bool kpView::isBuddyViewScrollableContainerRectangleShown () const +{ + return d->m_isBuddyViewScrollableContainerRectangleShown; +} + +// public +void kpView::showBuddyViewScrollableContainerRectangle (bool yes) +{ + if (yes == d->m_isBuddyViewScrollableContainerRectangleShown) + return; + + d->m_isBuddyViewScrollableContainerRectangleShown = yes; + + if (d->m_isBuddyViewScrollableContainerRectangleShown) + { + // Got these connect statements by analysing deps of + // updateBuddyViewScrollableContainerRectangle() rect update code. + + connect (this, SIGNAL (zoomLevelChanged (int, int)), + this, SLOT (updateBuddyViewScrollableContainerRectangle ())); + connect (this, SIGNAL (originChanged (const QPoint &)), + this, SLOT (updateBuddyViewScrollableContainerRectangle ())); + + if (buddyViewScrollableContainer ()) + { + connect (buddyViewScrollableContainer (), SIGNAL (contentsMovingSoon (int, int)), + this, SLOT (updateBuddyViewScrollableContainerRectangle ())); + connect (buddyViewScrollableContainer (), SIGNAL (resized ()), + this, SLOT (updateBuddyViewScrollableContainerRectangle ())); + } + + if (buddyView ()) + { + connect (buddyView (), SIGNAL (zoomLevelChanged (int, int)), + this, SLOT (updateBuddyViewScrollableContainerRectangle ())); + connect (buddyView (), SIGNAL (originChanged (const QPoint &)), + this, SLOT (updateBuddyViewScrollableContainerRectangle ())); + + connect (buddyView (), SIGNAL (sizeChanged (int, int)), + this, SLOT (updateBuddyViewScrollableContainerRectangle ())); + } + + } + else + { + disconnect (this, SIGNAL (zoomLevelChanged (int, int)), + this, SLOT (updateBuddyViewScrollableContainerRectangle ())); + disconnect (this, SIGNAL (originChanged (const QPoint &)), + this, SLOT (updateBuddyViewScrollableContainerRectangle ())); + + if (buddyViewScrollableContainer ()) + { + disconnect (buddyViewScrollableContainer (), SIGNAL (contentsMovingSoon (int, int)), + this, SLOT (updateBuddyViewScrollableContainerRectangle ())); + disconnect (buddyViewScrollableContainer (), SIGNAL (resized ()), + this, SLOT (updateBuddyViewScrollableContainerRectangle ())); + } + + if (buddyView ()) + { + disconnect (buddyView (), SIGNAL (zoomLevelChanged (int, int)), + this, SLOT (updateBuddyViewScrollableContainerRectangle ())); + disconnect (buddyView (), SIGNAL (originChanged (const QPoint &)), + this, SLOT (updateBuddyViewScrollableContainerRectangle ())); + + disconnect (buddyView (), SIGNAL (sizeChanged (int, int)), + this, SLOT (updateBuddyViewScrollableContainerRectangle ())); + } + + } + + updateBuddyViewScrollableContainerRectangle (); +} + + +// protected +QRect kpView::buddyViewScrollableContainerRectangle () const +{ + return d->m_buddyViewScrollableContainerRectangle; +} + +// protected slot +void kpView::updateBuddyViewScrollableContainerRectangle () +{ + if (viewManager ()) + viewManager ()->setQueueUpdates (); + + { + if (d->m_buddyViewScrollableContainerRectangle.isValid ()) + { + if (viewManager ()) + { + // Erase last + viewManager ()->updateViewRectangleEdges (this, + d->m_buddyViewScrollableContainerRectangle); + } + } + + + QRect newRect; + if (isBuddyViewScrollableContainerRectangleShown () && + buddyViewScrollableContainer () && buddyView ()) + { + QRect docRect = buddyView ()->transformViewToDoc ( + QRect (buddyViewScrollableContainer ()->contentsXSoon (), + buddyViewScrollableContainer ()->contentsYSoon (), + QMIN (buddyView ()->width (), + buddyViewScrollableContainer ()->visibleWidth ()), + QMIN (buddyView ()->height (), + buddyViewScrollableContainer ()->visibleHeight ()))); + + + QRect viewRect = this->transformDocToView (docRect); + + + // (Surround the area of interest by moving outwards by 1 pixel in each + // direction - don't overlap area) + newRect = QRect (viewRect.x () - 1, + viewRect.y () - 1, + viewRect.width () + 2, + viewRect.height () + 2); + } + else + { + newRect = QRect (); + } + + if (newRect != d->m_buddyViewScrollableContainerRectangle) + { + // (must set before updateView() for paintEvent() to see new + // rect) + d->m_buddyViewScrollableContainerRectangle = newRect; + + if (newRect.isValid ()) + { + if (viewManager ()) + { + viewManager ()->updateViewRectangleEdges (this, + d->m_buddyViewScrollableContainerRectangle); + } + } + } + } + + if (viewManager ()) + viewManager ()->restoreQueueUpdates (); +} + + +// public +double kpView::transformViewToDocX (double viewX) const +{ + return (viewX - origin ().x ()) * 100.0 / zoomLevelX (); +} + +// public +double kpView::transformViewToDocY (double viewY) const +{ + return (viewY - origin ().y ()) * 100.0 / zoomLevelY (); +} + +// public +QPoint kpView::transformViewToDoc (const QPoint &viewPoint) const +{ + return QPoint ((int) transformViewToDocX (viewPoint.x ()), + (int) transformViewToDocY (viewPoint.y ())); +} + +// public +QRect kpView::transformViewToDoc (const QRect &viewRect) const +{ + if (zoomLevelX () == 100 && zoomLevelY () == 100) + { + return QRect (viewRect.x () - origin ().x (), + viewRect.y () - origin ().y (), + viewRect.width (), + viewRect.height ()); + } + else + { + const QPoint docTopLeft = transformViewToDoc (viewRect.topLeft ()); + + // (don't call transformViewToDoc[XY]() - need to round up dimensions) + const int docWidth = qRound (double (viewRect.width ()) * 100.0 / double (zoomLevelX ())); + const int docHeight = qRound (double (viewRect.height ()) * 100.0 / double (zoomLevelY ())); + + // (like QWMatrix::Areas) + return QRect (docTopLeft.x (), docTopLeft.y (), docWidth, docHeight); + } +} + + +// public +double kpView::transformDocToViewX (double docX) const +{ + return (docX * zoomLevelX () / 100.0) + origin ().x (); +} + +// public +double kpView::transformDocToViewY (double docY) const +{ + return (docY * zoomLevelY () / 100.0) + origin ().y (); +} + +// public +QPoint kpView::transformDocToView (const QPoint &docPoint) const +{ + return QPoint ((int) transformDocToViewX (docPoint.x ()), + (int) transformDocToViewY (docPoint.y ())); +} + +// public +QRect kpView::transformDocToView (const QRect &docRect) const +{ + if (zoomLevelX () == 100 && zoomLevelY () == 100) + { + return QRect (docRect.x () + origin ().x (), + docRect.y () + origin ().y (), + docRect.width (), + docRect.height ()); + } + else + { + const QPoint viewTopLeft = transformDocToView (docRect.topLeft ()); + + // (don't call transformDocToView[XY]() - need to round up dimensions) + const int viewWidth = qRound (double (docRect.width ()) * double (zoomLevelX ()) / 100.0); + const int viewHeight = qRound (double (docRect.height ()) * double (zoomLevelY ()) / 100.0); + + // (like QWMatrix::Areas) + return QRect (viewTopLeft.x (), viewTopLeft.y (), viewWidth, viewHeight); + } +} + + +// public +QPoint kpView::transformViewToOtherView (const QPoint &viewPoint, + const kpView *otherView) +{ + if (this == otherView) + return viewPoint; + + const double docX = transformViewToDocX (viewPoint.x ()); + const double docY = transformViewToDocY (viewPoint.y ()); + + const double otherViewX = otherView->transformDocToViewX (docX); + const double otherViewY = otherView->transformDocToViewY (docY); + + return QPoint ((int) otherViewX, (int) otherViewY); +} + + +// public +int kpView::zoomedDocWidth () const +{ + return document () ? document ()->width () * zoomLevelX () / 100 : 0; +} + +// public +int kpView::zoomedDocHeight () const +{ + return document () ? document ()->height () * zoomLevelY () / 100 : 0; +} + + +// public +void kpView::setHasMouse (bool yes) +{ + kpViewManager *vm = viewManager (); + if (!vm) + return; + +#if DEBUG_KP_VIEW && 0 + kdDebug () << "kpView(" << name () + << ")::setHasMouse(" << yes + << ") existing viewUnderCursor=" + << (vm->viewUnderCursor () ? vm->viewUnderCursor ()->name () : "(none)") + << endl; +#endif + if (yes && vm->viewUnderCursor () != this) + vm->setViewUnderCursor (this); + else if (!yes && vm->viewUnderCursor () == this) + vm->setViewUnderCursor (0); +} + + +// public +void kpView::addToQueuedArea (const QRegion ®ion) +{ +#if DEBUG_KP_VIEW && 0 + kdDebug () << "kpView(" << name () + << ")::addToQueuedArea() already=" << d->m_queuedUpdateArea + << " - plus - " << region + << endl; +#endif + d->m_queuedUpdateArea += region; +} + +// public +void kpView::addToQueuedArea (const QRect &rect) +{ +#if DEBUG_KP_VIEW && 0 + kdDebug () << "kpView(" << name () + << ")::addToQueuedArea() already=" << d->m_queuedUpdateArea + << " - plus - " << rect + << endl; +#endif + d->m_queuedUpdateArea += rect; +} + +// public +void kpView::invalidateQueuedArea () +{ +#if DEBUG_KP_VIEW && 0 + kdDebug () << "kpView::invalidateQueuedArea()" << endl; +#endif + + d->m_queuedUpdateArea = QRegion (); +} + +// public +void kpView::updateQueuedArea () +{ + kpViewManager *vm = viewManager (); +#if DEBUG_KP_VIEW && 0 + kdDebug () << "kpView(" << name () + << ")::updateQueuedArea() vm=" << (bool) vm + << " queueUpdates=" << (vm && vm->queueUpdates ()) + << " fastUpdates=" << (vm && vm->fastUpdates ()) + << " area=" << d->m_queuedUpdateArea + << endl; +#endif + + if (!vm) + return; + + if (vm->queueUpdates ()) + return; + + if (!d->m_queuedUpdateArea.isNull ()) + vm->updateView (this, d->m_queuedUpdateArea); + + invalidateQueuedArea (); +} + +// public +void kpView::updateMicroFocusHint (const QRect µFocusHint) +{ + int x = microFocusHint.topLeft().x(); + int y = microFocusHint.topLeft().y(); + int width = microFocusHint.width(); + int height = microFocusHint.height(); + setMicroFocusHint (x, y, width, height); +} + +// public +QRect kpView::selectionViewRect () const +{ + return selection () ? + transformDocToView (selection ()->boundingRect ()) : + QRect (); + +} + +// public +QPoint kpView::mouseViewPoint (const QPoint &returnViewPoint) const +{ + if (returnViewPoint != KP_INVALID_POINT) + return returnViewPoint; + else + return mapFromGlobal (QCursor::pos ()); +} + +// public +QPoint kpView::mouseViewPointRelativeToSelection (const QPoint &viewPoint) const +{ + if (!selection ()) + return KP_INVALID_POINT; + + return mouseViewPoint (viewPoint) - transformDocToView (selection ()->topLeft ()); +} + +// public +bool kpView::mouseOnSelection (const QPoint &viewPoint) const +{ + const QRect selViewRect = selectionViewRect (); + if (!selViewRect.isValid ()) + return false; + + return selViewRect.contains (mouseViewPoint (viewPoint)); +} + + +// public +int kpView::textSelectionMoveBorderAtomicSize () const +{ + if (!selection () || !selection ()->isText ()) + return 0; + + return QMAX (4, zoomLevelX () / 100); +} + +// public +bool kpView::mouseOnSelectionToMove (const QPoint &viewPoint) const +{ + if (!mouseOnSelection (viewPoint)) + return false; + + if (!selection ()->isText ()) + return true; + + if (mouseOnSelectionResizeHandle (viewPoint)) + return false; + + + const QPoint viewPointRelSel = mouseViewPointRelativeToSelection (viewPoint); + + // Middle point should always be selectable + const QPoint selCenterDocPoint = selection ()->boundingRect ().center (); + if (tool () && + tool ()->currentPoint () == selCenterDocPoint) + { + return false; + } + + + const int atomicSize = textSelectionMoveBorderAtomicSize (); + const QRect selViewRect = selectionViewRect (); + + return (viewPointRelSel.x () < atomicSize || + viewPointRelSel.x () >= selViewRect.width () - atomicSize || + viewPointRelSel.y () < atomicSize || + viewPointRelSel.y () >= selViewRect.height () - atomicSize); +} + + +// protected +bool kpView::selectionLargeEnoughToHaveResizeHandlesIfAtomicSize (int atomicSize) const +{ + if (!selection ()) + return false; + + const QRect selViewRect = selectionViewRect (); + + return (selViewRect.width () >= atomicSize * 5 || + selViewRect.height () >= atomicSize * 5); +} + +// public +int kpView::selectionResizeHandleAtomicSize () const +{ + int atomicSize = QMIN (7, QMAX (4, zoomLevelX () / 100)); + while (atomicSize > 0 && + !selectionLargeEnoughToHaveResizeHandlesIfAtomicSize (atomicSize)) + { + atomicSize--; + } + + return atomicSize; +} + +// public +bool kpView::selectionLargeEnoughToHaveResizeHandles () const +{ + return (selectionResizeHandleAtomicSize () > 0); +} + +// public +QRegion kpView::selectionResizeHandlesViewRegion (bool forRenderer) const +{ + QRegion ret; + + const int atomicLength = selectionResizeHandleAtomicSize (); + if (atomicLength <= 0) + return QRegion (); + + + // HACK: At low zoom (e.g. 100%), resize handles will probably be too + // big and overlap text / cursor / too much of selection. + // + // So limit the _visual_ size of handles at low zoom. The + // handles' grab area remains the same for usability; so yes, + // there are a few pixels that don't look grabable but they are. + // + // The real solution is to be able to partially render the + // handles outside of the selection view rect. If not possible, + // at least for text boxes, render text on top of handles. + int normalAtomicLength = atomicLength; + int vertEdgeAtomicLength = atomicLength; + if (forRenderer && selection ()) + { + if (zoomLevelX () <= 150) + { + if (normalAtomicLength > 1) + normalAtomicLength--; + + if (vertEdgeAtomicLength > 1) + vertEdgeAtomicLength--; + } + + // 1 line of text? + if (selection ()->isText () && selection ()->textLines ().size () == 1) + { + if (zoomLevelX () <= 150) + vertEdgeAtomicLength = QMIN (vertEdgeAtomicLength, QMAX (2, zoomLevelX () / 100)); + else if (zoomLevelX () <= 250) + vertEdgeAtomicLength = QMIN (vertEdgeAtomicLength, QMAX (3, zoomLevelX () / 100)); + } + } + + + const QRect selViewRect = selectionViewRect (); + +#define ADD_BOX_RELATIVE_TO_SELECTION(type,x,y) \ + ret += QRect ((x), (y), type##AtomicLength, type##AtomicLength) + + ADD_BOX_RELATIVE_TO_SELECTION (normal, + selViewRect.width () - normalAtomicLength, + selViewRect.height () - normalAtomicLength); + ADD_BOX_RELATIVE_TO_SELECTION (normal, + selViewRect.width () - normalAtomicLength, + 0); + ADD_BOX_RELATIVE_TO_SELECTION (normal, + 0, + selViewRect.height () - normalAtomicLength); + ADD_BOX_RELATIVE_TO_SELECTION (normal, + 0, + 0); + + ADD_BOX_RELATIVE_TO_SELECTION (vertEdge, + selViewRect.width () - vertEdgeAtomicLength, + (selViewRect.height () - vertEdgeAtomicLength) / 2); + ADD_BOX_RELATIVE_TO_SELECTION (normal, + (selViewRect.width () - normalAtomicLength) / 2, + selViewRect.height () - normalAtomicLength); + ADD_BOX_RELATIVE_TO_SELECTION (normal, + (selViewRect.width () - normalAtomicLength) / 2, + 0); + ADD_BOX_RELATIVE_TO_SELECTION (vertEdge, + 0, + (selViewRect.height () - vertEdgeAtomicLength) / 2); + +#undef ADD_BOX_RELATIVE_TO_SELECTION + + ret.translate (selViewRect.x (), selViewRect.y ()); + ret = ret.intersect (selViewRect); + + return ret; +} + +// public +int kpView::mouseOnSelectionResizeHandle (const QPoint &viewPoint) const +{ +#if DEBUG_KP_VIEW + kdDebug () << "kpView::mouseOnSelectionResizeHandle(viewPoint=" + << viewPoint << ")" << endl; +#endif + + if (!mouseOnSelection (viewPoint)) + { + #if DEBUG_KP_VIEW + kdDebug () << "\tmouse not on sel" << endl; + #endif + return 0; + } + + + const QRect selViewRect = selectionViewRect (); +#if DEBUG_KP_VIEW + kdDebug () << "\tselViewRect=" << selViewRect << endl; +#endif + + + const int atomicLength = selectionResizeHandleAtomicSize (); +#if DEBUG_KP_VIEW + kdDebug () << "\tatomicLength=" << atomicLength << endl; +#endif + + if (atomicLength <= 0) + { + #if DEBUG_KP_VIEW + kdDebug () << "\tsel not large enough to have resize handles" << endl; + #endif + // Want to make it possible to move a small selection + return 0; + } + + + const QPoint viewPointRelSel = mouseViewPointRelativeToSelection (viewPoint); +#if DEBUG_KP_VIEW + kdDebug () << "\tviewPointRelSel=" << viewPointRelSel << endl; +#endif + + +#define LOCAL_POINT_IN_BOX_AT(x,y) \ + QRect ((x), (y), atomicLength, atomicLength).contains (viewPointRelSel) + + // Favour the bottom & right and the corners. + if (LOCAL_POINT_IN_BOX_AT (selViewRect.width () - atomicLength, + selViewRect.height () - atomicLength)) + { + return Bottom | Right; + } + else if (LOCAL_POINT_IN_BOX_AT (selViewRect.width () - atomicLength, 0)) + { + return Top | Right; + } + else if (LOCAL_POINT_IN_BOX_AT (0, selViewRect.height () - atomicLength)) + { + return Bottom | Left; + } + else if (LOCAL_POINT_IN_BOX_AT (0, 0)) + { + return Top | Left; + } + else if (LOCAL_POINT_IN_BOX_AT (selViewRect.width () - atomicLength, + (selViewRect.height () - atomicLength) / 2)) + { + return Right; + } + else if (LOCAL_POINT_IN_BOX_AT ((selViewRect.width () - atomicLength) / 2, + selViewRect.height () - atomicLength)) + { + return Bottom; + } + else if (LOCAL_POINT_IN_BOX_AT ((selViewRect.width () - atomicLength) / 2, 0)) + { + return Top; + } + else if (LOCAL_POINT_IN_BOX_AT (0, (selViewRect.height () - atomicLength) / 2)) + { + return Left; + } + else + { + #if DEBUG_KP_VIEW + kdDebug () << "\tnot on sel resize handle" << endl; + #endif + return 0; + } +#undef LOCAL_POINT_IN_BOX_AT +} + +// public +bool kpView::mouseOnSelectionToSelectText (const QPoint &viewPoint) const +{ +#if DEBUG_KP_VIEW + kdDebug () << "kpView::mouseOnSelectionToSelectText(viewPoint=" + << viewPoint << ")" << endl; +#endif + + if (!mouseOnSelection (viewPoint)) + { + #if DEBUG_KP_VIEW + kdDebug () << "\tmouse non on sel" << endl; + #endif + return false; + } + + if (!selection ()->isText ()) + { + #if DEBUG_KP_VIEW + kdDebug () << "\tsel not text" << endl; + #endif + return false; + } + +#if DEBUG_KP_VIEW + kdDebug () << "\tmouse on sel: to move=" << mouseOnSelectionToMove () + << " to resize=" << mouseOnSelectionResizeHandle () + << endl; +#endif + + return (!mouseOnSelectionToMove (viewPoint) && + !mouseOnSelectionResizeHandle (viewPoint)); +} + + +// protected virtual [base QWidget] +void kpView::mouseMoveEvent (QMouseEvent *e) +{ +#if DEBUG_KP_VIEW && 0 + kdDebug () << "kpView(" << name () << ")::mouseMoveEvent (" + << e->x () << "," << e->y () << ")" + << endl; +#endif + + // TODO: This is wrong if you leaveEvent the mainView by mouseMoving on the + // mainView, landing on top of the thumbnailView cleverly put on top + // of the mainView. + setHasMouse (rect ().contains (e->pos ())); + + if (tool ()) + tool ()->mouseMoveEvent (e); + + e->accept (); +} + +// protected virtual [base QWidget] +void kpView::mousePressEvent (QMouseEvent *e) +{ +#if DEBUG_KP_VIEW && 0 + kdDebug () << "kpView(" << name () << ")::mousePressEvent (" + << e->x () << "," << e->y () << ")" + << endl; +#endif + + setHasMouse (true); + + if (tool ()) + tool ()->mousePressEvent (e); + + e->accept (); +} + +// protected virtual [base QWidget] +void kpView::mouseReleaseEvent (QMouseEvent *e) +{ +#if DEBUG_KP_VIEW && 0 + kdDebug () << "kpView(" << name () << ")::mouseReleaseEvent (" + << e->x () << "," << e->y () << ")" + << endl; +#endif + + setHasMouse (rect ().contains (e->pos ())); + + if (tool ()) + tool ()->mouseReleaseEvent (e); + + e->accept (); +} + +// public virtual [base QWidget] +void kpView::wheelEvent (QWheelEvent *e) +{ + if (tool ()) + tool ()->wheelEvent (e); +} + + +// protected virtual [base QWidget] +void kpView::keyPressEvent (QKeyEvent *e) +{ +#if DEBUG_KP_VIEW && 0 + kdDebug () << "kpView(" << name () << ")::keyPressEvent()" << endl; +#endif + + if (tool ()) + tool ()->keyPressEvent (e); + + e->accept (); +} + +// protected virtual [base QWidget] +void kpView::keyReleaseEvent (QKeyEvent *e) +{ +#if DEBUG_KP_VIEW && 0 + kdDebug () << "kpView(" << name () << ")::keyReleaseEvent()" << endl; +#endif + + if (tool ()) + tool ()->keyReleaseEvent (e); + + e->accept (); +} + + +// protected virtual [base QWidget] +void kpView::focusInEvent (QFocusEvent *e) +{ +#if DEBUG_KP_VIEW && 0 + kdDebug () << "kpView(" << name () << ")::focusInEvent()" << endl; +#endif + if (tool ()) + tool ()->focusInEvent (e); +} + +// protected virtual [base QWidget] +void kpView::focusOutEvent (QFocusEvent *e) +{ +#if DEBUG_KP_VIEW && 0 + kdDebug () << "kpView(" << name () << ")::focusOutEvent()" << endl; +#endif + if (tool ()) + tool ()->focusOutEvent (e); +} + + +// protected virtual [base QWidget] +void kpView::enterEvent (QEvent *e) +{ +#if DEBUG_KP_VIEW && 0 + kdDebug () << "kpView(" << name () << ")::enterEvent()" << endl; +#endif + + // Don't call setHasMouse(true) as it displays the brush cursor (if + // active) when dragging open a menu and then dragging + // past the extents of the menu due to Qt sending us an EnterEvent. + // We're already covered by MouseMoveEvent anyway. + // + // But disabling this causes a more serious problem: RMB on a text + // box and Esc. We have no other reliable way to determine if the + // mouse is still above the view (user could have moved mouse out + // while RMB menu was up) and hence the cursor is not updated. + setHasMouse (true); + + if (tool ()) + tool ()->enterEvent (e); +} + +// protected virtual [base QWidget] +void kpView::leaveEvent (QEvent *e) +{ +#if DEBUG_KP_VIEW && 0 + kdDebug () << "kpView(" << name () << ")::leaveEvent()" << endl; +#endif + + setHasMouse (false); + if (tool ()) + tool ()->leaveEvent (e); +} + + +// protected virtual [base QWidget] +void kpView::dragEnterEvent (QDragEnterEvent *) +{ +#if DEBUG_KP_VIEW && 1 + kdDebug () << "kpView(" << name () << ")::dragEnterEvent()" << endl; +#endif + + setHasMouse (true); +} + +// protected virtual [base QWidget] +void kpView::dragLeaveEvent (QDragLeaveEvent *) +{ +#if DEBUG_KP_VIEW && 1 + kdDebug () << "kpView(" << name () << ")::dragLeaveEvent" << endl; +#endif + + setHasMouse (false); +} + + +// public virtual [base QWidget] +void kpView::resize (int w, int h) +{ +#if DEBUG_KP_VIEW && 1 + kdDebug () << "kpView(" << name () + << ")::resize(" << w << "," << h << ")" + << endl; +#endif + + QWidget::resize (w, h); +} + +// protected virtual [base QWidget] +void kpView::resizeEvent (QResizeEvent *e) +{ +#if DEBUG_KP_VIEW && 1 + kdDebug () << "kpView(" << name () << ")::resizeEvent(" + << e->size () + << " vs actual=" << size () + << ") old=" << e->oldSize () << endl; +#endif + + QWidget::resizeEvent (e); + + emit sizeChanged (width (), height ()); + emit sizeChanged (size ()); +} + + +// private virtual +void kpView::imStartEvent (QIMEvent *e) +{ +#if DEBUG_KP_VIEW && 1 + kdDebug () << "kpView(" << name () << ")::imStartEvent" << endl; +#endif + + if (tool ()) + tool ()->imStartEvent (e); + e->accept(); +} + +// private virtual +void kpView::imComposeEvent (QIMEvent *e) +{ +#if DEBUG_KP_VIEW && 1 + kdDebug () << "kpView(" << name () << ")::imComposeEvent" << endl; +#endif + + if (tool ()) + tool ()->imComposeEvent (e); + e->accept(); +} + +// private virtual +void kpView::imEndEvent (QIMEvent *e) +{ +#if DEBUG_KP_VIEW && 1 + kdDebug () << "kpView(" << name () << ")::imEndEvent" << endl; +#endif + + if (tool ()) + tool ()->imEndEvent (e); + e->accept(); +} + + +// +// Renderer +// + +// protected +QRect kpView::paintEventGetDocRect (const QRect &viewRect) const +{ +#if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "kpView::paintEventGetDocRect(" << viewRect << ")" << endl; +#endif + + QRect docRect; + + // From the "we aren't sure whether to round up or round down" department: + + if (zoomLevelX () < 100 || zoomLevelY () < 100) + docRect = transformViewToDoc (viewRect); + else + { + // think of a grid - you need to fully cover the zoomed-in pixels + // when docRect is zoomed back to the view later + docRect = QRect (transformViewToDoc (viewRect.topLeft ()), // round down + transformViewToDoc (viewRect.bottomRight ())); // round down + } + + if (zoomLevelX () % 100 || zoomLevelY () % 100) + { + // at least round up the bottom-right point and deal with matrix weirdness: + // - helpful because it ensures we at least cover the required area + // at e.g. 67% or 573% + // - harmless since paintEventDrawRect() clips for us anyway + docRect.setBottomRight (docRect.bottomRight () + QPoint (2, 2)); + } + +#if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tdocRect=" << docRect << endl; +#endif + kpDocument *doc = document (); + if (doc) + { + docRect = docRect.intersect (doc->rect ()); + #if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tintersect with doc=" << docRect << endl; + #endif + } + + return docRect; +} + +// public +void kpView::drawTransparentBackground (QPainter *painter, + int /*viewWidth*/, int /*viewHeight*/, + const QRect &rect, + bool isPreview) +{ + const int cellSize = !isPreview ? 16 : 10; + + int starty = rect.y (); + if (starty % cellSize) + starty -= (starty % cellSize); + + int startx = rect.x (); + if (startx % cellSize) + startx -= (startx % cellSize); + + painter->save (); + for (int y = starty; y <= rect.bottom (); y += cellSize) + { + for (int x = startx; x <= rect.right (); x += cellSize) + { + bool parity = (x / cellSize + y / cellSize) % 2; + QColor col; + + if (parity) + { + if (!isPreview) + col = QColor (213, 213, 213); + else + col = QColor (224, 224, 224); + } + else + col = Qt::white; + + painter->fillRect (x - rect.x (), y - rect.y (), cellSize, cellSize, + col); + } + } + painter->restore (); +} + +// protected +void kpView::paintEventDrawCheckerBoard (QPainter *painter, const QRect &viewRect) +{ + kpDocument *doc = document (); + if (!doc) + return; + + drawTransparentBackground (painter, + doc->width () * zoomLevelX () / 100, + doc->height () * zoomLevelY () / 100, + viewRect); +} + +// protected +void kpView::paintEventDrawSelection (QPixmap *destPixmap, const QRect &docRect) +{ +#if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "kpView::paintEventDrawSelection() docRect=" << docRect << endl; +#endif + + kpDocument *doc = document (); + if (!doc) + { + #if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tno doc - abort" << endl; + #endif + return; + } + + kpSelection *sel = doc->selection (); + if (!sel) + { + #if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tno sel - abort" << endl; + #endif + return; + } + + + // + // Draw selection pixmap (if there is one) + // +#if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tdraw sel pixmap @ " << sel->topLeft () << endl; +#endif + sel->paint (destPixmap, docRect); + + + // + // Draw selection border + // + + kpViewManager *vm = viewManager (); +#if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tsel border visible=" + << vm->selectionBorderVisible () + << endl; +#endif + if (vm->selectionBorderVisible ()) + { + QPainter destPixmapPainter (destPixmap); + destPixmapPainter.setRasterOp (Qt::XorROP); + destPixmapPainter.setPen (QPen (Qt::white, 1, Qt::DotLine)); + + destPixmapPainter.setBackgroundMode (QPainter::OpaqueMode); + destPixmapPainter.setBackgroundColor (Qt::blue); + + QBitmap maskBitmap; + QPainter maskBitmapPainter; + if (destPixmap->mask ()) + { + maskBitmap = *destPixmap->mask (); + maskBitmapPainter.begin (&maskBitmap); + maskBitmapPainter.setPen (Qt::color1/*opaque*/); + } + + + #define PAINTER_CMD(cmd) \ + { \ + destPixmapPainter . cmd; \ + if (maskBitmapPainter.isActive ()) \ + maskBitmapPainter . cmd; \ + } + + QRect boundingRect = sel->boundingRect (); + #if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tsel boundingRect=" + << boundingRect + << endl; + #endif + + if (boundingRect.topLeft () != boundingRect.bottomRight ()) + { + switch (sel->type ()) + { + case kpSelection::Rectangle: + case kpSelection::Text: + #if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tselection border = rectangle" << endl; + kdDebug () << "\t\tx=" << boundingRect.x () - docRect.x () + << " y=" << boundingRect.y () - docRect.y () + << " w=" << boundingRect.width () + << " h=" << boundingRect.height () + << endl; + #endif + PAINTER_CMD (drawRect (boundingRect.x () - docRect.x (), + boundingRect.y () - docRect.y (), + boundingRect.width (), + boundingRect.height ())); + break; + + case kpSelection::Ellipse: + #if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tselection border = ellipse" << endl; + #endif + PAINTER_CMD (drawEllipse (boundingRect.x () - docRect.x (), + boundingRect.y () - docRect.y (), + boundingRect.width (), + boundingRect.height ())); + break; + + case kpSelection::Points: + { + #if DEBUG_KP_VIEW_RENDERER + kdDebug () << "\tselection border = freeForm" << endl; + #endif + QPointArray points = sel->points (); + points.detach (); + points.translate (-docRect.x (), -docRect.y ()); + if (vm->selectionBorderFinished ()) + { + PAINTER_CMD (drawPolygon (points)); + } + else + { + PAINTER_CMD (drawPolyline (points)); + } + + break; + } + + default: + kdError () << "kpView::paintEventDrawSelection() unknown sel border type" << endl; + break; + } + + + if (vm->selectionBorderFinished () && + (sel->type () == kpSelection::Ellipse || + sel->type () == kpSelection::Points)) + { + destPixmapPainter.save (); + + destPixmapPainter.setRasterOp (Qt::NotROP); + PAINTER_CMD (drawRect (boundingRect.x () - docRect.x (), + boundingRect.y () - docRect.y (), + boundingRect.width (), + boundingRect.height ())); + + destPixmapPainter.restore (); + } + } + else + { + // SYNC: Work around Qt bug: can't draw 1x1 rectangle + PAINTER_CMD (drawPoint (boundingRect.topLeft () - docRect.topLeft ())); + } + + #undef PAINTER_CMD + + destPixmapPainter.end (); + if (maskBitmapPainter.isActive ()) + maskBitmapPainter.end (); + + destPixmap->setMask (maskBitmap); + } + + + // + // Draw text cursor + // + + if (sel->isText () && + vm->textCursorEnabled () && + (vm->textCursorBlinkState () || + // For the current main window: + // As long as _any_ view has focus, blink _all_ views not just the + // one with focus // !this->isActiveWindow () + !vm->activeView ())) // sync: call will break when vm is not held by 1 mainWindow + { + // TODO: Fix code duplication: kpViewManager::{setTextCursorPosition,updateTextCursor}() & kpView::paintEventDrawSelection() + QPoint topLeft = sel->pointForTextRowCol (vm->textCursorRow (), vm->textCursorCol ()); + if (topLeft != KP_INVALID_POINT) + { + QRect rect = QRect (topLeft.x (), topLeft.y (), + 1, sel->textStyle ().fontMetrics ().height ()); + rect = rect.intersect (sel->textAreaRect ()); + if (!rect.isEmpty ()) + { + rect.moveBy (-docRect.x (), -docRect.y ()); + + QBitmap maskBitmap; + QPainter destPixmapPainter, maskBitmapPainter; + + if (destPixmap->mask ()) + { + maskBitmap = *destPixmap->mask (); + maskBitmapPainter.begin (&maskBitmap); + maskBitmapPainter.fillRect (rect, Qt::color1/*opaque*/); + maskBitmapPainter.end (); + } + + destPixmapPainter.begin (destPixmap); + destPixmapPainter.setRasterOp (Qt::XorROP); + destPixmapPainter.fillRect (rect, Qt::white); + destPixmapPainter.end (); + + if (!maskBitmap.isNull ()) + destPixmap->setMask (maskBitmap); + } + } + } +} + +// protected +bool kpView::selectionResizeHandleAtomicSizeCloseToZoomLevel () const +{ + return (abs (selectionResizeHandleAtomicSize () - zoomLevelX () / 100) < 3); +} + +// protected +void kpView::paintEventDrawSelectionResizeHandles (QPainter *painter, const QRect &viewRect) +{ +#if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "kpView::paintEventDrawSelectionResizeHandles(" + << viewRect << ")" << endl; +#endif + + if (!selectionLargeEnoughToHaveResizeHandles ()) + { + #if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tsel not large enough to have resize handles" << endl; + #endif + return; + } + + kpViewManager *vm = viewManager (); + if (!vm || !vm->selectionBorderVisible () || !vm->selectionBorderFinished ()) + { + #if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tsel border not visible or not finished" << endl; + #endif + + return; + } + + const QRect selViewRect = selectionViewRect (); +#if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tselViewRect=" << selViewRect << endl; +#endif + if (!selViewRect.intersects (viewRect)) + { + #if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tdoesn't intersect viewRect" << endl; + #endif + return; + } + + QRegion selResizeHandlesRegion = selectionResizeHandlesViewRegion (true/*for renderer*/); +#if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tsel resize handles view region=" + << selResizeHandlesRegion << endl; +#endif + selResizeHandlesRegion.translate (-viewRect.x (), -viewRect.y ()); + + painter->save (); + + QColor fillColor; + if (selectionResizeHandleAtomicSizeCloseToZoomLevel ()) + { + fillColor = Qt::blue; + painter->setRasterOp (Qt::CopyROP); + } + else + { + fillColor = Qt::white; + painter->setRasterOp (Qt::XorROP); + } + + QMemArray rects = selResizeHandlesRegion.rects (); + for (QMemArray ::ConstIterator it = rects.begin (); + it != rects.end (); + it++) + { + painter->fillRect (*it, fillColor); + } + + painter->restore (); +} + +// protected +void kpView::paintEventDrawTempPixmap (QPixmap *destPixmap, const QRect &docRect) +{ + kpViewManager *vm = viewManager (); + if (!vm) + return; + + const kpTempPixmap *tpm = vm->tempPixmap (); +#if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "kpView::paintEventDrawTempPixmap() tempPixmap=" + << tpm + << " isVisible=" + << (tpm ? tpm->isVisible (vm) : false) + << endl; +#endif + + if (!tpm || !tpm->isVisible (vm)) + return; + + tpm->paint (destPixmap, docRect); +} + +// protected +void kpView::paintEventDrawGridLines (QPainter *painter, const QRect &viewRect) +{ + int hzoomMultiple = zoomLevelX () / 100; + int vzoomMultiple = zoomLevelY () / 100; + + QPen ordinaryPen (Qt::gray); + QPen tileBoundaryPen (Qt::lightGray); + + painter->setPen (ordinaryPen); + + // horizontal lines + int starty = viewRect.top (); + if (starty % vzoomMultiple) + starty = (starty + vzoomMultiple) / vzoomMultiple * vzoomMultiple; + int tileHeight = 16 * vzoomMultiple; // CONFIG + for (int y = starty - viewRect.y (); y <= viewRect.bottom () - viewRect.y (); y += vzoomMultiple) + { + if (0 && tileHeight > 0 && y % tileHeight == 0) + { + painter->setPen (tileBoundaryPen); + //painter.setRasterOp (Qt::XorROP); + } + + painter->drawLine (0, y, viewRect.right () - viewRect.left (), y); + + if (0 && tileHeight > 0 && y % tileHeight == 0) + { + painter->setPen (ordinaryPen); + //painter.setRasterOp (Qt::CopyROP); + } + } + + // vertical lines + int startx = viewRect.left (); + if (startx % hzoomMultiple) + startx = (startx + hzoomMultiple) / hzoomMultiple * hzoomMultiple; + int tileWidth = 16 * hzoomMultiple; // CONFIG + for (int x = startx - viewRect.x (); x <= viewRect.right () - viewRect.x (); x += hzoomMultiple) + { + if (0 && tileWidth > 0 && x % tileWidth == 0) + { + painter->setPen (tileBoundaryPen); + //painter.setRasterOp (Qt::XorROP); + } + + painter->drawLine (x, 0, x, viewRect.bottom () - viewRect.top ()); + + if (0 && tileWidth > 0 && x % tileWidth == 0) + { + painter->setPen (ordinaryPen); + //painter.setRasterOp (Qt::CopyROP); + } + } +} + + +void kpView::paintEventDrawRect (const QRect &viewRect) +{ +#if DEBUG_KP_VIEW_RENDERER + kdDebug () << "\tkpView::paintEventDrawRect(viewRect=" << viewRect + << ")" << endl; +#endif + + kpViewManager *vm = viewManager (); + const kpDocument *doc = document (); + + if (!vm || !doc) + return; + + + if (viewRect.isEmpty ()) + return; + + + QRect docRect = paintEventGetDocRect (viewRect); + +#if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tdocRect=" << docRect << endl; +#endif + +// uncomment to cause deliberate flicker (identifies needless updates) +#if DEBUG_KP_VIEW_RENDERER && 0 + QPainter flickerPainter (this); + flickerPainter.fillRect (viewRect, Qt::red); + flickerPainter.end (); +#endif + + + // + // Prepare Back Buffer + // + + if (!d->m_backBuffer || + d->m_backBuffer->width () < viewRect.width () || + d->m_backBuffer->height () < viewRect.height () || + d->m_backBuffer->width () > width () || + d->m_backBuffer->height () > height ()) + { + // don't use QPixmap::resize() as that wastes time copying pixels + // that will be overwritten anyway + // + // OPT: Should use doubling trick or at least go up in multiples + // to reduce X server pressure. + delete d->m_backBuffer; + d->m_backBuffer = new QPixmap (viewRect.width (), viewRect.height ()); + } + +// uncomment to catch bits of the view that the renderer forgot to update +#if 0 + d->m_backBuffer->fill (Qt::green); +#endif + + QPainter backBufferPainter; + backBufferPainter.begin (d->m_backBuffer); + + + // + // Draw checkboard for transparent images and/or views with borders + // + + QPixmap docPixmap; + + bool tempPixmapWillBeRendered = false; + + if (!docRect.isEmpty ()) + { + docPixmap = doc->getPixmapAt (docRect); + + tempPixmapWillBeRendered = + (!doc->selection () && + vm->tempPixmap () && + vm->tempPixmap ()->isVisible (vm) && + docRect.intersects (vm->tempPixmap ()->rect ())); + + #if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\ttempPixmapWillBeRendered=" << tempPixmapWillBeRendered + << " (sel=" << doc->selection () + << " tempPixmap=" << vm->tempPixmap () + << " tempPixmap.isVisible=" << (vm->tempPixmap () ? vm->tempPixmap ()->isVisible (vm) : false) + << " docRect.intersects(tempPixmap.rect)=" << (vm->tempPixmap () ? docRect.intersects (vm->tempPixmap ()->rect ()) : false) + << ")" + << endl; + #endif + } + + if (docPixmap.mask () || + (tempPixmapWillBeRendered && vm->tempPixmap ()->mayChangeDocumentMask ())) + { + #if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tmask=" << (bool) docPixmap.mask () + << endl; + #endif + paintEventDrawCheckerBoard (&backBufferPainter, viewRect); + } + else + { + #if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tno mask" << endl; + #endif + } + + + if (!docRect.isEmpty ()) + { + // + // Draw docPixmap + tempPixmap + // + + if (doc->selection ()) + { + paintEventDrawSelection (&docPixmap, docRect); + } + else if (tempPixmapWillBeRendered) + { + paintEventDrawTempPixmap (&docPixmap, docRect); + } + + #if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\torigin=" << origin () << endl; + #endif + // blit scaled version of docPixmap + tempPixmap onto Back Buffer + #if DEBUG_KP_VIEW_RENDERER && 1 + QTime scaleTimer; scaleTimer.start (); + #endif + backBufferPainter.translate (origin ().x () - viewRect.x (), + origin ().y () - viewRect.y ()); + backBufferPainter.scale (double (zoomLevelX ()) / 100.0, + double (zoomLevelY ()) / 100.0); + backBufferPainter.drawPixmap (docRect, docPixmap); + backBufferPainter.resetXForm (); // back to 1-1 scaling + #if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tscale time=" << scaleTimer.elapsed () << endl; + #endif + + } // if (!docRect.isEmpty ()) { + + + // + // Draw Grid Lines + // + + if (isGridShown ()) + { + #if DEBUG_KP_VIEW_RENDERER && 1 + QTime gridTimer; gridTimer.start (); + #endif + paintEventDrawGridLines (&backBufferPainter, viewRect); + #if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tgrid time=" << gridTimer.elapsed () << endl; + #endif + } + + + const QRect bvsvRect = buddyViewScrollableContainerRectangle (); + if (!bvsvRect.isEmpty ()) + { + backBufferPainter.save (); + + backBufferPainter.setRasterOp (Qt::XorROP); + backBufferPainter.setPen (Qt::white); + backBufferPainter.translate (-viewRect.x (), -viewRect.y ()); + backBufferPainter.drawRect (bvsvRect); + + backBufferPainter.restore (); + } + + + if (!docRect.isEmpty ()) + { + if (doc->selection ()) + { + // Draw resize handles on top of possible grid lines + paintEventDrawSelectionResizeHandles (&backBufferPainter, viewRect); + } + } + + + // + // Blit Back Buffer to View + // + + backBufferPainter.end (); + + bitBlt (this, viewRect.topLeft (), + d->m_backBuffer, QRect (0, 0, viewRect.width (), viewRect.height ())); +} + + +// protected virtual [base QWidget] +void kpView::paintEvent (QPaintEvent *e) +{ + // sync: kpViewPrivate + // WARNING: document(), viewManager() and friends might be 0 in this method. + // TODO: I'm not 100% convinced that we always check if their friends are 0. + +#if DEBUG_KP_VIEW_RENDERER && 1 + QTime timer; + timer.start (); +#endif + + kpViewManager *vm = viewManager (); + +#if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "kpView(" << name () << ")::paintEvent() vm=" << (bool) vm + << " queueUpdates=" << (vm && vm->queueUpdates ()) + << " fastUpdates=" << (vm && vm->fastUpdates ()) + << " viewRect=" << e->rect () + << " erased=" << e->erased () + << " topLeft=" << QPoint (x (), y ()) + << endl; +#endif + + if (!vm) + return; + + if (vm->queueUpdates ()) + { + // OPT: if this update was due to the document, + // use document coordinates (in case of a zoom change in + // which view coordinates become out of date) + addToQueuedArea (e->region ()); + return; + } + + + QRegion viewRegion = clipRegion ().intersect (e->region ()); + QMemArray rects = viewRegion.rects (); +#if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\t#rects = " << rects.count () << endl; +#endif + + for (QMemArray ::ConstIterator it = rects.begin (); + it != rects.end (); + it++) + { + paintEventDrawRect (*it); + } + + +#if DEBUG_KP_VIEW_RENDERER && 1 + kdDebug () << "\tall done in: " << timer.restart () << "ms" << endl; +#endif +} + + +#include -- cgit v1.2.3