| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_slideshow.hxx" | |
| // must be first | |
| #include <canvas/debug.hxx> | |
| #include <basegfx/range/b2drange.hxx> | |
| #include <basegfx/range/b1drange.hxx> | |
| #include <basegfx/range/b2dpolyrange.hxx> | |
| #include <basegfx/matrix/b2dhommatrix.hxx> | |
| #include <basegfx/polygon/b2dpolypolygon.hxx> | |
| #include <basegfx/polygon/b2dpolypolygontools.hxx> | |
| #include <basegfx/polygon/b2dpolypolygoncutter.hxx> | |
| #include "layer.hxx" | |
| #include <boost/bind.hpp> | |
| using namespace ::com::sun::star; | |
| namespace slideshow | |
| { | |
| namespace internal | |
| { | |
| Layer::Layer( const basegfx::B2DRange& rMaxLayerBounds, | |
| Dummy ) : | |
| maViewEntries(), | |
| maBounds(), | |
| maNewBounds(), | |
| maMaxBounds( rMaxLayerBounds ), | |
| mbBoundsDirty(false), | |
| mbBackgroundLayer(true), | |
| mbClipSet(false) | |
| { | |
| } | |
| Layer::Layer( const basegfx::B2DRange& rMaxLayerBounds ) : | |
| maViewEntries(), | |
| maBounds(), | |
| maNewBounds(), | |
| maMaxBounds( rMaxLayerBounds ), | |
| mbBoundsDirty(false), | |
| mbBackgroundLayer(false), | |
| mbClipSet(false) | |
| { | |
| } | |
| ViewLayerSharedPtr Layer::addView( const ViewSharedPtr& rNewView ) | |
| { | |
| OSL_ASSERT( rNewView ); | |
| ViewEntryVector::iterator aIter; | |
| const ViewEntryVector::iterator aEnd( maViewEntries.end() ); | |
| if( (aIter=std::find_if( maViewEntries.begin(), | |
| aEnd, | |
| boost::bind<bool>( | |
| std::equal_to< ViewSharedPtr >(), | |
| boost::bind( &ViewEntry::getView, _1 ), | |
| boost::cref( rNewView )))) != aEnd ) | |
| { | |
| // already added - just return existing layer | |
| return aIter->mpViewLayer; | |
| } | |
| // not yet added - create new view layer | |
| ViewLayerSharedPtr pNewLayer; | |
| if( mbBackgroundLayer ) | |
| pNewLayer = rNewView; | |
| else | |
| pNewLayer = rNewView->createViewLayer(maBounds); | |
| // add to local list | |
| maViewEntries.push_back( | |
| ViewEntry( rNewView, | |
| pNewLayer )); | |
| return maViewEntries.back().mpViewLayer; | |
| } | |
| ViewLayerSharedPtr Layer::removeView( const ViewSharedPtr& rView ) | |
| { | |
| OSL_ASSERT( rView ); | |
| ViewEntryVector::iterator aIter; | |
| const ViewEntryVector::iterator aEnd( maViewEntries.end() ); | |
| if( (aIter=std::find_if( maViewEntries.begin(), | |
| aEnd, | |
| boost::bind<bool>( | |
| std::equal_to< ViewSharedPtr >(), | |
| boost::bind( &ViewEntry::getView, _1 ), | |
| boost::cref( rView )))) == aEnd ) | |
| { | |
| // View was not added/is already removed | |
| return ViewLayerSharedPtr(); | |
| } | |
| OSL_ENSURE( std::count_if( maViewEntries.begin(), | |
| aEnd, | |
| boost::bind<bool>( | |
| std::equal_to< ViewSharedPtr >(), | |
| boost::bind( &ViewEntry::getView, _1 ), | |
| boost::cref( rView ))) == 1, | |
| "Layer::removeView(): view added multiple times" ); | |
| ViewLayerSharedPtr pRet( aIter->mpViewLayer ); | |
| maViewEntries.erase(aIter); | |
| return pRet; | |
| } | |
| void Layer::viewChanged( const ViewSharedPtr& rChangedView ) | |
| { | |
| ViewEntryVector::iterator aIter; | |
| const ViewEntryVector::iterator aEnd( maViewEntries.end() ); | |
| if( (aIter=std::find_if( maViewEntries.begin(), | |
| aEnd, | |
| boost::bind<bool>( | |
| std::equal_to< ViewSharedPtr >(), | |
| boost::bind( &ViewEntry::getView, _1 ), | |
| boost::cref( rChangedView )))) != | |
| aEnd ) | |
| { | |
| // adapt size of given ViewLayer - background layer | |
| // resizes with view. | |
| if( !mbBackgroundLayer ) | |
| aIter->mpViewLayer->resize(maBounds); | |
| } | |
| } | |
| void Layer::viewsChanged() | |
| { | |
| // adapt size of given ViewLayer - background layer | |
| // resizes with view. | |
| if( !mbBackgroundLayer ) | |
| { | |
| std::for_each( maViewEntries.begin(), | |
| maViewEntries.end(), | |
| boost::bind( &ViewLayer::resize, | |
| boost::bind( &ViewEntry::getViewLayer, | |
| _1 ), | |
| boost::cref(maBounds))); | |
| } | |
| } | |
| void Layer::setShapeViews( ShapeSharedPtr const& rShape ) const | |
| { | |
| rShape->clearAllViewLayers(); | |
| std::for_each( maViewEntries.begin(), | |
| maViewEntries.end(), | |
| boost::bind(&Shape::addViewLayer, | |
| boost::cref(rShape), | |
| boost::bind(&ViewEntry::getViewLayer, | |
| _1), | |
| false )); | |
| } | |
| void Layer::setPriority( const ::basegfx::B1DRange& rPrioRange ) | |
| { | |
| if( !mbBackgroundLayer ) | |
| { | |
| std::for_each( maViewEntries.begin(), | |
| maViewEntries.end(), | |
| boost::bind( &ViewLayer::setPriority, | |
| boost::bind( &ViewEntry::getViewLayer, | |
| _1 ), | |
| boost::cref(rPrioRange))); | |
| } | |
| } | |
| void Layer::addUpdateRange( ::basegfx::B2DRange const& rUpdateRange ) | |
| { | |
| // TODO(Q1): move this to B2DMultiRange | |
| if( !rUpdateRange.isEmpty() ) | |
| maUpdateAreas.appendElement( rUpdateRange, | |
| basegfx::ORIENTATION_POSITIVE ); | |
| } | |
| void Layer::updateBounds( ShapeSharedPtr const& rShape ) | |
| { | |
| if( !mbBackgroundLayer ) | |
| { | |
| if( !mbBoundsDirty ) | |
| maNewBounds.reset(); | |
| maNewBounds.expand( rShape->getUpdateArea() ); | |
| } | |
| mbBoundsDirty = true; | |
| } | |
| bool Layer::commitBounds() | |
| { | |
| mbBoundsDirty = false; | |
| if( mbBackgroundLayer ) | |
| return false; | |
| if( maNewBounds == maBounds ) | |
| return false; | |
| maBounds = maNewBounds; | |
| if( std::count_if( maViewEntries.begin(), | |
| maViewEntries.end(), | |
| boost::bind( &ViewLayer::resize, | |
| boost::bind( &ViewEntry::getViewLayer, | |
| _1 ), | |
| boost::cref(maBounds)) ) == 0 ) | |
| { | |
| return false; | |
| } | |
| // layer content invalid, update areas have wrong | |
| // coordinates/not sensible anymore. | |
| clearUpdateRanges(); | |
| return true; | |
| } | |
| void Layer::clearUpdateRanges() | |
| { | |
| maUpdateAreas.clear(); | |
| } | |
| void Layer::clearContent() | |
| { | |
| // clear content on all view layers | |
| std::for_each( maViewEntries.begin(), | |
| maViewEntries.end(), | |
| boost::bind( | |
| &ViewLayer::clear, | |
| boost::bind( | |
| &ViewEntry::getViewLayer, | |
| _1))); | |
| // layer content cleared, update areas are not sensible | |
| // anymore. | |
| clearUpdateRanges(); | |
| } | |
| class LayerEndUpdate : private boost::noncopyable | |
| { | |
| public: | |
| LayerEndUpdate( LayerSharedPtr const& rLayer ) : | |
| mpLayer( rLayer ) | |
| {} | |
| ~LayerEndUpdate() { if(mpLayer) mpLayer->endUpdate(); } | |
| void dismiss() { mpLayer.reset(); } | |
| private: | |
| LayerSharedPtr mpLayer; | |
| }; | |
| Layer::EndUpdater Layer::beginUpdate() | |
| { | |
| if( maUpdateAreas.count() ) | |
| { | |
| // perform proper layer update. That means, setup proper | |
| // clipping, and render each shape that intersects with | |
| // the calculated update area | |
| ::basegfx::B2DPolyPolygon aClip( maUpdateAreas.solveCrossovers() ); | |
| aClip = ::basegfx::tools::stripNeutralPolygons(aClip); | |
| aClip = ::basegfx::tools::stripDispensablePolygons(aClip, false); | |
| // actually, if there happen to be shapes with zero | |
| // update area in the maUpdateAreas vector, the | |
| // resulting clip polygon will be empty. | |
| if( aClip.count() ) | |
| { | |
| // set clip to all view layers | |
| std::for_each( maViewEntries.begin(), | |
| maViewEntries.end(), | |
| boost::bind( | |
| &ViewLayer::setClip, | |
| boost::bind( | |
| &ViewEntry::getViewLayer, | |
| _1), | |
| boost::cref(aClip))); | |
| // clear update area on all view layers | |
| std::for_each( maViewEntries.begin(), | |
| maViewEntries.end(), | |
| boost::bind( | |
| &ViewLayer::clear, | |
| boost::bind( | |
| &ViewEntry::getViewLayer, | |
| _1))); | |
| mbClipSet = true; | |
| } | |
| } | |
| return EndUpdater(new LayerEndUpdate(shared_from_this())); | |
| } | |
| void Layer::endUpdate() | |
| { | |
| if( mbClipSet ) | |
| { | |
| mbClipSet = false; | |
| basegfx::B2DPolyPolygon aEmptyClip; | |
| std::for_each( maViewEntries.begin(), | |
| maViewEntries.end(), | |
| boost::bind( | |
| &ViewLayer::setClip, | |
| boost::bind( | |
| &ViewEntry::getViewLayer, | |
| _1), | |
| boost::cref(aEmptyClip))); | |
| } | |
| clearUpdateRanges(); | |
| } | |
| bool Layer::isInsideUpdateArea( ShapeSharedPtr const& rShape ) const | |
| { | |
| return maUpdateAreas.overlaps( rShape->getUpdateArea() ); | |
| } | |
| LayerSharedPtr Layer::createBackgroundLayer( const basegfx::B2DRange& rMaxLayerBounds ) | |
| { | |
| return LayerSharedPtr(new Layer( rMaxLayerBounds, | |
| BackgroundLayer )); | |
| } | |
| LayerSharedPtr Layer::createLayer( const basegfx::B2DRange& rMaxLayerBounds ) | |
| { | |
| return LayerSharedPtr( new Layer( rMaxLayerBounds ) ); | |
| } | |
| } | |
| } |