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