| /************************************************************** | |
| * | |
| * 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. | |
| * | |
| *************************************************************/ | |
| #ifndef INCLUDED_SLIDESHOW_LAYER_HXX | |
| #define INCLUDED_SLIDESHOW_LAYER_HXX | |
| #include <basegfx/range/b2dpolyrange.hxx> | |
| #include <cppcanvas/spritecanvas.hxx> | |
| #include "view.hxx" | |
| #include "animatableshape.hxx" | |
| #include <boost/shared_ptr.hpp> | |
| #include <boost/weak_ptr.hpp> | |
| #include <boost/noncopyable.hpp> | |
| #include <boost/enable_shared_from_this.hpp> | |
| #include <vector> | |
| namespace slideshow | |
| { | |
| namespace internal | |
| { | |
| class LayerEndUpdate; | |
| /* Definition of Layer class */ | |
| /** This class represents one layer of output on a Slide. | |
| Layers group shapes for a certain depth region of a slide. | |
| Since slides have a notion of depth, i.e. shapes on it | |
| have a certain order in which they lie upon each other, | |
| this layering must be modelled. A prime example for this | |
| necessity are animations of shapes lying behind other | |
| shapes. Then, everything behind the animated shape will be | |
| in a background layer, the shape itself will be in an | |
| animation layer, and everything before it will be in a | |
| foreground layer (these layers are most preferably | |
| modelled as XSprite objects internally). | |
| @attention All methods of this class are only supposed to | |
| be called from the LayerManager. Normally, it shouldn't be | |
| possible to get hold of an instance of this class at all. | |
| */ | |
| class Layer : public boost::enable_shared_from_this<Layer>, | |
| private boost::noncopyable | |
| { | |
| public: | |
| typedef boost::shared_ptr<LayerEndUpdate> EndUpdater; | |
| /** Create background layer | |
| This method will create a layer without a ViewLayer, | |
| i.e. one that displays directly on the background. | |
| @param rMaxLayerBounds | |
| Maximal bounds of this layer, in user | |
| coordinates. This layer will never be larger or extend | |
| outside these bounds. | |
| */ | |
| static ::boost::shared_ptr< Layer > createBackgroundLayer( const basegfx::B2DRange& rMaxLayerBounds ); | |
| /** Create non-background layer | |
| This method will create a layer in front of the | |
| background, to contain shapes that should appear in | |
| front of animated objects. | |
| @param rMaxLayerBounds | |
| Maximal bounds of this layer, in user | |
| coordinates. This layer will never be larger or extend | |
| outside these bounds. | |
| */ | |
| static ::boost::shared_ptr< Layer > createLayer( const basegfx::B2DRange& rMaxLayerBounds ); | |
| ///////////////////////////////////////////////////////////////////// | |
| /** Predicate, whether this layer is the special | |
| background layer | |
| This method is mostly useful for checking invariants. | |
| */ | |
| bool isBackgroundLayer() const { return mbBackgroundLayer; } | |
| /** Add a view to this layer. | |
| If the view is already added, this method does not add | |
| it a second time, just returning the existing ViewLayer. | |
| @param rNewView | |
| New view to add to this layer. | |
| @return the newly generated ViewLayer for this View | |
| */ | |
| ViewLayerSharedPtr addView( const ViewSharedPtr& rNewView ); | |
| /** Remove a view | |
| This method removes the view from this Layer and all | |
| shapes included herein. | |
| @return the ViewLayer of the removed Layer, if | |
| any. Otherwise, NULL is returned. | |
| */ | |
| ViewLayerSharedPtr removeView( const ViewSharedPtr& rView ); | |
| /** Notify that given ViewLayer has changed | |
| @param rChangedView | |
| This view's layer will get resized. Afterwards, a | |
| complete repaint might be necessary. | |
| */ | |
| void viewChanged( const ViewSharedPtr& rChangedView ); | |
| /** Notify that all ViewLayer have changed | |
| This resizes all view layers. Afterwards, a complete | |
| repaint might be necessary. | |
| */ | |
| void viewsChanged(); | |
| /** Init shape with this layer's views | |
| @param rShape | |
| The shape, that will subsequently display on this | |
| layer's views | |
| */ | |
| void setShapeViews( ShapeSharedPtr const& rShape ) const; | |
| ///////////////////////////////////////////////////////////////////// | |
| /** Change layer priority range. | |
| The layer priority affects the position of the layer | |
| in the z direction (i.e. before/behind which other | |
| layers this one appears). The higher the prio, the | |
| further on top of the layer stack this one appears. | |
| @param rPrioRange | |
| The priority range of differing layers must not | |
| intersect | |
| */ | |
| void setPriority( const ::basegfx::B1DRange& rPrioRange ); | |
| /** Add an area that needs update | |
| @param rUpdateRange | |
| Area on this layer that needs update | |
| */ | |
| void addUpdateRange( ::basegfx::B2DRange const& rUpdateRange ); | |
| /** Whether any update ranges have been added | |
| @return true, if any non-empty addUpdateRange() calls | |
| have been made since the last render()/update() call. | |
| */ | |
| bool isUpdatePending() const { return maUpdateAreas.count()!=0; } | |
| /** Update layer bound rect from shape bounds | |
| */ | |
| void updateBounds( ShapeSharedPtr const& rShape ); | |
| /** Commit collected layer bounds to ViewLayer | |
| Call this method when you're done adding new shapes to | |
| the layer. | |
| @return true, if layer needed a resize (which | |
| invalidates its content - you have to repaint all | |
| contained shapes!) | |
| */ | |
| bool commitBounds(); | |
| /** Clear all registered update ranges | |
| This method clears all update ranges that are | |
| registered at this layer. | |
| */ | |
| void clearUpdateRanges(); | |
| /** Clear whole layer content | |
| This method clears the whole layer content. As a | |
| byproduct, all update ranges are cleared as well. It | |
| makes no sense to maintain them any further, since | |
| they only serve for partial updates. | |
| */ | |
| void clearContent(); | |
| /** Init layer update. | |
| This method initializes a full layer update of the | |
| update area. When the last copy of the returned | |
| EndUpdater is destroyed, the Layer leaves update mode | |
| again. | |
| @return a update end RAII object. | |
| */ | |
| EndUpdater beginUpdate(); | |
| /** Finish layer update | |
| Resets clipping and transformation to normal values | |
| */ | |
| void endUpdate(); | |
| /** Check whether given shape is inside current update area. | |
| @return true, if the given shape is at least partially | |
| inside the current update area. | |
| */ | |
| bool isInsideUpdateArea( ShapeSharedPtr const& rShape ) const; | |
| private: | |
| enum Dummy{ BackgroundLayer }; | |
| /** Create background layer | |
| This constructor will create a layer without a | |
| ViewLayer, i.e. one that displays directly on the | |
| background. | |
| @param rMaxLayerBounds | |
| Maximal bounds of this layer, in user | |
| coordinates. This layer will never be larger or extend | |
| outside these bounds. | |
| @param eFlag | |
| Dummy parameter, to disambiguate from normal layer | |
| constructor | |
| */ | |
| Layer( const basegfx::B2DRange& rMaxLayerBounds, | |
| Dummy eFlag ); | |
| /** Create non-background layer | |
| This constructor will create a layer in front of the | |
| background, to contain shapes that should appear in | |
| front of animated objects. | |
| @param rMaxLayerBounds | |
| Maximal bounds of this layer, in user | |
| coordinates. This layer will never be larger or extend | |
| outside these bounds. | |
| */ | |
| explicit Layer( const basegfx::B2DRange& rMaxLayerBounds ); | |
| struct ViewEntry | |
| { | |
| ViewEntry( const ViewSharedPtr& rView, | |
| const ViewLayerSharedPtr& rViewLayer ) : | |
| mpView( rView ), | |
| mpViewLayer( rViewLayer ) | |
| {} | |
| ViewSharedPtr mpView; | |
| ViewLayerSharedPtr mpViewLayer; | |
| // for generic algo access (which needs actual functions) | |
| const ViewSharedPtr& getView() const { return mpView; } | |
| const ViewLayerSharedPtr& getViewLayer() const { return mpViewLayer; } | |
| }; | |
| typedef ::std::vector< ViewEntry > ViewEntryVector; | |
| ViewEntryVector maViewEntries; | |
| basegfx::B2DPolyRange maUpdateAreas; | |
| basegfx::B2DRange maBounds; | |
| basegfx::B2DRange maNewBounds; | |
| const basegfx::B2DRange maMaxBounds; // maBounds is clipped against this | |
| bool mbBoundsDirty; // true, if view layers need resize | |
| bool mbBackgroundLayer; // true, if this | |
| // layer is the | |
| // special | |
| // background layer | |
| bool mbClipSet; // true, if beginUpdate set a clip | |
| }; | |
| typedef ::boost::shared_ptr< Layer > LayerSharedPtr; | |
| typedef ::boost::weak_ptr< Layer > LayerWeakPtr; | |
| typedef ::std::vector< LayerSharedPtr > LayerVector; | |
| } | |
| } | |
| #endif /* INCLUDED_SLIDESHOW_LAYER_HXX */ |