sd/source/ui/slidesorter/view/SlsLayeredDevice.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 "SlsLayeredDevice.hxx"
  21 #include <Window.hxx>
  22
  23 #include <vcl/window.hxx>
  24 #include <vcl/virdev.hxx>
  25 #include <sal/log.hxx>
  26 #include <osl/diagnose.h>
  27
  28 #include <tools/gen.hxx>
  29 #include <tools/fract.hxx>
  30
  31 #include <functional>
  32
  33 namespace sd { namespace slidesorter { namespace view {
  34
  35 namespace {
  36 static const sal_Int32 gnMaximumLayerCount = 8;
  37
  38 class LayerInvalidator : public ILayerInvalidator
  39 {
  40 public:
  41     LayerInvalidator (
  42         const std::shared_ptr<LayeredDevice>& rpLayeredDevice,
  43         sd::Window *pTargetWindow,
  44         const int nLayer)
  45         : mpLayeredDevice(rpLayeredDevice),
  46           mpTargetWindow(pTargetWindow),
  47           mnLayer(nLayer)
  48     {
  49     }
  50
  51     virtual void Invalidate (const ::tools::Rectangle& rInvalidationBox) override
  52     {
  53         mpLayeredDevice->Invalidate(rInvalidationBox, mnLayer);
  54         mpTargetWindow->Invalidate(rInvalidationBox);
  55     }
  56
  57 private:
  58     const std::shared_ptr<LayeredDevice> mpLayeredDevice;
  59     VclPtr<sd::Window> mpTargetWindow;
  60     const int mnLayer;
  61 };
  62
  63 void DeviceCopy (
  64     vcl::RenderContext& rTargetDevice,
  65     vcl::RenderContext const & rSourceDevice,
  66     const ::tools::Rectangle& rBox)
  67 {
  68     rTargetDevice.DrawOutDev(
  69         rBox.TopLeft(),
  70         rBox.GetSize(),
  71         rBox.TopLeft(),
  72         rBox.GetSize(),
  73         rSourceDevice);
  74 }
  75
  76 void ForAllRectangles (const vcl::Region& rRegion, const std::function<void (const ::tools::Rectangle&)>& aFunction)
  77 {
  78     OSL_ASSERT(aFunction);
  79     RectangleVector aRectangles;
  80     rRegion.GetRegionRectangles(aRectangles);
  81
  82     if(aRectangles.empty())
  83     {
  84         aFunction(::tools::Rectangle());
  85     }
  86     else
  87     {
  88         for(const auto& rRect : aRectangles)
  89         {
  90             aFunction(rRect);
  91         }
  92
  93         //Region aMutableRegionCopy (rRegion);
  94         //RegionHandle aHandle(aMutableRegionCopy.BeginEnumRects());
  95         //Rectangle aBox;
  96         //while (aMutableRegionCopy.GetEnumRects(aHandle, aBox))
  97         //    aFunction(aBox);
  98         //aMutableRegionCopy.EndEnumRects(aHandle);
  99     }
 100 }
 101
 102 class Layer
 103 {
 104 public:
 105     Layer();
 106     Layer(const Layer&) = delete;
 107     Layer& operator=(const Layer&) = delete;
 108
 109     void Initialize (sd::Window *pTargetWindow);
 110     void InvalidateRectangle (const ::tools::Rectangle& rInvalidationBox);
 111     void InvalidateRegion (const vcl::Region& rInvalidationRegion);
 112     void Validate (const MapMode& rMapMode);
 113     void Repaint (
 114         OutputDevice& rTargetDevice,
 115         const ::tools::Rectangle& rRepaintRectangle);
 116     void Resize (const Size& rSize);
 117     void AddPainter (const SharedILayerPainter& rpPainter);
 118     void RemovePainter (const SharedILayerPainter& rpPainter);
 119     bool HasPainter() const;
 120     void Dispose();
 121
 122 private:
 123     ScopedVclPtr<VirtualDevice> mpLayerDevice;
 124     ::std::vector<SharedILayerPainter> maPainters;
 125     vcl::Region maInvalidationRegion;
 126
 127     void ValidateRectangle (const ::tools::Rectangle& rBox);
 128 };
 129 typedef std::shared_ptr<Layer> SharedLayer;
 130
 131 } // end of anonymous namespace
 132
 133 class LayeredDevice::LayerContainer
 134 {
 135 public:
 136     LayerContainer() : mvLayers() {}
 137
 138     bool empty() const { return mvLayers.empty(); }
 139
 140     size_t size() const { return mvLayers.size(); }
 141
 142     const SharedLayer& back() const { return mvLayers.back(); }
 143
 144     const ::std::vector<SharedLayer>::const_iterator begin() const { return mvLayers.begin(); }
 145     const ::std::vector<SharedLayer>::const_iterator end() const { return mvLayers.end(); }
 146
 147     void clear() { mvLayers.clear(); }
 148
 149     void pop_back() { mvLayers.pop_back(); }
 150
 151     void resize(size_t n) { mvLayers.resize(n); }
 152
 153     SharedLayer& operator[](size_t i) { return mvLayers[i]; }
 154
 155 private:
 156     ::std::vector<SharedLayer> mvLayers;
 157 };
 158
 159 //===== LayeredDevice =========================================================
 160
 161 LayeredDevice::LayeredDevice (const VclPtr<sd::Window>& pTargetWindow)
 162     : mpTargetWindow(pTargetWindow),
 163       mpLayers(new LayerContainer()),
 164       mpBackBuffer(VclPtr<VirtualDevice>::Create(*mpTargetWindow)),
 165       maSavedMapMode(pTargetWindow->GetMapMode())
 166 {
 167     mpBackBuffer->SetOutputSizePixel(mpTargetWindow->GetSizePixel());
 168 }
 169
 170 LayeredDevice::~LayeredDevice()
 171 {
 172 }
 173
 174 void LayeredDevice::Invalidate (
 175     const ::tools::Rectangle& rInvalidationArea,
 176     const sal_Int32 nLayer)
 177 {
 178     if (nLayer<0 || size_t(nLayer)>=mpLayers->size())
 179     {
 180         OSL_ASSERT(nLayer>=0 && size_t(nLayer)<mpLayers->size());
 181         return;
 182     }
 183
 184     (*mpLayers)[nLayer]->InvalidateRectangle(rInvalidationArea);
 185 }
 186
 187 void LayeredDevice::InvalidateAllLayers (const ::tools::Rectangle& rInvalidationArea)
 188 {
 189     for (size_t nLayer=0; nLayer<mpLayers->size(); ++nLayer)
 190         (*mpLayers)[nLayer]->InvalidateRectangle(rInvalidationArea);
 191 }
 192
 193 void LayeredDevice::InvalidateAllLayers (const vcl::Region& rInvalidationRegion)
 194 {
 195     for (size_t nLayer=0; nLayer<mpLayers->size(); ++nLayer)
 196         (*mpLayers)[nLayer]->InvalidateRegion(rInvalidationRegion);
 197 }
 198
 199 void LayeredDevice::RegisterPainter (
 200     const SharedILayerPainter& rpPainter,
 201     const sal_Int32 nLayer)
 202 {
 203     OSL_ASSERT(mpLayers);
 204     if ( ! rpPainter)
 205     {
 206         OSL_ASSERT(rpPainter);
 207         return;
 208     }
 209     if (nLayer<0 || nLayer>=gnMaximumLayerCount)
 210     {
 211         OSL_ASSERT(nLayer>=0 && nLayer<gnMaximumLayerCount);
 212         return;
 213     }
 214
 215     // Provide the layers.
 216     if (sal_uInt32(nLayer) >= mpLayers->size())
 217     {
 218         const sal_Int32 nOldLayerCount (mpLayers->size());
 219         mpLayers->resize(nLayer+1);
 220
 221         for (size_t nIndex=nOldLayerCount; nIndex<mpLayers->size(); ++nIndex)
 222             (*mpLayers)[nIndex].reset(new Layer());
 223     }
 224
 225     (*mpLayers)[nLayer]->AddPainter(rpPainter);
 226     if (nLayer == 0)
 227         (*mpLayers)[nLayer]->Initialize(mpTargetWindow);
 228
 229     rpPainter->SetLayerInvalidator(
 230         SharedILayerInvalidator(new LayerInvalidator(shared_from_this(),mpTargetWindow,nLayer)));
 231 }
 232
 233 void LayeredDevice::RemovePainter (
 234     const SharedILayerPainter& rpPainter,
 235     const sal_Int32 nLayer)
 236 {
 237     if ( ! rpPainter)
 238     {
 239         OSL_ASSERT(rpPainter);
 240         return;
 241     }
 242     if (nLayer<0 || size_t(nLayer)>=mpLayers->size())
 243     {
 244         OSL_ASSERT(nLayer>=0 && size_t(nLayer)<mpLayers->size());
 245         return;
 246     }
 247
 248     rpPainter->SetLayerInvalidator(SharedILayerInvalidator());
 249
 250     (*mpLayers)[nLayer]->RemovePainter(rpPainter);
 251
 252     // Remove top most layers that do not contain any painters.
 253     while ( ! mpLayers->empty() && ! mpLayers->back()->HasPainter())
 254         mpLayers->pop_back();
 255 }
 256
 257 void LayeredDevice::Repaint (const vcl::Region& rRepaintRegion)
 258 {
 259     // Validate the contents of all layers (that have their own devices.)
 260     for (auto const& it : *mpLayers)
 261     {
 262         it->Validate(mpTargetWindow->GetMapMode());
 263     }
 264
 265     ForAllRectangles(rRepaintRegion,
 266             [this] (::tools::Rectangle const& r) { this->RepaintRectangle(r); });
 267 }
 268
 269 void LayeredDevice::RepaintRectangle (const ::tools::Rectangle& rRepaintRectangle)
 270 {
 271     if (mpLayers->empty())
 272         return;
 273     else if (mpLayers->size() == 1)
 274     {
 275         // Just copy the main layer into the target device.
 276         (*mpLayers)[0]->Repaint(*mpTargetWindow, rRepaintRectangle);
 277     }
 278     else
 279     {
 280         // Paint all layers first into the back buffer (to avoid flickering
 281         // due to synchronous paints) and then copy that into the target
 282         // device.
 283         mpBackBuffer->SetMapMode(mpTargetWindow->GetMapMode());
 284         for (auto const& it : *mpLayers)
 285         {
 286             it->Repaint(*mpBackBuffer, rRepaintRectangle);
 287         }
 288         DeviceCopy(*mpTargetWindow, *mpBackBuffer, rRepaintRectangle);
 289     }
 290 }
 291
 292 void LayeredDevice::Resize()
 293 {
 294     const Size aSize (mpTargetWindow->GetSizePixel());
 295     mpBackBuffer->SetOutputSizePixel(aSize);
 296     for (auto const& it : *mpLayers)
 297     {
 298         it->Resize(aSize);
 299     }
 300 }
 301
 302 void LayeredDevice::Dispose()
 303 {
 304     for (auto const& it : *mpLayers)
 305     {
 306         it->Dispose();
 307     }
 308     mpLayers->clear();
 309 }
 310
 311 bool LayeredDevice::HandleMapModeChange()
 312 {
 313     const MapMode& rMapMode (mpTargetWindow->GetMapMode());
 314     if (maSavedMapMode == rMapMode)
 315         return false;
 316
 317     const ::tools::Rectangle aLogicWindowBox (
 318         mpTargetWindow->PixelToLogic(::tools::Rectangle(Point(0,0), mpTargetWindow->GetSizePixel())));
 319     if (maSavedMapMode.GetScaleX() != rMapMode.GetScaleX()
 320         || maSavedMapMode.GetScaleY() != rMapMode.GetScaleY()
 321         || maSavedMapMode.GetMapUnit() != rMapMode.GetMapUnit())
 322     {
 323         // When the scale has changed then we have to paint everything.
 324         InvalidateAllLayers(aLogicWindowBox);
 325     }
 326     else if (maSavedMapMode.GetOrigin() != rMapMode.GetOrigin())
 327     {
 328         // Window has been scrolled.  Adapt contents of backbuffers and
 329         // layer devices.
 330         const Point aDelta (rMapMode.GetOrigin() - maSavedMapMode.GetOrigin());
 331         mpBackBuffer->CopyArea(
 332             aLogicWindowBox.TopLeft(),
 333             mpTargetWindow->PixelToLogic(Point(0,0), maSavedMapMode),
 334             aLogicWindowBox.GetSize());
 335
 336         // Invalidate the area(s) that have been exposed.
 337         const ::tools::Rectangle aWindowBox (Point(0,0), mpTargetWindow->GetSizePixel());
 338         if (aDelta.Y() < 0)
 339             InvalidateAllLayers(mpTargetWindow->PixelToLogic(::tools::Rectangle(
 340                 aWindowBox.Left(),
 341                 aWindowBox.Bottom()+aDelta.Y(),
 342                 aWindowBox.Right(),
 343                 aWindowBox.Bottom())));
 344         else if (aDelta.Y() > 0)
 345             InvalidateAllLayers(mpTargetWindow->PixelToLogic(::tools::Rectangle(
 346                 aWindowBox.Left(),
 347                 aWindowBox.Top(),
 348                 aWindowBox.Right(),
 349                 aWindowBox.Top()+aDelta.Y())));
 350         if (aDelta.X() < 0)
 351             InvalidateAllLayers(mpTargetWindow->PixelToLogic(::tools::Rectangle(
 352                 aWindowBox.Right()+aDelta.X(),
 353                 aWindowBox.Top(),
 354                 aWindowBox.Right(),
 355                 aWindowBox.Bottom())));
 356         else if (aDelta.X() > 0)
 357             InvalidateAllLayers(mpTargetWindow->PixelToLogic(::tools::Rectangle(
 358                 aWindowBox.Left(),
 359                 aWindowBox.Top(),
 360                 aWindowBox.Left()+aDelta.X(),
 361                 aWindowBox.Bottom())));
 362     }
 363     else
 364     {
 365         // Can this happen?  Lets trigger a warning when it does.
 366         OSL_ASSERT(false);
 367     }
 368
 369     maSavedMapMode = rMapMode;
 370
 371     return true;
 372 }
 373
 374 //===== Layer =================================================================
 375
 376 Layer::Layer()
 377     : mpLayerDevice(),
 378       maPainters(),
 379       maInvalidationRegion()
 380 {
 381 }
 382
 383 void Layer::Initialize (sd::Window *pTargetWindow)
 384 {
 385 #if 0
 386     (void)pTargetWindow;
 387 #else
 388     if ( ! mpLayerDevice)
 389     {
 390         mpLayerDevice.disposeAndReset(VclPtr<VirtualDevice>::Create(*pTargetWindow));
 391         mpLayerDevice->SetOutputSizePixel(pTargetWindow->GetSizePixel());
 392     }
 393 #endif
 394 }
 395
 396 void Layer::InvalidateRectangle (const ::tools::Rectangle& rInvalidationBox)
 397 {
 398     maInvalidationRegion.Union(rInvalidationBox);
 399 }
 400
 401 void Layer::InvalidateRegion (const vcl::Region& rInvalidationRegion)
 402 {
 403     maInvalidationRegion.Union(rInvalidationRegion);
 404 }
 405
 406 void Layer::Validate (const MapMode& rMapMode)
 407 {
 408     if (mpLayerDevice && ! maInvalidationRegion.IsEmpty())
 409     {
 410         vcl::Region aRegion (maInvalidationRegion);
 411         maInvalidationRegion.SetEmpty();
 412
 413         mpLayerDevice->SetMapMode(rMapMode);
 414         ForAllRectangles(
 415             aRegion,
 416             [this] (::tools::Rectangle const& r) { return this->ValidateRectangle(r); });
 417     }
 418 }
 419
 420 void Layer::ValidateRectangle (const ::tools::Rectangle& rBox)
 421 {
 422     if ( ! mpLayerDevice)
 423         return;
 424     const vcl::Region aSavedClipRegion (mpLayerDevice->GetClipRegion());
 425     mpLayerDevice->IntersectClipRegion(rBox);
 426
 427     for (const auto& rxPainter : maPainters)
 428     {
 429         rxPainter->Paint(*mpLayerDevice, rBox);
 430     }
 431
 432     mpLayerDevice->SetClipRegion(aSavedClipRegion);
 433 }
 434
 435 void Layer::Repaint (
 436     OutputDevice& rTargetDevice,
 437     const ::tools::Rectangle& rRepaintRectangle)
 438 {
 439     if (mpLayerDevice)
 440     {
 441         DeviceCopy(rTargetDevice, *mpLayerDevice, rRepaintRectangle);
 442     }
 443     else
 444     {
 445         for (auto const& it : maPainters)
 446         {
 447             it->Paint(rTargetDevice, rRepaintRectangle);
 448         }
 449     }
 450 }
 451
 452 void Layer::Resize (const Size& rSize)
 453 {
 454     if (mpLayerDevice)
 455     {
 456         mpLayerDevice->SetOutputSizePixel(rSize);
 457         maInvalidationRegion = ::tools::Rectangle(Point(0,0), rSize);
 458     }
 459 }
 460
 461 void Layer::AddPainter (const SharedILayerPainter& rpPainter)
 462 {
 463     OSL_ASSERT(::std::find(maPainters.begin(), maPainters.end(), rpPainter) == maPainters.end());
 464
 465     maPainters.push_back(rpPainter);
 466 }
 467
 468 void Layer::RemovePainter (const SharedILayerPainter& rpPainter)
 469 {
 470     const ::std::vector<SharedILayerPainter>::iterator iPainter (
 471         ::std::find(maPainters.begin(), maPainters.end(), rpPainter));
 472     if (iPainter != maPainters.end())
 473     {
 474         maPainters.erase(iPainter);
 475     }
 476     else
 477     {
 478         SAL_WARN("sd", "LayeredDevice::RemovePainter called for painter that is not registered");
 479     }
 480 }
 481
 482 bool Layer::HasPainter() const
 483 {
 484     return !maPainters.empty();
 485 }
 486
 487 void Layer::Dispose()
 488 {
 489     maPainters.clear();
 490 }
 491
 492 } } } // end of namespace ::sd::slidesorter::view
 493
 494 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */