slideshow/source/engine/slide/layer.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
  21 #include <basegfx/range/b2drange.hxx>
  22 #include <basegfx/range/b1drange.hxx>
  23 #include <basegfx/range/b2dpolyrange.hxx>
  24 #include <basegfx/polygon/b2dpolypolygon.hxx>
  25 #include <basegfx/polygon/b2dpolypolygoncutter.hxx>
  26 #include <osl/diagnose.h>
  27
  28 #include "layer.hxx"
  29
  30 using namespace ::com::sun::star;
  31
  32 namespace slideshow::internal
  33 {
  34         Layer::Layer( Dummy                     ) :
  35             maViewEntries(),
  36             maBounds(),
  37             maNewBounds(),
  38             mbBoundsDirty(false),
  39             mbBackgroundLayer(true),
  40             mbClipSet(false)
  41         {
  42         }
  43
  44         Layer::Layer() :
  45             maViewEntries(),
  46             maBounds(),
  47             maNewBounds(),
  48             mbBoundsDirty(false),
  49             mbBackgroundLayer(false),
  50             mbClipSet(false)
  51         {
  52         }
  53
  54         ViewLayerSharedPtr Layer::addView( const ViewSharedPtr& rNewView )
  55         {
  56             OSL_ASSERT( rNewView );
  57
  58             ViewEntryVector::iterator aIter;
  59             const ViewEntryVector::iterator aEnd( maViewEntries.end() );
  60             if( (aIter=std::find_if( maViewEntries.begin(),
  61                                      aEnd,
  62                                      [&rNewView]( const ViewEntry& rViewEntry )
  63                                      { return rViewEntry.getView() == rNewView; } ) ) != aEnd )
  64             {
  65                 // already added - just return existing layer
  66                 return aIter->mpViewLayer;
  67
  68             }
  69
  70             // not yet added - create new view layer
  71             ViewLayerSharedPtr pNewLayer;
  72             if( mbBackgroundLayer )
  73                 pNewLayer = rNewView;
  74             else
  75                 pNewLayer = rNewView->createViewLayer(maBounds);
  76
  77             // add to local list
  78             maViewEntries.emplace_back( rNewView,
  79                            pNewLayer );
  80
  81             return maViewEntries.back().mpViewLayer;
  82         }
  83
  84         ViewLayerSharedPtr Layer::removeView( const ViewSharedPtr& rView )
  85         {
  86             OSL_ASSERT( rView );
  87
  88             ViewEntryVector::iterator       aIter;
  89             const ViewEntryVector::iterator aEnd( maViewEntries.end() );
  90             if( (aIter=std::find_if( maViewEntries.begin(),
  91                                        aEnd,
  92                                        [&rView]( const ViewEntry& rViewEntry )
  93                                        { return rViewEntry.getView() == rView; } ) ) == aEnd )
  94             {
  95                 // View was not added/is already removed
  96                 return ViewLayerSharedPtr();
  97             }
  98
  99             OSL_ENSURE( std::count_if( maViewEntries.begin(),
 100                                        aEnd,
 101                                        [&rView]( const ViewEntry& rViewEntry )
 102                                        { return rViewEntry.getView() == rView; } ) == 1,
 103                         "Layer::removeView(): view added multiple times" );
 104
 105             ViewLayerSharedPtr pRet( aIter->mpViewLayer );
 106             maViewEntries.erase(aIter);
 107
 108             return pRet;
 109         }
 110
 111         void Layer::setShapeViews( ShapeSharedPtr const& rShape ) const
 112         {
 113             rShape->clearAllViewLayers();
 114
 115             for( const auto& rViewEntry : maViewEntries )
 116                 rShape->addViewLayer( rViewEntry.getViewLayer(), false );
 117         }
 118
 119         void Layer::setPriority( const ::basegfx::B1DRange& rPrioRange )
 120         {
 121             if( !mbBackgroundLayer )
 122             {
 123                 for( const auto& rViewEntry : maViewEntries )
 124                     rViewEntry.getViewLayer()->setPriority( rPrioRange );
 125             }
 126         }
 127
 128         void Layer::addUpdateRange( ::basegfx::B2DRange const& rUpdateRange )
 129         {
 130             // TODO(Q1): move this to B2DMultiRange
 131             if( !rUpdateRange.isEmpty() )
 132                 maUpdateAreas.appendElement( rUpdateRange,
 133                                              basegfx::B2VectorOrientation::Positive );
 134         }
 135
 136         void Layer::updateBounds( ShapeSharedPtr const& rShape )
 137         {
 138             if( !mbBackgroundLayer )
 139             {
 140                 if( !mbBoundsDirty )
 141                     maNewBounds.reset();
 142
 143                 maNewBounds.expand( rShape->getUpdateArea() );
 144             }
 145
 146             mbBoundsDirty = true;
 147         }
 148
 149         bool Layer::commitBounds()
 150         {
 151             mbBoundsDirty = false;
 152
 153             if( mbBackgroundLayer )
 154                 return false;
 155
 156             if( maNewBounds == maBounds )
 157                 return false;
 158
 159             maBounds = maNewBounds;
 160             if( std::count_if( maViewEntries.begin(),
 161                                maViewEntries.end(),
 162                                [this]( const ViewEntry& rViewEntry )
 163                                { return rViewEntry.getViewLayer()->resize( this->maBounds ); }
 164                                ) == 0 )
 165             {
 166                 return false;
 167             }
 168
 169             // layer content invalid, update areas have wrong
 170             // coordinates/not sensible anymore.
 171             clearUpdateRanges();
 172
 173             return true;
 174         }
 175
 176         void Layer::clearUpdateRanges()
 177         {
 178             maUpdateAreas.clear();
 179         }
 180
 181         void Layer::clearContent()
 182         {
 183             // clear content on all view layers
 184             for( const auto& rViewEntry : maViewEntries )
 185                 rViewEntry.getViewLayer()->clearAll();
 186
 187             // layer content cleared, update areas are not sensible
 188             // anymore.
 189             clearUpdateRanges();
 190         }
 191
 192         class LayerEndUpdate
 193         {
 194         public:
 195             LayerEndUpdate( const LayerEndUpdate& ) = delete;
 196             LayerEndUpdate& operator=( const LayerEndUpdate& ) = delete;
 197             explicit LayerEndUpdate( LayerSharedPtr const& rLayer ) :
 198                 mpLayer( rLayer )
 199             {}
 200
 201             ~LayerEndUpdate() { if(mpLayer) mpLayer->endUpdate(); }
 202
 203         private:
 204             LayerSharedPtr mpLayer;
 205         };
 206
 207         Layer::EndUpdater Layer::beginUpdate()
 208         {
 209             if( maUpdateAreas.count() )
 210             {
 211                 // perform proper layer update. That means, setup proper
 212                 // clipping, and render each shape that intersects with
 213                 // the calculated update area
 214                 ::basegfx::B2DPolyPolygon aClip( maUpdateAreas.solveCrossovers() );
 215                 aClip = ::basegfx::utils::stripNeutralPolygons(aClip);
 216                 aClip = ::basegfx::utils::stripDispensablePolygons(aClip);
 217
 218                 // actually, if there happen to be shapes with zero
 219                 // update area in the maUpdateAreas vector, the
 220                 // resulting clip polygon will be empty.
 221                 if( aClip.count() )
 222                 {
 223                     for( const auto& rViewEntry : maViewEntries )
 224                     {
 225                         const ViewLayerSharedPtr& pViewLayer = rViewEntry.getViewLayer();
 226
 227                         // set clip to all view layers and
 228                         pViewLayer->setClip( aClip );
 229
 230                         // clear update area on all view layers
 231                         pViewLayer->clear();
 232                     }
 233
 234                     mbClipSet = true;
 235                 }
 236             }
 237
 238             return std::make_shared<LayerEndUpdate>(shared_from_this());
 239         }
 240
 241         void Layer::endUpdate()
 242         {
 243             if( mbClipSet )
 244             {
 245                 mbClipSet = false;
 246
 247                 basegfx::B2DPolyPolygon aEmptyClip;
 248                 for( const auto& rViewEntry : maViewEntries )
 249                     rViewEntry.getViewLayer()->setClip( aEmptyClip );
 250             }
 251
 252             clearUpdateRanges();
 253         }
 254
 255         bool Layer::isInsideUpdateArea( ShapeSharedPtr const& rShape ) const
 256         {
 257             return maUpdateAreas.overlaps( rShape->getUpdateArea() );
 258         }
 259
 260         LayerSharedPtr Layer::createBackgroundLayer()
 261         {
 262             return LayerSharedPtr(new Layer( BackgroundLayer ));
 263         }
 264
 265         LayerSharedPtr Layer::createLayer( )
 266         {
 267             return LayerSharedPtr( new Layer );
 268         }
 269
 270 }
 271
 272 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */