sd/source/ui/slidesorter/controller/SlsScrollBarManager.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: SlsScrollBarManager.cxx,v $
  10  * $Revision: 1.13 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "precompiled_sd.hxx"
  32
  33 #include "controller/SlsScrollBarManager.hxx"
  34
  35 #include "SlideSorter.hxx"
  36 #include "controller/SlideSorterController.hxx"
  37 #include "model/SlideSorterModel.hxx"
  38 #include "model/SlsPageDescriptor.hxx"
  39 #include "view/SlideSorterView.hxx"
  40 #include "view/SlsLayouter.hxx"
  41 #include "view/SlsViewOverlay.hxx"
  42 #include "Window.hxx"
  43 #include "sdpage.hxx"
  44
  45 #include <boost/limits.hpp>
  46
  47 #include <vcl/scrbar.hxx>
  48
  49 namespace sd { namespace slidesorter { namespace controller {
  50
  51 ScrollBarManager::ScrollBarManager (SlideSorter& rSlideSorter)
  52     : mrSlideSorter(rSlideSorter),
  53       mpHorizontalScrollBar(mrSlideSorter.GetHorizontalScrollBar()),
  54       mpVerticalScrollBar(mrSlideSorter.GetVerticalScrollBar()),
  55       mnHorizontalPosition (0),
  56       mnVerticalPosition (0),
  57       maScrollBorder (10,10),
  58       mnHorizontalScrollFactor (0.1),
  59       mnVerticalScrollFactor (0.1),
  60       mpScrollBarFiller(mrSlideSorter.GetScrollBarFiller()),
  61       mpContentWindow(mrSlideSorter.GetContentWindow())
  62 {
  63     // Hide the scroll bars by default to prevent display errors while
  64     // switching between view shells:  In the short time between initiating
  65     // such a switch and the final rearrangement of UI controls the scroll
  66     // bars and the filler where displayed in the upper left corner of the
  67     // ViewTabBar.
  68     mpHorizontalScrollBar->Hide();
  69     mpVerticalScrollBar->Hide();
  70     mpScrollBarFiller->Hide();
  71
  72     maAutoScrollTimer.SetTimeout(50);
  73     maAutoScrollTimer.SetTimeoutHdl (
  74         LINK(this, ScrollBarManager, AutoScrollTimeoutHandler));
  75 }
  76
  77
  78
  79
  80 ScrollBarManager::~ScrollBarManager (void)
  81 {
  82 }
  83
  84
  85
  86
  87 void ScrollBarManager::LateInitialization (void)
  88 {
  89 }
  90
  91
  92
  93
  94 void ScrollBarManager::Connect (void)
  95 {
  96     if (mpVerticalScrollBar != NULL)
  97         mpVerticalScrollBar->SetScrollHdl (
  98             LINK(
  99                 this,
 100                 ScrollBarManager,
 101                 VerticalScrollBarHandler));
 102     if (mpHorizontalScrollBar != NULL)
 103         mpHorizontalScrollBar->SetScrollHdl (
 104             LINK(
 105                 this,
 106                 ScrollBarManager,
 107                 HorizontalScrollBarHandler));
 108 }
 109
 110
 111
 112
 113 void ScrollBarManager::Disconnect (void)
 114 {
 115     if (mpVerticalScrollBar != NULL)
 116         mpVerticalScrollBar->SetScrollHdl (Link());
 117     if (mpHorizontalScrollBar != NULL)
 118         mpHorizontalScrollBar->SetScrollHdl (Link());
 119 }
 120
 121
 122
 123
 124 /** Placing the scroll bars is an iterative process.  The visibility of one
 125     scroll bar affects the remaining size and thus may lead to the other
 126     scroll bar becoming visible.
 127
 128     First we determine the visibility of the horizontal scroll bar.  After
 129     that we do the same for the vertical scroll bar.  To have an initial
 130     value for the required size we call the layouter before that.  When one
 131     of the two scroll bars is made visible then the size of the browser
 132     window changes and a second call to the layouter becomes necessary.
 133     That call is made anyway after this method returns.
 134 */
 135 Rectangle ScrollBarManager::PlaceScrollBars (const Rectangle& rAvailableArea)
 136 {
 137     Rectangle aRemainingSpace (DetermineScrollBarVisibilities(rAvailableArea));
 138     PlaceHorizontalScrollBar (rAvailableArea);
 139     PlaceVerticalScrollBar (rAvailableArea);
 140     PlaceFiller (rAvailableArea);
 141
 142     return aRemainingSpace;
 143 }
 144
 145
 146
 147
 148 void ScrollBarManager::PlaceHorizontalScrollBar (const Rectangle& aAvailableArea)
 149 {
 150     if (mpHorizontalScrollBar != NULL
 151         && mpHorizontalScrollBar->IsVisible())
 152     {
 153         // Save the current relative position.
 154         mnHorizontalPosition = double(mpHorizontalScrollBar->GetThumbPos())
 155             / double(mpHorizontalScrollBar->GetRange().Len());
 156
 157         // Place the scroll bar.
 158         Size aScrollBarSize (mpHorizontalScrollBar->GetSizePixel());
 159         mpHorizontalScrollBar->SetPosSizePixel (
 160             Point(aAvailableArea.Left(),
 161                 aAvailableArea.Bottom()-aScrollBarSize.Height()+1),
 162             Size (aAvailableArea.GetWidth() - GetVerticalScrollBarWidth(),
 163                 aScrollBarSize.Height()));
 164
 165         // Restore the relative position.
 166         mpHorizontalScrollBar->SetThumbPos(
 167             (long)(0.5 + mnHorizontalPosition * mpHorizontalScrollBar->GetRange().Len()));
 168     }
 169 }
 170
 171
 172
 173
 174 void ScrollBarManager::PlaceVerticalScrollBar (const Rectangle& aArea)
 175 {
 176     if (mpVerticalScrollBar != NULL
 177         && mpVerticalScrollBar->IsVisible())
 178     {
 179         view::Layouter::DoublePoint aLayouterPosition
 180             = mrSlideSorter.GetView().GetLayouter().ConvertModelToLayouterCoordinates (
 181                 Point (0, mpVerticalScrollBar->GetThumbPos()));
 182
 183         // Place the scroll bar.
 184         Size aScrollBarSize (mpVerticalScrollBar->GetSizePixel());
 185         Point aPosition (aArea.Right()-aScrollBarSize.Width()+1, aArea.Top());
 186         Size aSize (aScrollBarSize.Width(), aArea.GetHeight() - GetHorizontalScrollBarHeight());
 187         mpVerticalScrollBar->SetPosSizePixel(aPosition, aSize);
 188
 189         // Restore the position.
 190         mpVerticalScrollBar->SetThumbPos(
 191             mrSlideSorter.GetView().GetLayouter().ConvertLayouterToModelCoordinates(
 192                 aLayouterPosition).Y());
 193         mnVerticalPosition = double(mpVerticalScrollBar->GetThumbPos())
 194             / double(mpVerticalScrollBar->GetRange().Len());
 195     }
 196 }
 197
 198
 199
 200
 201 void ScrollBarManager::PlaceFiller (const Rectangle& aArea)
 202 {
 203     // Place the filler when both scroll bars are visible.
 204     if (mpHorizontalScrollBar != NULL
 205         && mpVerticalScrollBar != NULL
 206         && mpHorizontalScrollBar->IsVisible()
 207         && mpVerticalScrollBar->IsVisible())
 208     {
 209         mpScrollBarFiller->SetPosSizePixel(
 210             Point(
 211                 aArea.Right()-mpVerticalScrollBar->GetSizePixel().Width()+1,
 212                 aArea.Bottom()-mpHorizontalScrollBar->GetSizePixel().Height()+1),
 213             Size (
 214                 mpVerticalScrollBar->GetSizePixel().Width(),
 215                 mpHorizontalScrollBar->GetSizePixel().Height()));
 216         mpScrollBarFiller->Show();
 217     }
 218     else
 219         mpScrollBarFiller->Hide();
 220 }
 221
 222
 223
 224
 225 void ScrollBarManager::AdaptWindowSize (const Rectangle& rArea)
 226 {
 227     Size aPixelContentSize (mpContentWindow->LogicToPixel(
 228         mrSlideSorter.GetView().GetLayouter().GetPageBox (
 229             mrSlideSorter.GetModel().GetPageCount()).GetSize()));
 230     int nHeightDifference = aPixelContentSize.Height() - rArea.GetHeight();
 231     ::Window* pParentWindow = mpContentWindow->GetParent();
 232     Size aNewWindowSize (pParentWindow->GetSizePixel());
 233     if (nHeightDifference != 0)
 234     {
 235         aNewWindowSize.Height() += nHeightDifference;
 236         pParentWindow->SetPosSizePixel(
 237             pParentWindow->GetPosPixel(),
 238             aNewWindowSize);
 239     }
 240 }
 241
 242
 243
 244
 245 void ScrollBarManager::UpdateScrollBars (bool bResetThumbPosition, bool bUseScrolling)
 246 {
 247     Rectangle aModelArea (mrSlideSorter.GetView().GetModelArea());
 248     ::sd::Window* pWindow = mrSlideSorter.GetView().GetWindow();
 249     Size aWindowModelSize (pWindow->PixelToLogic(pWindow->GetSizePixel()));
 250
 251     // The horizontal scroll bar is only shown when the window is
 252     // horizontally smaller than the view.
 253     if (mpHorizontalScrollBar != NULL && mpHorizontalScrollBar->IsVisible())
 254     {
 255         mpHorizontalScrollBar->Show();
 256         mpHorizontalScrollBar->SetRange (
 257             Range(aModelArea.Left(), aModelArea.Right()));
 258         if (bResetThumbPosition)
 259         {
 260             mpHorizontalScrollBar->SetThumbPos (0);
 261             mnHorizontalPosition = 0;
 262         }
 263         else
 264             mnHorizontalPosition =
 265                 double(mpHorizontalScrollBar->GetThumbPos())
 266                 / double(mpHorizontalScrollBar->GetRange().Len());
 267
 268         mpHorizontalScrollBar->SetVisibleSize (aWindowModelSize.Width());
 269
 270         const long nWidth (mpContentWindow->PixelToLogic(
 271             mpContentWindow->GetSizePixel()).Width());
 272         // Make the line size about 10% of the visible width.
 273         mpHorizontalScrollBar->SetLineSize (nWidth / 10);
 274         // Make the page size about 90% of the visible width.
 275         mpHorizontalScrollBar->SetPageSize ((nWidth * 9) / 10);
 276     }
 277     else
 278     {
 279         mnHorizontalPosition = 0;
 280     }
 281
 282     // The vertical scroll bar is always shown.
 283     if (mpVerticalScrollBar != NULL && mpVerticalScrollBar->IsVisible())
 284     {
 285         mpVerticalScrollBar->SetRange (
 286             Range(aModelArea.Top(), aModelArea.Bottom()));
 287         if (bResetThumbPosition)
 288         {
 289             mpVerticalScrollBar->SetThumbPos (0);
 290             mnVerticalPosition = 0;
 291         }
 292         else
 293             mnVerticalPosition =
 294                 double(mpVerticalScrollBar->GetThumbPos())
 295                 / double(mpVerticalScrollBar->GetRange().Len());
 296
 297         mpVerticalScrollBar->SetVisibleSize (aWindowModelSize.Height());
 298
 299         const long nHeight (mpContentWindow->PixelToLogic(
 300             mpContentWindow->GetSizePixel()).Height());
 301         // Make the line size about 10% of the visible height.
 302         mpVerticalScrollBar->SetLineSize (nHeight / 10);
 303         // Make the page size about 90% of the visible height.
 304         mpVerticalScrollBar->SetPageSize ((nHeight * 9) / 10);
 305     }
 306     else
 307     {
 308         mnVerticalPosition = 0;
 309     }
 310
 311
 312     double nEps (::std::numeric_limits<double>::epsilon());
 313     if (fabs(mnHorizontalPosition-pWindow->GetVisibleX()) > nEps
 314         || fabs(mnVerticalPosition-pWindow->GetVisibleY()) > nEps)
 315     {
 316         mrSlideSorter.GetView().InvalidatePageObjectVisibilities();
 317         if (bUseScrolling)
 318             pWindow->SetVisibleXY(mnHorizontalPosition, mnVerticalPosition);
 319         else
 320             SetWindowOrigin(mnHorizontalPosition, mnVerticalPosition);
 321     }
 322 }
 323
 324
 325
 326
 327 IMPL_LINK(ScrollBarManager, VerticalScrollBarHandler, ScrollBar*, pScrollBar)
 328 {
 329     if (pScrollBar!=NULL
 330         && pScrollBar==mpVerticalScrollBar.get()
 331         && pScrollBar->IsVisible()
 332         && mrSlideSorter.GetView().GetWindow()!=NULL)
 333     {
 334         double nRelativePosition = double(pScrollBar->GetThumbPos())
 335             / double(pScrollBar->GetRange().Len());
 336         mrSlideSorter.GetView().InvalidatePageObjectVisibilities();
 337         mrSlideSorter.GetView().GetWindow()->SetVisibleXY (
 338             -1,
 339             nRelativePosition);
 340     }
 341     return TRUE;
 342 }
 343
 344
 345
 346
 347 IMPL_LINK(ScrollBarManager, HorizontalScrollBarHandler, ScrollBar*, pScrollBar)
 348 {
 349     if (pScrollBar!=NULL
 350         && pScrollBar==mpHorizontalScrollBar.get()
 351         && pScrollBar->IsVisible()
 352         && mrSlideSorter.GetView().GetWindow()!=NULL)
 353     {
 354         double nRelativePosition = double(pScrollBar->GetThumbPos())
 355             / double(pScrollBar->GetRange().Len());
 356         mrSlideSorter.GetView().InvalidatePageObjectVisibilities();
 357         mrSlideSorter.GetView().GetWindow()->SetVisibleXY (nRelativePosition, -1);
 358     }
 359     return TRUE;
 360 }
 361
 362
 363
 364
 365 void ScrollBarManager::SetWindowOrigin (
 366     double nHorizontalPosition,
 367     double nVerticalPosition)
 368 {
 369     mnHorizontalPosition = nHorizontalPosition;
 370     mnVerticalPosition = nVerticalPosition;
 371
 372     ::sd::Window* pWindow = mrSlideSorter.GetView().GetWindow();
 373     Size aViewSize (pWindow->GetViewSize());
 374     Point aOrigin (
 375         (long int) (mnHorizontalPosition * aViewSize.Width()),
 376         (long int) (mnVerticalPosition * aViewSize.Height()));
 377
 378     pWindow->SetWinViewPos (aOrigin);
 379     pWindow->UpdateMapMode ();
 380     pWindow->Invalidate ();
 381 }
 382
 383
 384
 385
 386 /** Determining the visibility of the scroll bars is quite complicated.  The
 387     visibility of one influences that of the other because showing a scroll
 388     bar makes the available space smaller and may lead to the need of
 389     displaying the other.
 390     To solve this we test all four combinations of showing or hiding each
 391     scroll bar and use the best one.  The best one is that combination that
 392     a) shows the least number of scroll bars with preference of showing the
 393     vertical over showing the horizontal and
 394     b) when not showing a scroll bar the area used by the page objects fits
 395     into the available area in the scroll bars orientation.
 396 */
 397 Rectangle ScrollBarManager::DetermineScrollBarVisibilities (const Rectangle& rAvailableArea)
 398 {
 399     // Test which combination of scroll bars is the best.
 400     bool bShowHorizontal = false;
 401     bool bShowVertical = false;
 402     do
 403     {
 404         if (mrSlideSorter.GetModel().GetPageCount() == 0)
 405             // No pages => no scroll bars.
 406             break;
 407
 408         if (TestScrollBarVisibilities(bShowHorizontal=false, bShowVertical=false, rAvailableArea))
 409             break;
 410         if (TestScrollBarVisibilities(bShowHorizontal=true, bShowVertical=false, rAvailableArea))
 411             break;
 412         if (TestScrollBarVisibilities(bShowHorizontal=false, bShowVertical=true, rAvailableArea))
 413             break;
 414         if (TestScrollBarVisibilities(bShowHorizontal=true, bShowVertical=true, rAvailableArea))
 415             break;
 416     }
 417     while (false);
 418
 419     // Make the visibility of the scroll bars permanent.
 420     mpVerticalScrollBar->Show(bShowVertical);
 421     mpHorizontalScrollBar->Show(bShowHorizontal);
 422
 423     // Adapt the remaining space accordingly.
 424     Rectangle aRemainingSpace (rAvailableArea);
 425     if (bShowVertical)
 426         aRemainingSpace.Right() -= mpVerticalScrollBar->GetSizePixel().Width();
 427     if (bShowHorizontal)
 428         aRemainingSpace.Bottom() -= mpHorizontalScrollBar->GetSizePixel().Height();
 429
 430     return aRemainingSpace;
 431 }
 432
 433
 434
 435
 436 bool ScrollBarManager::TestScrollBarVisibilities (
 437     bool bHorizontalScrollBarVisible,
 438     bool bVerticalScrollBarVisible,
 439     const Rectangle& rAvailableArea)
 440 {
 441     bool bAreVisibilitiesOK = true;
 442
 443     // Adapt the available size by subtracting the sizes of the scroll bars
 444     // visible in this combination.
 445     Size aBrowserSize (rAvailableArea.GetSize());
 446     if (bHorizontalScrollBarVisible)
 447         aBrowserSize.Height() -= mpHorizontalScrollBar->GetSizePixel().Height();
 448     if (bVerticalScrollBarVisible)
 449         aBrowserSize.Width() -= mpVerticalScrollBar->GetSizePixel().Width();
 450
 451     // Tell the view to rearrange its page objects and check whether the
 452     // page objects can be shown without clipping.
 453     bool bRearrangeSuccess (false);
 454     if (mrSlideSorter.GetView().GetOrientation() == view::SlideSorterView::HORIZONTAL)
 455     {
 456         bRearrangeSuccess = mrSlideSorter.GetView().GetLayouter().RearrangeHorizontal (
 457             aBrowserSize,
 458             mrSlideSorter.GetModel().GetPageDescriptor(0)->GetPage()->GetSize(),
 459             mpContentWindow.get(),
 460             mrSlideSorter.GetModel().GetPageCount());
 461     }
 462     else
 463     {
 464         bRearrangeSuccess =  mrSlideSorter.GetView().GetLayouter().RearrangeVertical (
 465             aBrowserSize,
 466             mrSlideSorter.GetModel().GetPageDescriptor(0)->GetPage()->GetSize(),
 467             mpContentWindow.get());
 468     }
 469
 470     if (bRearrangeSuccess)
 471     {
 472         Size aPageSize = mrSlideSorter.GetView().GetLayouter().GetPageBox (
 473             mrSlideSorter.GetModel().GetPageCount()).GetSize();
 474         Size aWindowModelSize = mpContentWindow->PixelToLogic(aBrowserSize);
 475
 476         bool bHorizontallyClipped = (aPageSize.Width() > aWindowModelSize.Width());
 477         bool bVerticallyClipped = (aPageSize.Height() > aWindowModelSize.Height());
 478         bAreVisibilitiesOK = (bHorizontallyClipped == bHorizontalScrollBarVisible)
 479             && (bVerticallyClipped == bVerticalScrollBarVisible);
 480     }
 481     else
 482         bAreVisibilitiesOK = false;
 483
 484     return bAreVisibilitiesOK;
 485 }
 486
 487
 488
 489
 490 void ScrollBarManager::SetTop (const sal_Int32 nNewTop)
 491 {
 492     if (mpVerticalScrollBar != NULL
 493         && mpVerticalScrollBar->GetThumbPos() != nNewTop)
 494     {
 495         // Flush pending repaints before scrolling to avoid temporary artifacts.
 496         mrSlideSorter.GetView().GetWindow()->Update();
 497
 498         mpVerticalScrollBar->SetThumbPos(nNewTop);
 499         mnVerticalPosition = double(nNewTop) / double(mpVerticalScrollBar->GetRange().Len());
 500         mrSlideSorter.GetView().GetWindow()->SetVisibleXY (
 501             mnHorizontalPosition, mnVerticalPosition);
 502     }
 503 }
 504
 505
 506
 507
 508 void ScrollBarManager::SetLeft (const sal_Int32 nNewLeft)
 509 {
 510     if (mpHorizontalScrollBar != NULL
 511         && mpHorizontalScrollBar->GetThumbPos() != nNewLeft)
 512     {
 513         // Flush pending repaints before scrolling to avoid temporary artifacts.
 514         mrSlideSorter.GetView().GetWindow()->Update();
 515
 516         mpHorizontalScrollBar->SetThumbPos(nNewLeft);
 517         mnHorizontalPosition = double(nNewLeft) / double(mpHorizontalScrollBar->GetRange().Len());
 518         mrSlideSorter.GetView().GetWindow()->SetVisibleXY (
 519             mnHorizontalPosition, mnVerticalPosition);
 520     }
 521 }
 522
 523
 524
 525
 526 int ScrollBarManager::GetVerticalScrollBarWidth (void) const
 527 {
 528     if (mpVerticalScrollBar != NULL && mpVerticalScrollBar->IsVisible())
 529         return mpVerticalScrollBar->GetSizePixel().Width();
 530     else
 531         return 0;
 532 }
 533
 534
 535
 536
 537 int ScrollBarManager::GetHorizontalScrollBarHeight (void) const
 538 {
 539     if (mpHorizontalScrollBar != NULL && mpHorizontalScrollBar->IsVisible())
 540         return mpHorizontalScrollBar->GetSizePixel().Height();
 541     else
 542         return 0;
 543 }
 544
 545
 546
 547
 548 void ScrollBarManager::CalcAutoScrollOffset (const Point& rMouseWindowPosition)
 549 {
 550     ::sd::Window* pWindow = mrSlideSorter.GetView().GetWindow();
 551
 552     int nDx = 0;
 553     int nDy = 0;
 554
 555     Size aWindowSize = pWindow->GetOutputSizePixel();
 556     Rectangle aWindowArea (pWindow->GetPosPixel(), aWindowSize);
 557     Rectangle aViewPixelArea (
 558         pWindow->LogicToPixel(mrSlideSorter.GetView().GetModelArea()));
 559
 560     if (aWindowSize.Width() > maScrollBorder.Width() * 3
 561         && mpHorizontalScrollBar != NULL
 562         && mpHorizontalScrollBar->IsVisible())
 563     {
 564         if (rMouseWindowPosition.X() < maScrollBorder.Width()
 565             && aWindowArea.Left() > aViewPixelArea.Left())
 566         {
 567             nDx = -1 + (int)(mnHorizontalScrollFactor
 568                 * (rMouseWindowPosition.X() - maScrollBorder.Width()));
 569         }
 570
 571         if (rMouseWindowPosition.X() >= (aWindowSize.Width() - maScrollBorder.Width())
 572             && aWindowArea.Right() < aViewPixelArea.Right())
 573         {
 574             nDx = 1 + (int)(mnHorizontalScrollFactor
 575                 * (rMouseWindowPosition.X() - aWindowSize.Width()
 576                     + maScrollBorder.Width()));
 577         }
 578     }
 579
 580     if (aWindowSize.Height() > maScrollBorder.Height() * 3
 581         && aWindowSize.Height() < aViewPixelArea.GetHeight())
 582     {
 583         if (rMouseWindowPosition.Y() < maScrollBorder.Height()
 584             && aWindowArea.Top() > aViewPixelArea.Top())
 585         {
 586             nDy = -1 + (int)(mnVerticalScrollFactor
 587                 * (rMouseWindowPosition.Y() - maScrollBorder.Height()));
 588         }
 589
 590         if (rMouseWindowPosition.Y() >= (aWindowSize.Height() - maScrollBorder.Height())
 591             && aWindowArea.Bottom() < aViewPixelArea.Bottom())
 592         {
 593             nDy = 1 + (int)(mnVerticalScrollFactor
 594                 * (rMouseWindowPosition.Y() - aWindowSize.Height()
 595                     + maScrollBorder.Height()));
 596         }
 597     }
 598
 599     maAutoScrollOffset = Size(nDx,nDy);
 600 }
 601
 602
 603
 604
 605 bool ScrollBarManager::AutoScroll (const Point& rMouseWindowPosition)
 606 {
 607     CalcAutoScrollOffset (rMouseWindowPosition);
 608     bool bResult = RepeatAutoScroll();
 609     if (bResult)
 610     {
 611         maAutoScrollTimer.Start();
 612     }
 613     return bResult;
 614 }
 615
 616
 617
 618
 619 void ScrollBarManager::StopAutoScroll (void)
 620 {
 621     maAutoScrollTimer.Stop();
 622 }
 623
 624
 625
 626
 627 bool ScrollBarManager::RepeatAutoScroll (void)
 628 {
 629     if (maAutoScrollOffset != Size(0,0))
 630     {
 631         if (mrSlideSorter.GetViewShell() != NULL)
 632         {
 633             mrSlideSorter.GetViewShell()->ScrollLines(
 634                 maAutoScrollOffset.Width(),
 635                     maAutoScrollOffset.Height());
 636             return true;
 637         }
 638     }
 639
 640     return false;
 641 }
 642
 643
 644
 645
 646 IMPL_LINK(ScrollBarManager, AutoScrollTimeoutHandler, Timer *, EMPTYARG)
 647 {
 648     RepeatAutoScroll();
 649
 650     return 0;
 651 }
 652
 653
 654 } } } // end of namespace ::sd::slidesorter::controller