kolourpaint/kpViewScrollableContainer.cpp

   1
   2 /*
   3    Copyright (c) 2003-2007 Clarence Dang <dang@kde.org>
   4    All rights reserved.
   5
   6    Redistribution and use in source and binary forms, with or without
   7    modification, are permitted provided that the following conditions
   8    are met:
   9
  10    1. Redistributions of source code must retain the above copyright
  11       notice, this list of conditions and the following disclaimer.
  12    2. Redistributions in binary form must reproduce the above copyright
  13       notice, this list of conditions and the following disclaimer in the
  14       documentation and/or other materials provided with the distribution.
  15
  16    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19    IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25    THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 */
  27
  28 #define DEBUG_KP_VIEW_SCROLLABLE_CONTAINER 0
  29
  30 #include <kpViewScrollableContainer.h>
  31
  32 #include <qbitmap.h>
  33 #include <qcursor.h>
  34 #include <qevent.h>
  35 #include <qpainter.h>
  36 #include <qpen.h>
  37 #include <qpixmap.h>
  38 #include <qtimer.h>
  39
  40 #include <kdebug.h>
  41 #include <klocale.h>
  42
  43 #include <kpDefs.h>
  44 #include <kpPixmapFX.h>
  45 #include <kpView.h>
  46 #include <kpWidgetMapper.h>
  47
  48
  49 // (Pulled from out of Thurston's hat)
  50 static const int DragScrollLeftTopMargin = 0;
  51 static const int DragScrollRightBottomMargin = 16;  // scrollbarish
  52 static const int DragScrollInterval = 150;
  53 static const int DragScrollInitialInterval = DragScrollInterval * 2;
  54 static const int DragScrollNumPixels = 10;
  55 static const int DragDistanceFromRectMaxFor1stMultiplier = 50;
  56 static const int DragDistanceFromRectMaxFor2ndMultiplier = 100;
  57
  58 static const int GripHandleSize = 7;
  59
  60 // public static
  61 const int kpGrip::Size = 7;
  62
  63
  64 kpGrip::kpGrip (GripType type, QWidget *parent)
  65     : QLabel (parent),
  66       m_type (type),
  67       m_startPoint (KP_INVALID_POINT),
  68       m_currentPoint (KP_INVALID_POINT),
  69       m_shouldReleaseMouseButtons (false)
  70 {
  71     setCursor (cursorForType (m_type));
  72
  73     setMouseTracking (true);  // mouseMoveEvent's even when no mousebtn down
  74
  75     updatePixmap ();
  76 }
  77
  78 kpGrip::~kpGrip ()
  79 {
  80 }
  81
  82
  83 // public
  84 kpGrip::GripType kpGrip::type () const
  85 {
  86     return m_type;
  87 }
  88
  89
  90 // public static
  91 QCursor kpGrip::cursorForType (GripType type)
  92 {
  93     switch (type)
  94     {
  95     case kpGrip::Bottom:
  96         return Qt::SizeVerCursor;
  97         break;  // one day you'll forget
  98
  99     case kpGrip::Right:
 100         return Qt::SizeHorCursor;
 101         break;  // one day you'll forget
 102
 103     case kpGrip::BottomRight:
 104         return Qt::SizeFDiagCursor;
 105         break;  // one day you'll forget
 106     }
 107
 108     return Qt::ArrowCursor;
 109 }
 110
 111
 112 // public
 113 QRect kpGrip::hotRect (bool toGlobal) const
 114 {
 115     QRect ret;
 116
 117     switch (m_type)
 118     {
 119     case kpGrip::Bottom:
 120     {
 121         const int handleX = (width () - GripHandleSize) / 2;
 122         ret = QRect (handleX, 0,
 123                      GripHandleSize, height ());
 124         break;
 125     }
 126     case kpGrip::Right:
 127     {
 128         const int handleY = (height () - GripHandleSize) / 2;
 129         ret = QRect (0, handleY,
 130                      width (), GripHandleSize);
 131         break;
 132     }
 133     case kpGrip::BottomRight:
 134         // pixmap all opaque
 135         ret = rect ();
 136         break;
 137
 138     default:
 139         return QRect ();
 140     }
 141
 142     return (toGlobal ? QRect (mapToGlobal (ret.topLeft ()),
 143                               mapToGlobal (ret.bottomRight ()))
 144                      : ret);
 145 }
 146
 147
 148 // public
 149 bool kpGrip::isDrawing () const
 150 {
 151     return (m_startPoint != KP_INVALID_POINT);
 152 }
 153
 154
 155 // public
 156 QString kpGrip::haventBegunDrawUserMessage () const
 157 {
 158     return i18n ("Left drag the handle to resize the image.");
 159 }
 160
 161
 162 // public
 163 QString kpGrip::userMessage () const
 164 {
 165     return m_userMessage;
 166 }
 167
 168 // public
 169 void kpGrip::setUserMessage (const QString &message)
 170 {
 171     // Don't do NOP checking here since another grip might have changed
 172     // the message so an apparent NOP for this grip is not a NOP in the
 173     // global sense (kpViewScrollableContainer::slotGripStatusMessageChanged()).
 174
 175     m_userMessage = message;
 176     emit statusMessageChanged (message);
 177 }
 178
 179
 180 // protected
 181 void kpGrip::updatePixmap ()
 182 {
 183 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
 184     kDebug () << "kpGrip::updatePixmap() rect=" << rect ();
 185 #endif
 186     if (width () <= 0 || height () <= 0)
 187         return;
 188
 189     QPixmap pixmap (width (), height ());
 190     kpPixmapFX::ensureTransparentAt (&pixmap, pixmap.rect ());
 191
 192     const QRect hr = hotRect ();
 193 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
 194     kDebug () << "\thotRect=" << hr;
 195 #endif
 196     if (hr.isValid ())
 197     {
 198         const QColor col = palette ().color (QPalette::Highlight);
 199         if (col.alpha () > 0)
 200         {
 201             // Note that we nuke the color's alpha (QColor::rgb()) since
 202             // kpPixmapFX methods can't handle it.
 203             kpPixmapFX::fillRect (&pixmap,
 204                 hr.x (), hr.y (), hr.width (), hr.height (),
 205                 kpColor (col.rgb ()));
 206         }
 207         else
 208         {
 209             // You have a crazy color palette with a transparent highlight
 210             // color.  Our pixmap is fully transparent already so nothing
 211             // needs to be done.
 212         }
 213     }
 214
 215     setPixmap (pixmap);
 216     setMask (pixmap.mask ());
 217 }
 218
 219
 220 // protected
 221 void kpGrip::cancel ()
 222 {
 223 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
 224     kDebug () << "kpGrip::cancel()";
 225 #endif
 226     if (m_currentPoint == KP_INVALID_POINT)
 227         return;
 228
 229     m_startPoint = KP_INVALID_POINT;
 230     m_currentPoint = KP_INVALID_POINT;
 231
 232     setUserMessage (i18n ("Resize Image: Let go of all the mouse buttons."));
 233     setCursor (Qt::ArrowCursor);
 234     m_shouldReleaseMouseButtons = true;
 235
 236     releaseKeyboard ();
 237     emit cancelledDraw ();
 238 }
 239
 240
 241 // protected virtual [base QWidget]
 242 void kpGrip::keyReleaseEvent (QKeyEvent *e)
 243 {
 244     if (m_startPoint != KP_INVALID_POINT &&
 245         e->key () == Qt::Key_Escape)
 246     {
 247         cancel ();
 248     }
 249 }
 250
 251 // protected virtual [base QWidget]
 252 void kpGrip::mousePressEvent (QMouseEvent *e)
 253 {
 254     if (m_startPoint == KP_INVALID_POINT &&
 255         (e->buttons () & Qt::MouseButtonMask) == Qt::LeftButton)
 256     {
 257         m_startPoint = e->pos ();
 258         m_currentPoint = e->pos ();
 259         emit beganDraw ();
 260         grabKeyboard ();
 261
 262         setUserMessage (i18n ("Resize Image: Right click to cancel."));
 263         setCursor (cursorForType (m_type));
 264     }
 265     else
 266     {
 267         if (m_startPoint != KP_INVALID_POINT)
 268             cancel ();
 269     }
 270 }
 271
 272 // public
 273 QPoint kpGrip::viewDeltaPoint () const
 274 {
 275     if (m_startPoint == KP_INVALID_POINT)
 276         return KP_INVALID_POINT;
 277
 278     const QPoint point = mapFromGlobal (QCursor::pos ());
 279
 280     // TODO: this is getting out of sync with m_currentPoint
 281
 282     return QPoint (((m_type & kpGrip::Right) ? point.x () - m_startPoint.x () : 0),
 283                    ((m_type & kpGrip::Bottom) ? point.y () - m_startPoint.y () : 0));
 284
 285 }
 286
 287 // public
 288 void kpGrip::mouseMovedTo (const QPoint &point, bool dueToDragScroll)
 289 {
 290     if (m_startPoint == KP_INVALID_POINT)
 291         return;
 292
 293     m_currentPoint = point;
 294
 295     emit continuedDraw (((m_type & kpGrip::Right) ? point.x () - m_startPoint.x () : 0),
 296                         ((m_type & kpGrip::Bottom) ? point.y () - m_startPoint.y () : 0),
 297                         dueToDragScroll);
 298 }
 299
 300 // protected virtual [base QWidget]
 301 void kpGrip::mouseMoveEvent (QMouseEvent *e)
 302 {
 303 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
 304     kDebug () << "kpGrip::mouseMoveEvent() m_startPoint=" << m_startPoint
 305                << " stateAfter: buttons=" << (int *) (int) e->buttons ()
 306                << endl;
 307 #endif
 308
 309     if (m_startPoint == KP_INVALID_POINT)
 310     {
 311         if ((e->buttons () & Qt::MouseButtonMask) == 0)
 312             setUserMessage (haventBegunDrawUserMessage ());
 313         return;
 314     }
 315
 316     mouseMovedTo (e->pos (), false/*not due to drag scroll*/);
 317 }
 318
 319 // protected virtual [base QWidget]
 320 void kpGrip::mouseReleaseEvent (QMouseEvent *e)
 321 {
 322 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
 323     kDebug () << "kpGrip::mouseReleaseEvent() m_startPoint=" << m_startPoint
 324                << " stateAfter: buttons=" << (int *) (int) e->buttons ()
 325                << endl;
 326 #endif
 327
 328     if (m_startPoint != KP_INVALID_POINT)
 329     {
 330         const int dx = m_currentPoint.x () - m_startPoint.x (),
 331                   dy = m_currentPoint.y () - m_startPoint.y ();
 332
 333         m_currentPoint = KP_INVALID_POINT;
 334         m_startPoint = KP_INVALID_POINT;
 335
 336         releaseKeyboard ();
 337         emit endedDraw ((m_type & kpGrip::Right) ? dx : 0,
 338                         (m_type & kpGrip::Bottom) ? dy : 0);
 339     }
 340
 341     if ((e->buttons () & Qt::MouseButtonMask) == 0)
 342     {
 343         m_shouldReleaseMouseButtons = false;
 344         setUserMessage (QString::null); //krazy:exclude=nullstrassigment for old broken gcc
 345         setCursor (cursorForType (m_type));
 346
 347         releaseKeyboard ();
 348         emit releasedAllButtons ();
 349     }
 350 }
 351
 352
 353 // protected virtual [base QWidget]
 354 void kpGrip::resizeEvent (QResizeEvent *)
 355 {
 356 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
 357     kDebug () << "kpGrip::resizeEvent()";
 358 #endif
 359     updatePixmap ();
 360 }
 361
 362
 363 // protected virtual [base QWidget]
 364 void kpGrip::enterEvent (QEvent * /*e*/)
 365 {
 366 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
 367     kDebug () << "kpGrip::enterEvent()"
 368                << " m_startPoint=" << m_startPoint
 369                << " shouldReleaseMouseButtons="
 370                << m_shouldReleaseMouseButtons << endl;
 371 #endif
 372
 373     if (m_startPoint == KP_INVALID_POINT &&
 374         !m_shouldReleaseMouseButtons)
 375     {
 376     #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
 377         kDebug () << "\tsending message";
 378     #endif
 379         setUserMessage (haventBegunDrawUserMessage ());
 380     }
 381 }
 382
 383 // protected virtual [base QWidget]
 384 void kpGrip::leaveEvent (QEvent * /*e*/)
 385 {
 386 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
 387     kDebug () << "kpGrip::leaveEvent()"
 388                << " m_startPoint=" << m_startPoint
 389                << " shouldReleaseMouseButtons="
 390                << m_shouldReleaseMouseButtons << endl;
 391 #endif
 392     if (m_startPoint == KP_INVALID_POINT &&
 393         !m_shouldReleaseMouseButtons)
 394     {
 395         setUserMessage (QString::null); //krazy:exclude=nullstrassigment for old broken gcc
 396     }
 397 }
 398
 399
 400 // protected virtual [base QWidget]
 401 void kpGrip::paintEvent (QPaintEvent *e)
 402 {
 403 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER && 0
 404     kDebug () << "kpGrip::paintEvent(" << e->rect () << ")";
 405 #endif
 406     QLabel::paintEvent (e);
 407 }
 408
 409
 410 // TODO: Are we checking for m_view == 0 often enough?  Also an issue in KDE 3.
 411 kpViewScrollableContainer::kpViewScrollableContainer (kpMainWindow *parent)
 412     : Q3ScrollView ((QWidget *) parent),
 413       m_mainWindow (parent),
 414       m_contentsXSoon (-1), m_contentsYSoon (-1),
 415       m_view (0),
 416       m_bottomGrip (new kpGrip (kpGrip::Bottom, viewport ())),
 417       m_rightGrip (new kpGrip (kpGrip::Right, viewport ())),
 418       m_bottomRightGrip (new kpGrip (kpGrip::BottomRight, viewport ())),
 419       m_docResizingGrip (0),
 420       m_dragScrollTimer (new QTimer (this)),
 421       m_zoomLevel (100),
 422       m_scrollTimerRunOnce (false),
 423       m_resizeRoundedLastViewX (-1), m_resizeRoundedLastViewY (-1),
 424       m_resizeRoundedLastViewDX (0), m_resizeRoundedLastViewDY (0),
 425       m_haveMovedFromOriginalDocSize (false)
 426
 427 {
 428     m_bottomGrip->setObjectName ("Bottom Grip");
 429     m_rightGrip->setObjectName ("Right Grip");
 430     m_bottomRightGrip->setObjectName ("BottomRight Grip");
 431
 432     // HITODO: drawResizeLines() uses this feature -- it therefore
 433     //         flickers and only works on X11.  Fix drawResizeLines()
 434     //         to remove the need for these attributes.
 435     viewport ()->setAttribute (Qt::WA_PaintOutsidePaintEvent);
 436     viewport ()->setAttribute (Qt::WA_PaintUnclipped);
 437
 438     m_bottomGrip->setFixedHeight (kpGrip::Size);
 439     m_bottomGrip->hide ();
 440     addChild (m_bottomGrip);
 441     connectGripSignals (m_bottomGrip);
 442
 443     m_rightGrip->setFixedWidth (kpGrip::Size);
 444     m_rightGrip->hide ();
 445     addChild (m_rightGrip);
 446     connectGripSignals (m_rightGrip);
 447
 448     m_bottomRightGrip->setFixedSize (kpGrip::Size, kpGrip::Size);
 449     m_bottomRightGrip->hide ();
 450     addChild (m_bottomRightGrip);
 451     connectGripSignals (m_bottomRightGrip);
 452
 453
 454     connect (this, SIGNAL (contentsMoving (int, int)),
 455              this, SLOT (slotContentsMoving (int, int)));
 456
 457     connect (m_dragScrollTimer, SIGNAL (timeout ()),
 458              this, SLOT (slotDragScroll ()));
 459 }
 460
 461 kpViewScrollableContainer::~kpViewScrollableContainer ()
 462 {
 463 }
 464
 465
 466 // public
 467 int kpViewScrollableContainer::contentsXSoon ()
 468 {
 469     if (m_contentsXSoon < 0)
 470         return contentsX ();
 471     else
 472         return m_contentsXSoon;
 473 }
 474
 475 // public
 476 int kpViewScrollableContainer::contentsYSoon ()
 477 {
 478     if (m_contentsYSoon < 0)
 479         return contentsY ();
 480     else
 481         return m_contentsYSoon;
 482 }
 483
 484
 485 // protected
 486 void kpViewScrollableContainer::connectGripSignals (kpGrip *grip)
 487 {
 488     connect (grip, SIGNAL (beganDraw ()),
 489              this, SLOT (slotGripBeganDraw ()));
 490     connect (grip, SIGNAL (continuedDraw (int, int, bool)),
 491              this, SLOT (slotGripContinuedDraw (int, int, bool)));
 492     connect (grip, SIGNAL (cancelledDraw ()),
 493              this, SLOT (slotGripCancelledDraw ()));
 494     connect (grip, SIGNAL (endedDraw (int, int)),
 495              this, SLOT (slotGripEndedDraw (int, int)));
 496
 497     connect (grip, SIGNAL (statusMessageChanged (const QString &)),
 498              this, SLOT (slotGripStatusMessageChanged (const QString &)));
 499
 500     connect (grip, SIGNAL (releasedAllButtons ()),
 501              this, SLOT (recalculateStatusMessage ()));
 502 }
 503
 504
 505 // public
 506 QSize kpViewScrollableContainer::newDocSize () const
 507 {
 508     return newDocSize (m_resizeRoundedLastViewDX,
 509                        m_resizeRoundedLastViewDY);
 510 }
 511
 512 // public
 513 bool kpViewScrollableContainer::haveMovedFromOriginalDocSize () const
 514 {
 515     return m_haveMovedFromOriginalDocSize;
 516 }
 517
 518 // public
 519 QString kpViewScrollableContainer::statusMessage () const
 520 {
 521     return m_gripStatusMessage;
 522 }
 523
 524 // public
 525 void kpViewScrollableContainer::clearStatusMessage ()
 526 {
 527 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER && 1
 528     kDebug () << "kpViewScrollableContainer::clearStatusMessage()";
 529 #endif
 530     m_bottomRightGrip->setUserMessage (QString::null);  //krazy:exclude=nullstrassigment for old broken gcc
 531     m_bottomGrip->setUserMessage (QString::null);       //krazy:exclude=nullstrassigment for old broken gcc
 532     m_rightGrip->setUserMessage (QString::null);        //krazy:exclude=nullstrassigment for old broken gcc
 533 }
 534
 535 // protected
 536 QSize kpViewScrollableContainer::newDocSize (int viewDX, int viewDY) const
 537 {
 538     if (!m_view)
 539         return QSize ();
 540
 541     if (!docResizingGrip ())
 542         return QSize ();
 543
 544     const int docX = (int) m_view->transformViewToDocX (m_view->width () + viewDX);
 545     const int docY = (int) m_view->transformViewToDocY (m_view->height () + viewDY);
 546
 547     return QSize (qMax (1, docX), qMax (1, docY));
 548 }
 549
 550
 551 // protected
 552 void kpViewScrollableContainer::calculateDocResizingGrip ()
 553 {
 554     if (m_bottomRightGrip->isDrawing ())
 555         m_docResizingGrip = m_bottomRightGrip;
 556     else if (m_bottomGrip->isDrawing ())
 557         m_docResizingGrip = m_bottomGrip;
 558     else if (m_rightGrip->isDrawing ())
 559         m_docResizingGrip = m_rightGrip;
 560     else
 561         m_docResizingGrip = 0;
 562 }
 563
 564 // protected
 565 kpGrip *kpViewScrollableContainer::docResizingGrip () const
 566 {
 567     return m_docResizingGrip;
 568 }
 569
 570
 571 // protected
 572 int kpViewScrollableContainer::bottomResizeLineWidth () const
 573 {
 574     if (!docResizingGrip ())
 575         return -1;
 576
 577     if (!m_view)
 578         return -1;
 579
 580     if (docResizingGrip ()->type () & kpGrip::Bottom)
 581         return qMax (m_view->zoomLevelY () / 100, 1);
 582     else
 583         return 1;
 584 }
 585
 586 // protected
 587 int kpViewScrollableContainer::rightResizeLineWidth () const
 588 {
 589     if (!docResizingGrip ())
 590         return -1;
 591
 592     if (!m_view)
 593         return -1;
 594
 595     if (docResizingGrip ()->type () & kpGrip::Right)
 596         return qMax (m_view->zoomLevelX () / 100, 1);
 597     else
 598         return 1;
 599 }
 600
 601
 602 // protected
 603 QRect kpViewScrollableContainer::bottomResizeLineRect () const
 604 {
 605     if (m_resizeRoundedLastViewX < 0 || m_resizeRoundedLastViewY < 0)
 606         return QRect ();
 607
 608     QRect visibleArea = QRect(QPoint(contentsX(),contentsY()), viewport()->size());
 609
 610     return QRect (QPoint (0,
 611                           m_resizeRoundedLastViewY),
 612                   QPoint (m_resizeRoundedLastViewX - 1,
 613                           m_resizeRoundedLastViewY + bottomResizeLineWidth () - 1)).intersected(visibleArea);
 614 }
 615
 616 // protected
 617 QRect kpViewScrollableContainer::rightResizeLineRect () const
 618 {
 619     if (m_resizeRoundedLastViewX < 0 || m_resizeRoundedLastViewY < 0)
 620         return QRect ();
 621
 622     QRect visibleArea = QRect(QPoint(contentsX(),contentsY()), viewport()->size());
 623
 624     return QRect (QPoint (m_resizeRoundedLastViewX,
 625                           0),
 626                   QPoint (m_resizeRoundedLastViewX + rightResizeLineWidth () - 1,
 627                           m_resizeRoundedLastViewY - 1)).intersected(visibleArea);
 628 }
 629
 630 // protected
 631 QRect kpViewScrollableContainer::bottomRightResizeLineRect () const
 632 {
 633     if (m_resizeRoundedLastViewX < 0 || m_resizeRoundedLastViewY < 0)
 634         return QRect ();
 635
 636     QRect visibleArea = QRect(QPoint(contentsX(),contentsY()), viewport()->size());
 637
 638     return QRect (QPoint (m_resizeRoundedLastViewX,
 639                           m_resizeRoundedLastViewY),
 640                   QPoint (m_resizeRoundedLastViewX + rightResizeLineWidth () - 1,
 641                           m_resizeRoundedLastViewY + bottomResizeLineWidth () - 1)).intersected(visibleArea);
 642 }
 643
 644
 645 // TODO: are these 2 correct?  Remember that viewport()->x() == 1, viewport()->y() == 1
 646
 647 // protected
 648 QPoint kpViewScrollableContainer::mapViewToViewport (const QPoint &viewPoint)
 649 {
 650     return viewPoint - QPoint (contentsX (), contentsY ());
 651 }
 652
 653 // protected
 654 QRect kpViewScrollableContainer::mapViewToViewport (const QRect &viewRect)
 655 {
 656     if (!viewRect.isValid ())
 657         return QRect ();
 658
 659     QRect ret = viewRect;
 660     ret.translate (-contentsX (), -contentsY ());
 661     return ret;
 662 }
 663
 664
 665 // protected
 666 QRect kpViewScrollableContainer::mapViewportToGlobal (const QRect &viewportRect)
 667 {
 668     return kpWidgetMapper::toGlobal (viewport (), viewportRect);
 669 }
 670
 671 // protected
 672 QRect kpViewScrollableContainer::mapViewToGlobal (const QRect &viewRect)
 673 {
 674     return mapViewportToGlobal (mapViewToViewport (viewRect));
 675 }
 676
 677
 678 // protected
 679 void kpViewScrollableContainer::repaintWidgetAtResizeLineViewRect (
 680     QWidget *widget, const QRect &resizeLineViewRect)
 681 {
 682     const QRect resizeLineGlobalRect = mapViewToGlobal (resizeLineViewRect);
 683     const QRect widgetGlobalRect = kpWidgetMapper::toGlobal (widget,
 684                                                              widget->rect ());
 685
 686     const QRect redrawGlobalRect =
 687         resizeLineGlobalRect.intersect (widgetGlobalRect);
 688
 689     const QRect redrawWidgetRect =
 690         kpWidgetMapper::fromGlobal (widget, redrawGlobalRect);
 691
 692
 693     if (redrawWidgetRect.isValid ())
 694     {
 695         widget->repaint (redrawWidgetRect);
 696     }
 697 }
 698
 699 // protected
 700 void kpViewScrollableContainer::repaintWidgetAtResizeLines (QWidget *widget)
 701 {
 702     repaintWidgetAtResizeLineViewRect (widget, rightResizeLineRect ());
 703     repaintWidgetAtResizeLineViewRect (widget, bottomResizeLineRect ());
 704     repaintWidgetAtResizeLineViewRect (widget, bottomRightResizeLineRect ());
 705 }
 706
 707 // protected
 708 void kpViewScrollableContainer::eraseResizeLines ()
 709 {
 710     if (m_resizeRoundedLastViewX >= 0 && m_resizeRoundedLastViewY >= 0)
 711     {
 712         repaintWidgetAtResizeLines (viewport ());
 713         repaintWidgetAtResizeLines (m_view);
 714
 715         repaintWidgetAtResizeLines (m_bottomGrip);
 716         repaintWidgetAtResizeLines (m_rightGrip);
 717         repaintWidgetAtResizeLines (m_bottomRightGrip);
 718     }
 719 }
 720
 721
 722 // protected
 723 void kpViewScrollableContainer::drawResizeLines ()
 724 {
 725 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER && 0
 726     kDebug () << "kpViewScrollableContainer::drawResizeLines()"
 727                << " lastViewX=" << m_resizeRoundedLastViewX
 728                << " lastViewY=" << m_resizeRoundedLastViewY
 729                << endl;
 730 #endif
 731
 732
 733 // TODO: If XRENDER is disabled, this painting with Qt::WA_PaintUnclipped
 734 //       seems to trigger a harmless, asynchronous error:
 735 //
 736 //           X Error: RenderBadPicture (invalid Picture parameter) 180
 737 //           Extension:    153 (RENDER)
 738 //           Minor opcode: 5 (RenderChangePicture)
 739 //           Resource id:  0x0
 740 //
 741 //       I don't know what code is _directly_ triggering that error -- running
 742 //       KolourPaint with "-sync" doesn't seem to make the error synchronous.
 743 //
 744 //       The API doc for Qt::WA_PaintUnclipped says "This flag is only
 745 //       supported for widgets for which the WA_PaintOnScreen".  We don't
 746 //       actually enable "WA_PaintOnScreen" (which looks quite scary), so that
 747 //       might be part of the cause.
 748 #define FILL_NOT_RECT(rect)                                              \
 749     kpPixmapFX::widgetFillNOTRect (viewport (),                          \
 750         rect.x (), rect.y (), rect.width (), rect.height (),             \
 751         kpColor::Black/*1st hint color if "Raster NOT" not supported*/,  \
 752         kpColor::White/*2nd hint color if "Raster NOT" not supported*/)
 753
 754     const QRect rightRect = rightResizeLineRect ();
 755     if (rightRect.isValid ())
 756         FILL_NOT_RECT (mapViewToViewport (rightRect));
 757
 758     const QRect bottomRect = bottomResizeLineRect ();
 759     if (bottomRect.isValid ())
 760         FILL_NOT_RECT (mapViewToViewport (bottomRect));
 761
 762     const QRect bottomRightRect = bottomRightResizeLineRect ();
 763     if (bottomRightRect.isValid ())
 764         FILL_NOT_RECT (mapViewToViewport (bottomRightRect));
 765
 766 #undef FILL_NOT_RECT
 767 }
 768
 769
 770 // protected
 771 void kpViewScrollableContainer::updateResizeLines (int viewX, int viewY,
 772                                                    int viewDX, int viewDY)
 773 {
 774 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER && 0
 775     kDebug () << "kpViewScrollableContainer::updateResizeLines("
 776                << viewX << "," << viewY << ")"
 777                << " oldViewX=" << m_resizeRoundedLastViewX
 778                << " oldViewY=" << m_resizeRoundedLastViewY
 779                << " viewDX=" << viewDX
 780                << " viewDY=" << viewDY
 781                << endl;
 782 #endif
 783
 784     eraseResizeLines ();
 785
 786
 787     if (viewX >= 0 && viewY >= 0)
 788     {
 789         m_resizeRoundedLastViewX = (int) m_view->transformDocToViewX ((int) m_view->transformViewToDocX (viewX));
 790         m_resizeRoundedLastViewY = (int) m_view->transformDocToViewY ((int) m_view->transformViewToDocY (viewY));
 791
 792         m_resizeRoundedLastViewDX = viewDX;
 793         m_resizeRoundedLastViewDY = viewDY;
 794     }
 795     else
 796     {
 797         m_resizeRoundedLastViewX = -1;
 798         m_resizeRoundedLastViewY = -1;
 799
 800         m_resizeRoundedLastViewDX = 0;
 801         m_resizeRoundedLastViewDY = 0;
 802     }
 803
 804     // TODO: This is suboptimal since if another window pops up on top of
 805     //       KolourPaint then disappears, the lines are not redrawn
 806     //       (although this doesn't happen very frequently since we grab the
 807     //       keyboard and mouse when resizing):
 808     //
 809     //         e.g. sleep 5 && gedit & sleep 10 && killall gedit
 810     //
 811     //       Should be done in the paintEvent's of every child of the
 812     //       scrollview.
 813     drawResizeLines ();
 814 }
 815
 816
 817 // protected slot
 818 void kpViewScrollableContainer::slotGripBeganDraw ()
 819 {
 820     if (!m_view)
 821         return;
 822
 823     calculateDocResizingGrip ();
 824
 825     m_haveMovedFromOriginalDocSize = false;
 826
 827     updateResizeLines (m_view->width (), m_view->height (),
 828                        0/*viewDX*/, 0/*viewDY*/);
 829
 830     emit beganDocResize ();
 831 }
 832
 833 // protected slot
 834 void kpViewScrollableContainer::slotGripContinuedDraw (int inViewDX, int inViewDY,
 835                                                        bool dueToDragScroll)
 836 {
 837     int viewDX = inViewDX,
 838         viewDY = inViewDY;
 839
 840 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
 841     kDebug () << "kpViewScrollableContainer::slotGripContinuedDraw("
 842                << viewDX << "," << viewDY << ") size="
 843                << newDocSize (viewDX, viewDY)
 844                << " dueToDragScroll=" << dueToDragScroll
 845                << endl;
 846 #endif
 847
 848     if (!m_view)
 849         return;
 850
 851     if (!dueToDragScroll &&
 852         beginDragScroll (QPoint (), QPoint (), m_view->zoomLevelX ()))
 853     {
 854         const QPoint newViewDeltaPoint = docResizingGrip ()->viewDeltaPoint ();
 855         viewDX = newViewDeltaPoint.x ();
 856         viewDY = newViewDeltaPoint.y ();
 857     #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
 858         kDebug () << "\tdrag scrolled - new view delta point="
 859                    << newViewDeltaPoint
 860                    << endl;
 861     #endif
 862     }
 863
 864     m_haveMovedFromOriginalDocSize = true;
 865
 866     updateResizeLines (qMax (1, qMax (m_view->width () + viewDX, (int) m_view->transformDocToViewX (1))),
 867                        qMax (1, qMax (m_view->height () + viewDY, (int) m_view->transformDocToViewY (1))),
 868                        viewDX, viewDY);
 869
 870     emit continuedDocResize (newDocSize ());
 871 }
 872
 873 // protected slot
 874 void kpViewScrollableContainer::slotGripCancelledDraw ()
 875 {
 876     m_haveMovedFromOriginalDocSize = false;
 877
 878     updateResizeLines (-1, -1, 0, 0);
 879
 880     calculateDocResizingGrip ();
 881
 882     emit cancelledDocResize ();
 883
 884     endDragScroll ();
 885 }
 886
 887 // protected slot
 888 void kpViewScrollableContainer::slotGripEndedDraw (int viewDX, int viewDY)
 889 {
 890 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
 891     kDebug () << "kpViewScrollableContainer::slotGripEndedDraw("
 892                << viewDX << "," << viewDY << ") size="
 893                << newDocSize (viewDX, viewDY)
 894                << endl;
 895 #endif
 896
 897     if (!m_view)
 898         return;
 899
 900     const QSize newSize = newDocSize (viewDX, viewDY);
 901
 902     m_haveMovedFromOriginalDocSize = false;
 903
 904     // must erase lines before view size changes
 905     updateResizeLines (-1, -1, 0, 0);
 906
 907     calculateDocResizingGrip ();
 908
 909     emit endedDocResize (newSize);
 910
 911     endDragScroll ();
 912 }
 913
 914
 915 // protected slot
 916 void kpViewScrollableContainer::slotGripStatusMessageChanged (const QString &string)
 917 {
 918     if (string == m_gripStatusMessage)
 919         return;
 920
 921     m_gripStatusMessage = string;
 922     emit statusMessageChanged (string);
 923 }
 924
 925
 926 // public slot
 927 void kpViewScrollableContainer::recalculateStatusMessage ()
 928 {
 929 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
 930     kDebug () << "kpViewScrollabelContainer::recalculateStatusMessage()";
 931     kDebug () << "\tQCursor::pos=" << QCursor::pos ()
 932                << " global visibleRect="
 933                << kpWidgetMapper::toGlobal (this,
 934                       QRect (0, 0, visibleWidth (), visibleHeight ()))
 935                << " brGrip.hotRect=" << m_bottomRightGrip->hotRect (true)
 936                << " bGrip.hotRect=" << m_bottomGrip->hotRect (true)
 937                << " rGrip.hotRect=" << m_rightGrip->hotRect (true)
 938                << endl;
 939 #endif
 940
 941     // HACK: After dragging to a new size, handles move so that they are now
 942     //       under the mouse pointer but no mouseMoveEvent() is generated for
 943     //       any grip.  This also handles the case of canceling over any
 944     //       grip.
 945     //
 946     if (kpWidgetMapper::toGlobal (this,
 947                                   QRect (0, 0, visibleWidth (), visibleHeight ()))
 948             .contains (QCursor::pos ()))
 949     {
 950         if (!m_bottomRightGrip->isHidden () &&
 951             m_bottomRightGrip->hotRect (true/*to global*/)
 952                 .contains (QCursor::pos ()))
 953         {
 954             m_bottomRightGrip->setUserMessage (i18n ("Left drag the handle to resize the image."));
 955         }
 956         else if (!m_bottomGrip->isHidden () &&
 957                 m_bottomGrip->hotRect (true/*to global*/)
 958                     .contains (QCursor::pos ()))
 959         {
 960             m_bottomGrip->setUserMessage (i18n ("Left drag the handle to resize the image."));
 961         }
 962         else if (!m_rightGrip->isHidden () &&
 963                 m_rightGrip->hotRect (true/*to global*/)
 964                     .contains (QCursor::pos ()))
 965         {
 966             m_rightGrip->setUserMessage (i18n ("Left drag the handle to resize the image."));
 967         }
 968         else
 969         {
 970             clearStatusMessage ();
 971         }
 972     }
 973     else
 974     {
 975         clearStatusMessage ();
 976     }
 977 }
 978
 979
 980 // protected slot
 981 void kpViewScrollableContainer::slotContentsMoving (int x, int y)
 982 {
 983 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
 984     kDebug () << "kpViewScrollableContainer::slotContentsMoving("
 985                << x << "," << y << ")"
 986                << " contentsX=" << contentsX ()
 987                << " contentsY=" << contentsY () << endl;
 988 #endif
 989
 990     m_contentsXSoon = x, m_contentsYSoon = y;
 991     emit contentsMovingSoon (m_contentsXSoon, m_contentsYSoon);
 992
 993     // Reduce flicker - don't let QScrollView scroll to-be-erased lines
 994     eraseResizeLines ();
 995
 996     QTimer::singleShot (0, this, SLOT (slotContentsMoved ()));
 997 }
 998
 999 // protected slot
1000 void kpViewScrollableContainer::slotContentsMoved ()
1001 {
1002     m_contentsXSoon = m_contentsYSoon = -1;
1003
1004     kpGrip *grip = docResizingGrip ();
1005 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1006     kDebug () << "kpViewScrollableContainer::slotContentsMoved()"
1007                << " grip=" << grip
1008                << " contentsX=" << contentsX ()
1009                << " contentsY=" << contentsY () << endl;
1010 #endif
1011     if (!grip)
1012         return;
1013
1014     grip->mouseMovedTo (grip->mapFromGlobal (QCursor::pos ()),
1015                         true/*moved due to drag scroll*/);
1016 }
1017
1018
1019 // protected
1020 void kpViewScrollableContainer::disconnectViewSignals ()
1021 {
1022     disconnect (m_view, SIGNAL (sizeChanged (const QSize &)),
1023                 this, SLOT (updateGrips ()));
1024     disconnect (m_view, SIGNAL (destroyed ()),
1025                 this, SLOT (slotViewDestroyed ()));
1026 }
1027
1028 // protected
1029 void kpViewScrollableContainer::connectViewSignals ()
1030 {
1031     connect (m_view, SIGNAL (sizeChanged (const QSize &)),
1032              this, SLOT (updateGrips ()));
1033     connect (m_view, SIGNAL (destroyed ()),
1034              this, SLOT (slotViewDestroyed ()));
1035 }
1036
1037
1038 // public virtual [base QScrollView]
1039 void kpViewScrollableContainer::addChild (QWidget *widget, int x, int y)
1040 {
1041 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1042     kDebug () << "kpViewScrollableContainer::addChild(" << widget
1043                << "," << x << "," << y << endl;
1044 #endif
1045
1046     Q3ScrollView::addChild (widget, x, y);
1047
1048     kpView *view = dynamic_cast <kpView *> (widget);
1049 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1050     kDebug () << "\tcast to kpView: " << view;
1051 #endif
1052     if (view)
1053     {
1054         setView (view);
1055     }
1056 }
1057
1058
1059 // public
1060 kpView *kpViewScrollableContainer::view () const
1061 {
1062     return m_view;
1063 }
1064
1065 // public
1066 void kpViewScrollableContainer::setView (kpView *view)
1067 {
1068 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1069     kDebug () << "kpViewScrollableContainer::setView(" << view << ")";
1070 #endif
1071
1072     if (m_view == view)
1073         return;
1074
1075     if (m_view)
1076     {
1077         disconnectViewSignals ();
1078     }
1079
1080     m_view = view;
1081
1082     updateGrips ();
1083
1084     if (m_view)
1085     {
1086         connectViewSignals ();
1087     }
1088 }
1089
1090
1091 // public slot
1092 void kpViewScrollableContainer::updateGrips ()
1093 {
1094 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1095     kDebug () << "kpViewScrollableContainer::updateGrips() m_view="
1096               << m_view
1097               << " (size=" << (m_view ? m_view->size () : QSize ()) << ")"
1098               << endl;
1099 #endif
1100
1101     if (m_view)
1102     {
1103         m_bottomGrip->setFixedWidth (m_view->width ());
1104         moveChild (m_bottomGrip, 0, m_view->height ());
1105
1106         m_rightGrip->setFixedHeight (m_view->height ());
1107         moveChild (m_rightGrip, m_view->width (), 0);
1108
1109         moveChild (m_bottomRightGrip, m_view->width (), m_view->height ());
1110     #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1111         kDebug () << "\tbottomRightGrip=" << m_bottomRightGrip->pos ();
1112     #endif
1113     }
1114
1115     m_bottomGrip->setHidden (m_view == 0);
1116     m_rightGrip->setHidden (m_view == 0);
1117     m_bottomRightGrip->setHidden (m_view == 0);
1118
1119 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1120     kDebug () << "\tcontentsRect=" << contentsRect ()
1121                << " visibleRect=" << visibleRect ()
1122                << " viewportRect=" << viewport ()->rect ()
1123                << endl;
1124 #endif
1125
1126     if (m_view)
1127     {
1128         resizeContents (m_view->width () + m_rightGrip->width (),
1129                         m_view->height () + m_bottomGrip->height ());
1130     }
1131     else
1132     {
1133         resizeContents (0, 0);
1134     }
1135
1136     recalculateStatusMessage ();
1137 }
1138
1139 // protected slot
1140 void kpViewScrollableContainer::slotViewDestroyed ()
1141 {
1142 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1143     kDebug () << "kpViewScrollableContainer::slotViewDestroyed() m_view="
1144                << m_view << endl;
1145 #endif
1146
1147     m_view = 0;
1148     updateGrips ();
1149 }
1150
1151
1152 // public slot
1153 bool kpViewScrollableContainer::beginDragScroll (const QPoint &/*docPoint*/,
1154                                                  const QPoint &/*lastDocPoint*/,
1155                                                  int zoomLevel,
1156                                                  bool *didSomething)
1157 {
1158     if (didSomething)
1159         *didSomething = false;
1160
1161     m_zoomLevel = zoomLevel;
1162
1163     const QPoint p = mapFromGlobal (QCursor::pos ());
1164
1165 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1166     kDebug () << "kpViewScrollableContainer::beginDragScroll() p=" << p
1167                << " dragScrollTimerRunOnce=" << m_scrollTimerRunOnce
1168                << endl;
1169 #endif
1170
1171     bool stopDragScroll = true;
1172     bool scrolled = false;
1173
1174     if (!noDragScrollRect ().contains (p))
1175     {
1176         if (m_dragScrollTimer->isActive ())
1177         {
1178             if (m_scrollTimerRunOnce)
1179             {
1180                 scrolled = slotDragScroll ();
1181             }
1182         }
1183         else
1184         {
1185             m_scrollTimerRunOnce = false;
1186             m_dragScrollTimer->start (DragScrollInitialInterval);
1187         }
1188
1189         stopDragScroll = false;
1190     }
1191
1192     if (stopDragScroll)
1193         m_dragScrollTimer->stop ();
1194
1195     if (didSomething)
1196         *didSomething = scrolled;
1197
1198     return scrolled;
1199 }
1200
1201 // public slot
1202 bool kpViewScrollableContainer::beginDragScroll (const QPoint &docPoint,
1203                                                  const QPoint &lastDocPoint,
1204                                                  int zoomLevel)
1205 {
1206     return beginDragScroll (docPoint, lastDocPoint, zoomLevel,
1207                             0/*don't want scrolled notification*/);
1208 }
1209
1210
1211 // public slot
1212 bool kpViewScrollableContainer::endDragScroll ()
1213 {
1214 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1215     kDebug () << "kpViewScrollableContainer::endDragScroll()";
1216 #endif
1217
1218     if (m_dragScrollTimer->isActive ())
1219     {
1220         m_dragScrollTimer->stop ();
1221         return true;
1222     }
1223     else
1224     {
1225         return false;
1226     }
1227 }
1228
1229
1230 static const int distanceFromRectToMultiplier (int dist)
1231 {
1232     if (dist < 0)
1233         return 0;
1234     else if (dist < DragDistanceFromRectMaxFor1stMultiplier)
1235         return 1;
1236     else if (dist < DragDistanceFromRectMaxFor2ndMultiplier)
1237         return 2;
1238     else
1239         return 4;
1240 }
1241
1242
1243 // protected slot
1244 bool kpViewScrollableContainer::slotDragScroll (bool *didSomething)
1245 {
1246     bool scrolled = false;
1247
1248     if (didSomething)
1249         *didSomething = false;
1250
1251
1252     const QRect rect = noDragScrollRect ();
1253     const QPoint pos = mapFromGlobal (QCursor::pos ());
1254
1255 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1256     for (int i = 0; i < 10; i++)
1257         kDebug () << QString ();
1258
1259     kDebug () << "kpViewScrollableContainer::slotDragScroll()"
1260                   << " noDragScrollRect=" << rect
1261                   << " pos=" << pos
1262                   << " contentsX=" << contentsX ()
1263                   << " contentsY=" << contentsY () << endl;
1264 #endif
1265
1266     int dx = 0, dy = 0;
1267     int dxMultiplier = 0, dyMultiplier = 0;
1268
1269     if (pos.x () < rect.left ())
1270     {
1271         dx = -DragScrollNumPixels;
1272         dxMultiplier = distanceFromRectToMultiplier (rect.left () - pos.x ());
1273     }
1274     else if (pos.x () > rect.right ())
1275     {
1276         dx = +DragScrollNumPixels;
1277         dxMultiplier = distanceFromRectToMultiplier (pos.x () - rect.right ());
1278     }
1279
1280     if (pos.y () < rect.top ())
1281     {
1282         dy = -DragScrollNumPixels;
1283         dyMultiplier = distanceFromRectToMultiplier (rect.top () - pos.y ());
1284     }
1285     else if (pos.y () > rect.bottom ())
1286     {
1287         dy = +DragScrollNumPixels;
1288         dyMultiplier = distanceFromRectToMultiplier (pos.y () - rect.bottom ());
1289     }
1290
1291 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER && 1
1292     kDebug () << "kpViewScrollableContainer::slotDragScroll()"
1293                   << " dx=" << dx << " * " << dxMultiplier
1294                   << " dy=" << dy << " * " << dyMultiplier
1295                   << " zoomLevel=" << m_zoomLevel
1296                   << endl;
1297 #endif
1298
1299     dx *= dxMultiplier;// * qMax (1, m_zoomLevel / 100);
1300     dy *= dyMultiplier;// * qMax (1, m_zoomLevel / 100);
1301
1302     if (dx || dy)
1303     {
1304         const int oldContentsX = contentsX (),
1305                   oldContentsY = contentsY ();
1306
1307         scrollBy (dx, dy);
1308
1309     #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER && 1
1310         kDebug () << "\tafter scrollBy():"
1311                    << " contentsX=" << contentsX ()
1312                    << " contentsY=" << contentsY () << endl;
1313     #endif
1314
1315         scrolled = (oldContentsX != contentsX () ||
1316                     oldContentsY != contentsY ());
1317
1318         if (scrolled)
1319         {
1320             QRegion region = QRect (contentsX (), contentsY (),
1321                                     visibleWidth (), visibleHeight ());
1322             region -= QRect (oldContentsX, oldContentsY,
1323                              visibleWidth (), visibleHeight ());
1324
1325             // Repaint newly exposed region immediately to reduce tearing
1326             // of scrollView.
1327      #if 1
1328         #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER && 1
1329             kDebug () << "\t\tscrolled - repaint new region:" << region;
1330         #endif
1331             m_view->repaint (region);
1332         #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER && 1
1333             kDebug () << "\t\tscrolled - repainted";
1334         #endif
1335      #endif
1336         }
1337     }
1338
1339
1340     m_dragScrollTimer->start (DragScrollInterval);
1341     m_scrollTimerRunOnce = true;
1342
1343
1344     if (didSomething)
1345         *didSomething = scrolled;
1346
1347
1348 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER && 1
1349     for (int i = 0; i < 10; i++)
1350         kDebug () << QString ();
1351 #endif
1352
1353     return scrolled;
1354 }
1355
1356 // protected virtual [base QScrollView]
1357 void kpViewScrollableContainer::contentsDragMoveEvent (QDragMoveEvent *e)
1358 {
1359 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1360     kDebug () << "kpViewScrollableContainer::contentsDragMoveEvent"
1361                << e->pos ()
1362                << endl;
1363 #endif
1364
1365     Q3ScrollView::contentsDragMoveEvent (e);
1366 }
1367
1368 // protected slot
1369 bool kpViewScrollableContainer::slotDragScroll ()
1370 {
1371     return slotDragScroll (0/*don't want scrolled notification*/);
1372 }
1373
1374
1375 // protected virtual [base QScrollView]
1376 void kpViewScrollableContainer::contentsMouseMoveEvent (QMouseEvent *e)
1377 {
1378 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1379     kDebug () << "kpViewScrollableContainer::contentsMouseMoveEvent"
1380                << e->pos ()
1381                << endl;
1382 #endif
1383
1384     Q3ScrollView::contentsMouseMoveEvent (e);
1385 }
1386
1387 // protected virtual [base QScrollView]
1388 void kpViewScrollableContainer::mouseMoveEvent (QMouseEvent *e)
1389 {
1390 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1391     kDebug () << "kpViewScrollableContainer::mouseMoveEvent"
1392                << e->pos ()
1393                << endl;
1394 #endif
1395
1396     Q3ScrollView::mouseMoveEvent (e);
1397 }
1398
1399
1400 // protected virtual [base QScrollView]
1401 void kpViewScrollableContainer::contentsWheelEvent (QWheelEvent *e)
1402 {
1403     e->ignore ();
1404
1405     if (m_view)
1406         m_view->wheelEvent (e);
1407
1408     if (!e->isAccepted ())
1409         Q3ScrollView::contentsWheelEvent (e);
1410 }
1411
1412
1413 QRect kpViewScrollableContainer::noDragScrollRect () const
1414 {
1415     return QRect (DragScrollLeftTopMargin, DragScrollLeftTopMargin,
1416                   width () - DragScrollLeftTopMargin - DragScrollRightBottomMargin,
1417                   height () - DragScrollLeftTopMargin - DragScrollRightBottomMargin);
1418 }
1419
1420 // protected virtual [base QScrollView]
1421 bool kpViewScrollableContainer::eventFilter (QObject *watchedObject, QEvent *event)
1422 {
1423     return Q3ScrollView::eventFilter (watchedObject, event);
1424 }
1425
1426 // protected virtual [base QScrollView]
1427 void kpViewScrollableContainer::viewportPaintEvent (QPaintEvent *e)
1428 {
1429 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1430     kDebug () << "kpViewScrollableContainer::viewportPaintEvent("
1431                << e->rect ()
1432                << ")" << endl;
1433 #endif
1434
1435     Q3ScrollView::viewportPaintEvent (e);
1436
1437 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1438     kDebug () << "done";
1439 #endif
1440 }
1441
1442 // protected virtual [base QFrame]
1443 void kpViewScrollableContainer::paintEvent (QPaintEvent *e)
1444 {
1445 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1446     kDebug () << "kpViewScrollableContainer::paintEvent("
1447                << e->rect ()
1448                << ")" << endl;
1449 #endif
1450
1451     Q3ScrollView::paintEvent (e);
1452
1453 #if DEBUG_KP_VIEW_SCROLLABLE_CONTAINER
1454     kDebug () << "done";
1455 #endif
1456 }
1457
1458 // protected virtual [base QScrollView]
1459 void kpViewScrollableContainer::resizeEvent (QResizeEvent *e)
1460 {
1461     Q3ScrollView::resizeEvent (e);
1462
1463     emit resized ();
1464 }
1465
1466
1467 #include <kpViewScrollableContainer.moc>
1468
1469