sd/source/ui/slidesorter/view/SlideSorterView.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <view/SlideSorterView.hxx>
  21
  22 #include <SlideSorter.hxx>
  23 #include <ViewShell.hxx>
  24 #include "SlsViewCacheContext.hxx"
  25 #include "SlsLayeredDevice.hxx"
  26 #include <view/SlsLayouter.hxx>
  27 #include <view/SlsPageObjectLayouter.hxx>
  28 #include <view/SlsPageObjectPainter.hxx>
  29 #include <view/SlsILayerPainter.hxx>
  30 #include <view/SlsToolTip.hxx>
  31 #include <controller/SlideSorterController.hxx>
  32 #include <controller/SlsClipboard.hxx>
  33 #include <model/SlideSorterModel.hxx>
  34 #include <model/SlsPageEnumerationProvider.hxx>
  35 #include <model/SlsPageDescriptor.hxx>
  36 #include <cache/SlsPageCache.hxx>
  37 #include <cache/SlsPageCacheManager.hxx>
  38 #include <titledockwin.hxx>
  39
  40 #include <sdpage.hxx>
  41 #include <Window.hxx>
  42
  43 #include <comphelper/lok.hxx>
  44 #include <osl/diagnose.h>
  45 #include <vcl/svapp.hxx>
  46 #include <vcl/settings.hxx>
  47 #include <vcl/graphicfilter.hxx>
  48
  49 #include <algorithm>
  50
  51 //#define DEBUG_TIMING
  52 #ifdef DEBUG_TIMING
  53 #include <memory>
  54 #include <vector>
  55 #endif
  56
  57 using namespace ::sd::slidesorter::model;
  58
  59 namespace sd::slidesorter::view {
  60
  61 namespace {
  62     /** Wrapper around the SlideSorterView that supports the IPainter
  63         interface and that allows the LayeredDevice to hold the
  64         SlideSorterView (held as unique_ptr by the SlideSorter) as
  65         shared_ptr.
  66     */
  67     class Painter : public ILayerPainter
  68     {
  69     public:
  70         explicit Painter (SlideSorterView& rView) : mrView(rView) {}
  71
  72         virtual void Paint (OutputDevice& rDevice, const ::tools::Rectangle& rRepaintArea) override
  73         {
  74             mrView.Paint(rDevice,rRepaintArea);
  75         }
  76
  77         virtual void SetLayerInvalidator (const SharedILayerInvalidator&) override {}
  78
  79     private:
  80         SlideSorterView& mrView;
  81     };
  82 }
  83
  84 namespace {
  85
  86 class BackgroundPainter
  87     : public ILayerPainter
  88 {
  89 public:
  90     explicit BackgroundPainter (const Color& rBackgroundColor) : maBackgroundColor(rBackgroundColor) {}
  91     BackgroundPainter(const BackgroundPainter&) = delete;
  92     BackgroundPainter& operator=(const BackgroundPainter&) = delete;
  93
  94     virtual void Paint (OutputDevice& rDevice, const ::tools::Rectangle& rRepaintArea) override
  95     {
  96         rDevice.SetFillColor(maBackgroundColor);
  97         rDevice.SetLineColor();
  98         rDevice.DrawRect(rRepaintArea);
  99     }
 100
 101     virtual void SetLayerInvalidator (const SharedILayerInvalidator&) override {}
 102
 103     void SetColor (const Color& rColor) { maBackgroundColor = rColor; }
 104
 105 private:
 106     Color maBackgroundColor;
 107 };
 108
 109 }
 110
 111 SlideSorterView::SlideSorterView (SlideSorter& rSlideSorter)
 112     : ::sd::View (
 113           *rSlideSorter.GetModel().GetDocument(),
 114           rSlideSorter.GetContentWindow()->GetOutDev(),
 115           rSlideSorter.GetViewShell()),
 116       mrSlideSorter(rSlideSorter),
 117       mrModel(rSlideSorter.GetModel()),
 118       mbIsDisposed(false),
 119       mpLayouter (new Layouter(rSlideSorter.GetContentWindow(), rSlideSorter.GetTheme())),
 120       mbPageObjectVisibilitiesValid (false),
 121       mpLayeredDevice(std::make_shared<LayeredDevice>(rSlideSorter.GetContentWindow())),
 122       maVisiblePageRange(-1,-1),
 123       maPreviewSize(0,0),
 124       mbPreciousFlagUpdatePending(true),
 125       meOrientation(Layouter::GRID),
 126       mpBackgroundPainter(
 127           std::make_shared<BackgroundPainter>(mrSlideSorter.GetTheme()->GetColor(Theme::Color_Background))),
 128       mpToolTip(new ToolTip(mrSlideSorter)),
 129       mbIsRearrangePending(true)
 130 {
 131     // Hide the page that contains the page objects.
 132     SetPageVisible (false);
 133
 134     // Register the background painter on level 1 to avoid the creation of a
 135     // background buffer.
 136     mpLayeredDevice->RegisterPainter(mpBackgroundPainter, 1);
 137
 138     // Wrap a shared_ptr-held-wrapper around this view and register it as
 139     // painter at the layered device.  There is no explicit destruction: in
 140     // the SlideSorterView destructor the layered device is destroyed and
 141     // with it the only reference to the wrapper which therefore is also
 142     // destroyed.
 143     SharedILayerPainter pPainter = std::make_shared<Painter>(*this);
 144
 145     // The painter is placed on level 1 to avoid buffering.  This should be
 146     // a little faster during animations because the previews are painted
 147     // directly into the window, not via the buffer.
 148     mpLayeredDevice->RegisterPainter(pPainter, 1);
 149 }
 150
 151 SlideSorterView::~SlideSorterView()
 152 {
 153     if ( ! mbIsDisposed)
 154     {
 155         OSL_ASSERT(mbIsDisposed);
 156         Dispose();
 157     }
 158 }
 159
 160 void SlideSorterView::Init()
 161 {
 162     HandleModelChange();
 163 }
 164
 165 void SlideSorterView::Dispose()
 166 {
 167     mpLayeredDevice->Dispose();
 168     mpPreviewCache.reset();
 169
 170     SetPageUnderMouse(SharedPageDescriptor());
 171
 172     // Hide the page to avoid problems in the view when deleting
 173     // visualized objects
 174     HideSdrPage();
 175
 176     // Deletion of the objects and the page will be done in SdrModel
 177     // destructor (as long as objects and pages are added)
 178
 179     OSL_ASSERT(mpLayeredDevice.use_count() == 1);
 180     mpLayeredDevice.reset();
 181
 182     mbIsDisposed = true;
 183 }
 184
 185 sal_Int32 SlideSorterView::GetPageIndexAtPoint (const Point& rWindowPosition) const
 186 {
 187     sal_Int32 nIndex (-1);
 188
 189     sd::Window *pWindow (mrSlideSorter.GetContentWindow().get());
 190     if (pWindow)
 191     {
 192         nIndex = mpLayouter->GetIndexAtPoint(pWindow->PixelToLogic(rWindowPosition), false, false);
 193
 194         // Clip the page index against the page count.
 195         if (nIndex >= mrModel.GetPageCount())
 196             nIndex = -1;
 197     }
 198
 199     return nIndex;
 200 }
 201
 202 Layouter& SlideSorterView::GetLayouter() { return *mpLayouter; }
 203
 204 void SlideSorterView::ModelHasChanged()
 205 {
 206     // Ignore this call.  Rely on hints sent by the model to get informed of
 207     // model changes.
 208 }
 209
 210 void SlideSorterView::PreModelChange()
 211 {
 212     // Reset the slide under the mouse.  It will be re-set in PostModelChange().
 213     SetPageUnderMouse(SharedPageDescriptor());
 214 }
 215
 216 void SlideSorterView::PostModelChange()
 217 {
 218     // In PreModelChange() the page objects have been released.  Here we
 219     // create new ones.
 220     ::osl::MutexGuard aGuard (mrModel.GetMutex());
 221
 222     model::PageEnumerationProvider::CreateAllPagesEnumeration(mrModel);
 223
 224     // The new page objects have to be scaled and positioned.
 225     RequestRearrange();
 226     RequestRepaint();
 227 }
 228
 229 /** At the moment for every model change all page objects are destroyed and
 230     re-created again.  This can be optimized by accepting hints that
 231     describe the type of change so that existing page objects can be
 232     reused.
 233 */
 234 void SlideSorterView::HandleModelChange()
 235 {
 236     PreModelChange ();
 237     PostModelChange();
 238 }
 239
 240 void SlideSorterView::HandleDrawModeChange()
 241 {
 242     // Replace the preview cache with a new and empty one.  The
 243     // PreviewRenderer that is used by the cache is replaced by this as
 244     // well.
 245     mpPreviewCache.reset();
 246     GetPreviewCache()->InvalidateCache();
 247
 248     RequestRepaint();
 249 }
 250
 251 void SlideSorterView::HandleDataChangeEvent()
 252 {
 253     GetPageObjectPainter()->SetTheme(mrSlideSorter.GetTheme());
 254
 255     // Update the color used by the background painter.
 256     std::shared_ptr<BackgroundPainter> pPainter (
 257         std::dynamic_pointer_cast<BackgroundPainter>(mpBackgroundPainter));
 258     if (pPainter)
 259         pPainter->SetColor(mrSlideSorter.GetTheme()->GetColor(Theme::Color_Background));
 260
 261     RequestRepaint();
 262 }
 263
 264 void SlideSorterView::Resize()
 265 {
 266     UpdateOrientation();
 267
 268     mpLayeredDevice->Resize();
 269     RequestRearrange();
 270 }
 271
 272 void SlideSorterView::RequestRearrange()
 273 {
 274     mbIsRearrangePending = true;
 275     Rearrange();
 276 }
 277
 278 void SlideSorterView::Rearrange()
 279 {
 280     if ( ! mbIsRearrangePending)
 281         return;
 282     if (mrModel.GetPageCount() <= 0)
 283         return;
 284
 285     sd::Window *pWindow (mrSlideSorter.GetContentWindow().get());
 286     if ( ! pWindow)
 287         return;
 288     const Size aWindowSize (pWindow->GetSizePixel());
 289     if (aWindowSize.IsEmpty())
 290         return;
 291
 292     const bool bRearrangeSuccess (
 293         mpLayouter->Rearrange (
 294             meOrientation,
 295             aWindowSize,
 296             mrModel.GetPageDescriptor(0)->GetPage()->GetSize(),
 297             mrModel.GetPageCount()));
 298     if (bRearrangeSuccess)
 299     {
 300         mbIsRearrangePending = false;
 301         Layout();
 302         UpdatePageUnderMouse();
 303         //        RequestRepaint();
 304     }
 305 }
 306
 307 void SlideSorterView::UpdateOrientation()
 308 {
 309     // The layout of slides depends on whether the slide sorter is
 310     // displayed in the center or the side pane.
 311     if (mrSlideSorter.GetViewShell()->IsMainViewShell())
 312         SetOrientation(Layouter::GRID);
 313     else
 314     {
 315         // Get access to the docking window.
 316         vcl::Window* pWindow = mrSlideSorter.GetContentWindow();
 317         TitledDockingWindow* pDockingWindow = nullptr;
 318         while (pWindow!=nullptr && pDockingWindow==nullptr)
 319         {
 320             pDockingWindow = dynamic_cast<TitledDockingWindow*>(pWindow);
 321             pWindow = pWindow->GetParent();
 322         }
 323
 324         if (pDockingWindow != nullptr)
 325         {
 326             const ::tools::Long nScrollBarSize (
 327                 Application::GetSettings().GetStyleSettings().GetScrollBarSize());
 328             switch (pDockingWindow->GetOrientation())
 329             {
 330                 case TitledDockingWindow::HorizontalOrientation:
 331                     if (SetOrientation(Layouter::HORIZONTAL))
 332                     {
 333                         const Range aRange (mpLayouter->GetValidVerticalSizeRange());
 334                         pDockingWindow->SetValidSizeRange(Range(
 335                             aRange.Min() + nScrollBarSize,
 336                             aRange.Max() + nScrollBarSize));
 337                     }
 338                     break;
 339
 340                 case TitledDockingWindow::VerticalOrientation:
 341                     if (SetOrientation(Layouter::VERTICAL))
 342                     {
 343                         const Range aRange (mpLayouter->GetValidHorizontalSizeRange());
 344                         pDockingWindow->SetValidSizeRange(Range(
 345                             aRange.Min() + nScrollBarSize,
 346                             aRange.Max() + nScrollBarSize));
 347                     }
 348                     break;
 349
 350                 case TitledDockingWindow::UnknownOrientation:
 351                     if (SetOrientation(Layouter::GRID))
 352                     {
 353                         const sal_Int32 nAdditionalSize (10);
 354                         pDockingWindow->SetMinOutputSizePixel(Size(
 355                             mpLayouter->GetValidHorizontalSizeRange().Min()
 356                                 + nScrollBarSize
 357                                 + nAdditionalSize,
 358                             mpLayouter->GetValidVerticalSizeRange().Min()
 359                                 + nScrollBarSize
 360                                 + nAdditionalSize));
 361                     }
 362                     return;
 363             }
 364         }
 365         else
 366         {
 367             // We are not placed in a docking window.  One possible reason
 368             // is that the slide sorter is temporarily into a cache and was
 369             // reparented to a non-docking window.
 370             SetOrientation(Layouter::GRID);
 371         }
 372     }
 373 }
 374
 375 void SlideSorterView::Layout ()
 376 {
 377     sd::Window *pWindow (mrSlideSorter.GetContentWindow().get());
 378     if (pWindow)
 379     {
 380         // Set the model area, i.e. the smallest rectangle that includes all
 381         // page objects.
 382         const ::tools::Rectangle aViewBox (mpLayouter->GetTotalBoundingBox());
 383         pWindow->SetViewOrigin (aViewBox.TopLeft());
 384         pWindow->SetViewSize (aViewBox.GetSize());
 385
 386         std::shared_ptr<PageObjectLayouter> pPageObjectLayouter(
 387             mpLayouter->GetPageObjectLayouter());
 388         if (pPageObjectLayouter)
 389         {
 390             const Size aNewPreviewSize (mpLayouter->GetPageObjectLayouter()->GetPreviewSize());
 391             if (maPreviewSize != aNewPreviewSize && GetPreviewCache())
 392             {
 393                 mpPreviewCache->ChangeSize(aNewPreviewSize, Bitmap::HasFastScale());
 394                 maPreviewSize = aNewPreviewSize;
 395             }
 396         }
 397
 398         // Iterate over all page objects and place them relative to the
 399         // containing page.
 400         model::PageEnumeration aPageEnumeration (
 401             model::PageEnumerationProvider::CreateAllPagesEnumeration(mrModel));
 402         while (aPageEnumeration.HasMoreElements())
 403         {
 404             model::SharedPageDescriptor pDescriptor (aPageEnumeration.GetNextElement());
 405             pDescriptor->SetBoundingBox(mpLayouter->GetPageObjectBox(pDescriptor->GetPageIndex(), false));
 406         }
 407     }
 408
 409     InvalidatePageObjectVisibilities ();
 410 }
 411
 412 void SlideSorterView::InvalidatePageObjectVisibilities()
 413 {
 414     mbPageObjectVisibilitiesValid = false;
 415 }
 416
 417 void SlideSorterView::DeterminePageObjectVisibilities()
 418 {
 419     sd::Window *pWindow (mrSlideSorter.GetContentWindow().get());
 420     if (!pWindow)
 421         return;
 422
 423     // Set this flag to true here so that an invalidate during the
 424     // visibility calculation can correctly invalidate it again.
 425     mbPageObjectVisibilitiesValid = true;
 426
 427     ::tools::Rectangle aViewArea (pWindow->PixelToLogic(::tools::Rectangle(Point(0,0),pWindow->GetSizePixel())));
 428     const Range aRange (mpLayouter->GetRangeOfVisiblePageObjects(aViewArea));
 429     const Range aUnion(
 430         ::std::min(maVisiblePageRange.Min(), aRange.Min()),
 431         ::std::max(maVisiblePageRange.Max(), aRange.Max()));
 432
 433     // For page objects that just dropped off the visible area we
 434     // decrease the priority of pending requests for preview bitmaps.
 435     if (maVisiblePageRange != aRange)
 436         mbPreciousFlagUpdatePending |= true;
 437
 438     model::SharedPageDescriptor pDescriptor;
 439     for (::tools::Long nIndex=aUnion.Min(); nIndex<=aUnion.Max(); nIndex++)
 440     {
 441         pDescriptor = mrModel.GetPageDescriptor(nIndex);
 442         if (pDescriptor)
 443             SetState(
 444                 pDescriptor,
 445                 PageDescriptor::ST_Visible,
 446                 aRange.Contains(nIndex));
 447     }
 448
 449     // Broadcast a change of the set of visible page objects.
 450     if (maVisiblePageRange != aRange)
 451     {
 452         maVisiblePageRange = aRange;
 453
 454         // Tell the listeners that the visibility of some objects has
 455         // changed.
 456         ::std::vector<Link<LinkParamNone*,void>>& aChangeListeners (maVisibilityChangeListeners);
 457         for (const auto& rLink : aChangeListeners)
 458         {
 459             rLink.Call(nullptr);
 460         }
 461     }
 462
 463     // Restore the mouse over state.
 464     UpdatePageUnderMouse();
 465 }
 466
 467 void SlideSorterView::UpdatePreciousFlags()
 468 {
 469     if (!mbPreciousFlagUpdatePending)
 470         return;
 471
 472     mbPreciousFlagUpdatePending = false;
 473
 474     model::SharedPageDescriptor pDescriptor;
 475     std::shared_ptr<cache::PageCache> pCache = GetPreviewCache();
 476     sal_Int32 nPageCount (mrModel.GetPageCount());
 477
 478     for (int nIndex=0; nIndex<=nPageCount; ++nIndex)
 479     {
 480         pDescriptor = mrModel.GetPageDescriptor(nIndex);
 481         if (pDescriptor)
 482         {
 483             pCache->SetPreciousFlag(
 484                 pDescriptor->GetPage(),
 485                 maVisiblePageRange.Contains(nIndex));
 486         }
 487         else
 488         {
 489             // At least one cache entry can not be updated.  Remember to
 490             // repeat the whole updating later and leave the loop now.
 491             mbPreciousFlagUpdatePending = true;
 492             break;
 493         }
 494     }
 495 }
 496
 497 bool SlideSorterView::SetOrientation (const Layouter::Orientation eOrientation)
 498 {
 499     if (meOrientation != eOrientation)
 500     {
 501         meOrientation = eOrientation;
 502         return true;
 503     }
 504     else
 505         return false;
 506 }
 507
 508 void SlideSorterView::RequestRepaint()
 509 {
 510     sd::Window *pWindow (mrSlideSorter.GetContentWindow().get());
 511     if (pWindow)
 512     {
 513         mpLayeredDevice->InvalidateAllLayers(
 514             ::tools::Rectangle(
 515                 pWindow->PixelToLogic(Point(0,0)),
 516                 pWindow->PixelToLogic(pWindow->GetSizePixel())));
 517         pWindow->Invalidate();
 518     }
 519 }
 520
 521 void SlideSorterView::RequestRepaint (const model::SharedPageDescriptor& rpDescriptor)
 522 {
 523     if (rpDescriptor)
 524         RequestRepaint(rpDescriptor->GetBoundingBox());
 525 }
 526
 527 void SlideSorterView::RequestRepaint (const ::tools::Rectangle& rRepaintBox)
 528 {
 529     sd::Window *pWindow (mrSlideSorter.GetContentWindow().get());
 530     if (pWindow)
 531     {
 532         mpLayeredDevice->InvalidateAllLayers(rRepaintBox);
 533         pWindow->Invalidate(rRepaintBox);
 534     }
 535 }
 536
 537 void SlideSorterView::RequestRepaint (const vcl::Region& rRepaintRegion)
 538 {
 539     sd::Window *pWindow (mrSlideSorter.GetContentWindow().get());
 540     if (pWindow)
 541     {
 542         mpLayeredDevice->InvalidateAllLayers(rRepaintRegion);
 543         pWindow->Invalidate(rRepaintRegion);
 544     }
 545 }
 546
 547 ::tools::Rectangle SlideSorterView::GetModelArea() const
 548 {
 549     return mpLayouter->GetTotalBoundingBox();
 550 }
 551
 552 #ifdef DEBUG_TIMING
 553 static ::canvas::tools::ElapsedTime gaTimer;
 554 static const size_t gFrameTimeCount (10);
 555 static size_t gFrameTimeIndex (0);
 556 static ::std::vector<double> gFrameTimes (gFrameTimeCount, 0);
 557 static double gFrameTimeSum (0);
 558 static const ::tools::Rectangle gFrameTimeBox (10,10,150,20);
 559 static double gnLastFrameStart = 0;
 560 #endif
 561
 562 void SlideSorterView::CompleteRedraw (
 563     OutputDevice* pDevice,
 564     const vcl::Region& rPaintArea,
 565     sdr::contact::ViewObjectContactRedirector* pRedirector)
 566 {
 567     (void)pRedirector;
 568
 569     if (comphelper::LibreOfficeKit::isActive())
 570         return;
 571
 572     if (pDevice == nullptr || pDevice!=mrSlideSorter.GetContentWindow()->GetOutDev())
 573         return;
 574
 575 #ifdef DEBUG_TIMING
 576     const double nStartTime (gaTimer.getElapsedTime());
 577     SAL_INFO("sd.timing", "SlideSorterView::CompleteRedraw start" << (mnLockRedrawSmph ? " locked" : ""));
 578 #endif
 579
 580     // The parent implementation of CompleteRedraw is called only when
 581     // painting is locked.  We do all the painting ourself.  When painting
 582     // is locked the parent implementation keeps track of the repaint
 583     // requests and later, when painting is unlocked, calls CompleteRedraw
 584     // for all missed repaints.
 585
 586     if (mnLockRedrawSmph == 0)
 587     {
 588         if (mpLayeredDevice->HandleMapModeChange())
 589             DeterminePageObjectVisibilities();
 590         mpLayeredDevice->Repaint(rPaintArea);
 591     }
 592     else
 593     {
 594         maRedrawRegion.Union(rPaintArea);
 595     }
 596
 597 #ifdef DEBUG_TIMING
 598     const double nEndTime (gaTimer.getElapsedTime());
 599     SAL_INFO("sd.timing", "SlideSorterView::CompleteRedraw end after " << (nEndTime-nStartTime)*1000 << " ms");
 600     gFrameTimeSum -= gFrameTimes[gFrameTimeIndex];
 601     gFrameTimes[gFrameTimeIndex] = nStartTime - gnLastFrameStart;
 602     gnLastFrameStart = nStartTime;
 603     gFrameTimeSum += gFrameTimes[gFrameTimeIndex];
 604     gFrameTimeIndex = (gFrameTimeIndex+1) % gFrameTimeCount;
 605
 606     mrSlideSorter.GetContentWindow()->SetFillColor(COL_BLUE);
 607     mrSlideSorter.GetContentWindow()->DrawRect(gFrameTimeBox);
 608     mrSlideSorter.GetContentWindow()->SetTextColor(COL_WHITE);
 609     mrSlideSorter.GetContentWindow()->DrawText(
 610         gFrameTimeBox,
 611         OUString::number(1 / (gFrameTimeSum / gFrameTimeCount)),
 612         DrawTextFlags::Right | DrawTextFlags::VCenter);
 613     //    mrSlideSorter.GetContentWindow()->Invalidate(gFrameTimeBox);
 614 #endif
 615 }
 616
 617 void SlideSorterView::Paint (
 618     OutputDevice& rDevice,
 619     const ::tools::Rectangle& rRepaintArea)
 620 {
 621     if (rRepaintArea.IsEmpty())
 622         return;
 623
 624     if ( ! mpPageObjectPainter)
 625         if ( ! GetPageObjectPainter())
 626             return;
 627
 628     // Update the page visibilities when they have been invalidated.
 629     if ( ! mbPageObjectVisibilitiesValid)
 630         DeterminePageObjectVisibilities();
 631
 632     if (mbPreciousFlagUpdatePending)
 633         UpdatePreciousFlags();
 634
 635     if (mbIsRearrangePending)
 636         Rearrange();
 637
 638     // Paint all page objects that are fully or partially inside the
 639     // repaint region.
 640     const Range aRange (mpLayouter->GetRangeOfVisiblePageObjects(rRepaintArea));
 641     // Try to prefetch all graphics from the pages to paint. This will be done
 642     // in threads to be more efficient than loading them on-demand one by one.
 643     std::vector<Graphic*> graphics;
 644     for (::tools::Long nIndex=aRange.Min(); nIndex<=aRange.Max(); ++nIndex)
 645     {
 646         model::SharedPageDescriptor pDescriptor (mrModel.GetPageDescriptor(nIndex));
 647         if (!pDescriptor || ! pDescriptor->HasState(PageDescriptor::ST_Visible))
 648             continue;
 649         pDescriptor->GetPage()->getGraphicsForPrefetch(graphics);
 650     }
 651     // Handle also one page before and after to have those in advance on scrolling.
 652     for (::tools::Long nIndex : { aRange.Min() - 1, aRange.Max() + 1 })
 653     {
 654         model::SharedPageDescriptor pDescriptor (mrModel.GetPageDescriptor(nIndex));
 655         if (!pDescriptor)
 656             continue;
 657         pDescriptor->GetPage()->getGraphicsForPrefetch(graphics);
 658     }
 659     if(graphics.size() > 1) // threading does not help with loading just one
 660         GraphicFilter::GetGraphicFilter().MakeGraphicsAvailableThreaded(graphics);
 661
 662     for (::tools::Long nIndex=aRange.Min(); nIndex<=aRange.Max(); ++nIndex)
 663     {
 664         model::SharedPageDescriptor pDescriptor (mrModel.GetPageDescriptor(nIndex));
 665         if (!pDescriptor || ! pDescriptor->HasState(PageDescriptor::ST_Visible))
 666             continue;
 667
 668         mpPageObjectPainter->PaintPageObject(rDevice, pDescriptor);
 669     }
 670 }
 671
 672 void SlideSorterView::ConfigurationChanged (
 673     utl::ConfigurationBroadcaster* pBroadcaster,
 674     ConfigurationHints nHint)
 675 {
 676     // Some changes of the configuration (some of the colors for example)
 677     // may affect the previews.  Throw away the old ones and create new ones.
 678     cache::PageCacheManager::Instance()->InvalidateAllCaches();
 679
 680     ::sd::View::ConfigurationChanged(pBroadcaster, nHint);
 681     RequestRepaint();
 682
 683 }
 684
 685 std::shared_ptr<cache::PageCache> const & SlideSorterView::GetPreviewCache()
 686 {
 687     sd::Window *pWindow (mrSlideSorter.GetContentWindow().get());
 688     if (pWindow && mpPreviewCache == nullptr)
 689     {
 690         mpPreviewCache =
 691             std::make_shared<cache::PageCache>(
 692                 mpLayouter->GetPageObjectSize(),
 693                 Bitmap::HasFastScale(),
 694                 std::make_shared<ViewCacheContext>(mrSlideSorter));
 695     }
 696
 697     return mpPreviewCache;
 698 }
 699
 700 Range const & SlideSorterView::GetVisiblePageRange()
 701 {
 702     if ( ! mbPageObjectVisibilitiesValid)
 703         DeterminePageObjectVisibilities();
 704     return maVisiblePageRange;
 705 }
 706
 707 void SlideSorterView::AddVisibilityChangeListener (const Link<LinkParamNone*,void>& rListener)
 708 {
 709     if (::std::find (
 710         maVisibilityChangeListeners.begin(),
 711         maVisibilityChangeListeners.end(),
 712         rListener) == maVisibilityChangeListeners.end())
 713     {
 714         maVisibilityChangeListeners.push_back(rListener);
 715     }
 716 }
 717
 718 void SlideSorterView::RemoveVisibilityChangeListener(const Link<LinkParamNone*,void>&rListener)
 719 {
 720     maVisibilityChangeListeners.erase (
 721         ::std::find (
 722             maVisibilityChangeListeners.begin(),
 723             maVisibilityChangeListeners.end(),
 724             rListener));
 725 }
 726
 727 ToolTip& SlideSorterView::GetToolTip() const
 728 {
 729     OSL_ASSERT(mpToolTip);
 730     return *mpToolTip;
 731 }
 732
 733 void SlideSorterView::DragFinished (sal_Int8 nDropAction)
 734 {
 735     mrSlideSorter.GetController().GetClipboard().DragFinished(nDropAction);
 736
 737     View::DragFinished(nDropAction);
 738 }
 739
 740 void SlideSorterView::UpdatePageUnderMouse ()
 741 {
 742     // Tracking TODO check
 743     VclPtr<ScrollAdaptor> pVScrollBar (mrSlideSorter.GetVerticalScrollBar());
 744     VclPtr<ScrollAdaptor> pHScrollBar (mrSlideSorter.GetHorizontalScrollBar());
 745     if ((pVScrollBar && pVScrollBar->IsVisible() && pVScrollBar->HasGrab())
 746         || (pHScrollBar && pHScrollBar->IsVisible() && pHScrollBar->HasGrab()))
 747     {
 748         // One of the scroll bars is tracking mouse movement.  Do not
 749         // highlight the slide under the mouse in this case.
 750         SetPageUnderMouse(SharedPageDescriptor());
 751         return;
 752     }
 753
 754     sd::Window *pWindow (mrSlideSorter.GetContentWindow().get());
 755     if (pWindow && pWindow->IsVisible() && ! pWindow->IsMouseCaptured())
 756     {
 757         const Window::PointerState aPointerState (pWindow->GetPointerState());
 758         const ::tools::Rectangle aWindowBox (pWindow->GetPosPixel(), pWindow->GetSizePixel());
 759         if (aWindowBox.Contains(aPointerState.maPos))
 760         {
 761             UpdatePageUnderMouse(aPointerState.maPos);
 762             return;
 763         }
 764     }
 765
 766     SetPageUnderMouse(SharedPageDescriptor());
 767 }
 768
 769 void SlideSorterView::UpdatePageUnderMouse (
 770     const Point& rMousePosition)
 771 {
 772     SetPageUnderMouse(mrSlideSorter.GetController().GetPageAt(rMousePosition));
 773 }
 774
 775 void SlideSorterView::SetPageUnderMouse (
 776     const model::SharedPageDescriptor& rpDescriptor)
 777 {
 778     if (mpPageUnderMouse == rpDescriptor)
 779         return;
 780
 781     if (mpPageUnderMouse)
 782         SetState(mpPageUnderMouse, PageDescriptor::ST_MouseOver, false);
 783
 784     mpPageUnderMouse = rpDescriptor;
 785
 786     if (mpPageUnderMouse)
 787         SetState(mpPageUnderMouse, PageDescriptor::ST_MouseOver, true);
 788
 789     // Change the quick help text to display the name of the page under
 790     // the mouse.
 791     mpToolTip->SetPage(rpDescriptor);
 792 }
 793
 794 bool SlideSorterView::SetState (
 795     const model::SharedPageDescriptor& rpDescriptor,
 796     const PageDescriptor::State eState,
 797     const bool bStateValue)
 798 {
 799     if ( ! rpDescriptor)
 800         return false;
 801
 802     const bool bModified (rpDescriptor->SetState(eState, bStateValue));
 803     if ( ! bModified)
 804         return false;
 805
 806     // When the page object is not visible (i.e. not on the screen then
 807     // nothing has to be painted.
 808     if (rpDescriptor->HasState(PageDescriptor::ST_Visible))
 809     {
 810         // For most states a change of that state leads to visible
 811         // difference and we have to request a repaint.
 812         if (eState != PageDescriptor::ST_WasSelected)
 813             RequestRepaint(rpDescriptor);
 814     }
 815
 816     return bModified;
 817 }
 818
 819 std::shared_ptr<PageObjectPainter> const & SlideSorterView::GetPageObjectPainter()
 820 {
 821     if ( ! mpPageObjectPainter)
 822         mpPageObjectPainter = std::make_shared<PageObjectPainter>(mrSlideSorter);
 823     return mpPageObjectPainter;
 824 }
 825
 826 //===== SlideSorterView::DrawLock =============================================
 827
 828 SlideSorterView::DrawLock::DrawLock (SlideSorter const & rSlideSorter)
 829     : mrView(rSlideSorter.GetView()),
 830       mpWindow(rSlideSorter.GetContentWindow())
 831 {
 832     if (mrView.mnLockRedrawSmph == 0)
 833         mrView.maRedrawRegion.SetEmpty();
 834     ++mrView.mnLockRedrawSmph;
 835 }
 836
 837 SlideSorterView::DrawLock::~DrawLock()
 838 {
 839     OSL_ASSERT(mrView.mnLockRedrawSmph>0);
 840     --mrView.mnLockRedrawSmph;
 841     if (mrView.mnLockRedrawSmph == 0)
 842         if (mpWindow)
 843         {
 844             mpWindow->Invalidate(mrView.maRedrawRegion);
 845         }
 846 }
 847
 848 void SlideSorterView::DrawLock::Dispose()
 849 {
 850     mpWindow.reset();
 851 }
 852
 853 } // end of namespace ::sd::slidesorter::view
 854
 855 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */