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