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