| /************************************************************** |
| * |
| * 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" |
| |
| #include <osl/diagnose.hxx> |
| #include <canvas/debug.hxx> |
| #include <tools/diagnose_ex.h> |
| #include <canvas/canvastools.hxx> |
| #include <cppcanvas/basegfxfactory.hxx> |
| |
| #include <basegfx/matrix/b2dhommatrix.hxx> |
| #include <basegfx/point/b2dpoint.hxx> |
| #include <basegfx/polygon/b2dpolygon.hxx> |
| #include <basegfx/polygon/b2dpolygontools.hxx> |
| #include <basegfx/numeric/ftools.hxx> |
| |
| #include <com/sun/star/awt/SystemPointer.hpp> |
| #include <com/sun/star/container/XIndexAccess.hpp> |
| #include <com/sun/star/drawing/XMasterPageTarget.hpp> |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/container/XEnumerationAccess.hpp> |
| #include <com/sun/star/awt/Rectangle.hpp> |
| #include <com/sun/star/presentation/ParagraphTarget.hpp> |
| #include <com/sun/star/presentation/EffectNodeType.hpp> |
| #include <com/sun/star/animations/XAnimationNodeSupplier.hpp> |
| #include <com/sun/star/animations/XTargetPropertiesCreator.hpp> |
| #include <com/sun/star/drawing/TextAnimationKind.hpp> |
| |
| #include <animations/animationnodehelper.hxx> |
| |
| #include <cppuhelper/exc_hlp.hxx> |
| #include <comphelper/anytostring.hxx> |
| |
| #include "slide.hxx" |
| #include "slideshowcontext.hxx" |
| #include "slideanimations.hxx" |
| #include "doctreenode.hxx" |
| #include "screenupdater.hxx" |
| #include "cursormanager.hxx" |
| #include "shapeimporter.hxx" |
| #include "slideshowexceptions.hxx" |
| #include "eventqueue.hxx" |
| #include "activitiesqueue.hxx" |
| #include "layermanager.hxx" |
| #include "shapemanagerimpl.hxx" |
| #include "usereventqueue.hxx" |
| #include "userpaintoverlay.hxx" |
| #include "event.hxx" |
| #include "tools.hxx" |
| |
| #include <boost/bind.hpp> |
| #include <iterator> |
| #include <algorithm> |
| #include <functional> |
| #include <iostream> |
| |
| using namespace ::com::sun::star; |
| |
| // ----------------------------------------------------------------------------- |
| |
| namespace slideshow |
| { |
| namespace internal |
| { |
| namespace |
| { |
| |
| class SlideImpl : public Slide, |
| public CursorManager, |
| public ViewEventHandler, |
| public ::osl::DebugBase<SlideImpl> |
| { |
| public: |
| SlideImpl( const uno::Reference<drawing::XDrawPage>& xDrawPage, |
| const uno::Reference<drawing::XDrawPagesSupplier>& xDrawPages, |
| const uno::Reference<animations::XAnimationNode>& xRootNode, |
| EventQueue& rEventQueue, |
| EventMultiplexer& rEventMultiplexer, |
| ScreenUpdater& rScreenUpdater, |
| ActivitiesQueue& rActivitiesQueue, |
| UserEventQueue& rUserEventQueue, |
| CursorManager& rCursorManager, |
| const UnoViewContainer& rViewContainer, |
| const uno::Reference<uno::XComponentContext>& xContext, |
| const ShapeEventListenerMap& rShapeListenerMap, |
| const ShapeCursorMap& rShapeCursorMap, |
| const PolyPolygonVector& rPolyPolygonVector, |
| RGBColor const& rUserPaintColor, |
| double dUserPaintStrokeWidth, |
| bool bUserPaintEnabled, |
| bool bIntrinsicAnimationsAllowed, |
| bool bDisableAnimationZOrder ); |
| |
| ~SlideImpl(); |
| |
| |
| // Disposable interface |
| // ------------------------------------------------------------------- |
| |
| virtual void dispose(); |
| |
| |
| // Slide interface |
| // ------------------------------------------------------------------- |
| |
| virtual bool prefetch(); |
| virtual bool show( bool ); |
| virtual void hide(); |
| |
| virtual basegfx::B2ISize getSlideSize() const; |
| virtual uno::Reference<drawing::XDrawPage > getXDrawPage() const; |
| virtual uno::Reference<animations::XAnimationNode> getXAnimationNode() const; |
| virtual PolyPolygonVector getPolygons(); |
| virtual void drawPolygons() const; |
| virtual bool isPaintOverlayActive() const; |
| virtual void enablePaintOverlay(); |
| virtual void disablePaintOverlay(); |
| virtual void update_settings( bool bUserPaintEnabled, RGBColor const& aUserPaintColor, double dUserPaintStrokeWidth ); |
| |
| |
| // TODO(F2): Rework SlideBitmap to no longer be based on XBitmap, |
| // but on canvas-independent basegfx bitmaps |
| virtual SlideBitmapSharedPtr getCurrentSlideBitmap( const UnoViewSharedPtr& rView ) const; |
| |
| |
| private: |
| // ViewEventHandler |
| virtual void viewAdded( const UnoViewSharedPtr& rView ); |
| virtual void viewRemoved( const UnoViewSharedPtr& rView ); |
| virtual void viewChanged( const UnoViewSharedPtr& rView ); |
| virtual void viewsChanged(); |
| |
| // CursorManager |
| virtual bool requestCursor( sal_Int16 nCursorShape ); |
| virtual void resetCursor(); |
| |
| void activatePaintOverlay(); |
| void deactivatePaintOverlay(); |
| |
| /** Query whether the slide has animations at all |
| |
| If the slide doesn't have animations, show() displays |
| only static content. If an event is registered with |
| registerSlideEndEvent(), this event will be |
| immediately activated at the end of the show() method. |
| |
| @return true, if this slide has animations, false |
| otherwise |
| */ |
| bool isAnimated(); |
| |
| /** Query whether this slide is currently showing. |
| |
| @return true, if this slide is currently showing. |
| */ |
| bool isShowing() const; |
| |
| /// Set all Shapes to their initial attributes for slideshow |
| bool applyInitialShapeAttributes( const ::com::sun::star::uno::Reference< |
| ::com::sun::star::animations::XAnimationNode >& xRootAnimationNode ); |
| |
| /// Renders current slide content to bitmap |
| SlideBitmapSharedPtr createCurrentSlideBitmap( |
| const UnoViewSharedPtr& rView, |
| ::basegfx::B2ISize const & rSlideSize ) const; |
| |
| /// Prefetch all shapes (not the animations) |
| bool loadShapes(); |
| |
| /// Retrieve slide size from XDrawPage |
| basegfx::B2ISize getSlideSizeImpl() const; |
| |
| /// Prefetch show, but don't call applyInitialShapeAttributes() |
| bool implPrefetchShow(); |
| |
| /// Query the rectangle covered by the slide |
| ::basegfx::B2DRectangle getSlideRect() const; |
| |
| /// Start GIF and other intrinsic shape animations |
| void endIntrinsicAnimations(); |
| |
| /// End GIF and other intrinsic shape animations |
| void startIntrinsicAnimations(); |
| |
| /// Add Polygons to the member maPolygons |
| void addPolygons(PolyPolygonVector aPolygons); |
| |
| // Types |
| // ===== |
| |
| enum SlideAnimationState |
| { |
| CONSTRUCTING_STATE=0, |
| INITIAL_STATE=1, |
| SHOWING_STATE=2, |
| FINAL_STATE=3, |
| SlideAnimationState_NUM_ENTRIES=4 |
| }; |
| |
| typedef std::vector< SlideBitmapSharedPtr > VectorOfSlideBitmaps; |
| /** Vector of slide bitmaps. |
| |
| Since the bitmap content is sensitive to animation |
| effects, we have an inner vector containing a distinct |
| bitmap for each of the SlideAnimationStates. |
| */ |
| typedef ::std::vector< std::pair< UnoViewSharedPtr, |
| VectorOfSlideBitmaps > > VectorOfVectorOfSlideBitmaps; |
| |
| |
| // Member variables |
| // ================ |
| |
| /// The page model object |
| uno::Reference< drawing::XDrawPage > mxDrawPage; |
| uno::Reference< drawing::XDrawPagesSupplier > mxDrawPagesSupplier; |
| uno::Reference< animations::XAnimationNode > mxRootNode; |
| |
| LayerManagerSharedPtr mpLayerManager; |
| boost::shared_ptr<ShapeManagerImpl> mpShapeManager; |
| boost::shared_ptr<SubsettableShapeManager> mpSubsettableShapeManager; |
| |
| /// Contains common objects needed throughout the slideshow |
| SlideShowContext maContext; |
| |
| /// parent cursor manager |
| CursorManager& mrCursorManager; |
| |
| /// Handles the animation and event generation for us |
| SlideAnimations maAnimations; |
| PolyPolygonVector maPolygons; |
| |
| RGBColor maUserPaintColor; |
| double mdUserPaintStrokeWidth; |
| UserPaintOverlaySharedPtr mpPaintOverlay; |
| |
| /// Bitmaps with slide content at various states |
| mutable VectorOfVectorOfSlideBitmaps maSlideBitmaps; |
| |
| SlideAnimationState meAnimationState; |
| |
| const basegfx::B2ISize maSlideSize; |
| |
| sal_Int16 mnCurrentCursor; |
| |
| /// True, when intrinsic shape animations are allowed |
| bool mbIntrinsicAnimationsAllowed; |
| |
| /// True, when user paint overlay is enabled |
| bool mbUserPaintOverlayEnabled; |
| |
| /// True, if initial load of all page shapes succeeded |
| bool mbShapesLoaded; |
| |
| /// True, if initial load of all animation info succeeded |
| bool mbShowLoaded; |
| |
| /** True, if this slide is not static. |
| |
| If this slide has animated content, this variable will |
| be true, and false otherwise. |
| */ |
| bool mbHaveAnimations; |
| |
| /** True, if this slide has a main animation sequence. |
| |
| If this slide has animation content, which in turn has |
| a main animation sequence (which must be fully run |
| before EventMultiplexer::notifySlideAnimationsEnd() is |
| called), this member is true. |
| */ |
| bool mbMainSequenceFound; |
| |
| /// When true, show() was called. Slide hidden oherwise. |
| bool mbActive; |
| |
| ///When true, enablePaintOverlay was called and mbUserPaintOverlay = true |
| bool mbPaintOverlayActive; |
| }; |
| |
| |
| ////////////////////////////////////////////////////////////////////////////////// |
| |
| |
| class SlideRenderer |
| { |
| public: |
| explicit SlideRenderer( SlideImpl& rSlide ) : |
| mrSlide( rSlide ) |
| { |
| } |
| |
| void operator()( const UnoViewSharedPtr& rView ) |
| { |
| // fully clear view content to background color |
| rView->clearAll(); |
| |
| SlideBitmapSharedPtr pBitmap( mrSlide.getCurrentSlideBitmap( rView ) ); |
| ::cppcanvas::CanvasSharedPtr pCanvas( rView->getCanvas() ); |
| |
| const ::basegfx::B2DHomMatrix aViewTransform( rView->getTransformation() ); |
| const ::basegfx::B2DPoint aOutPosPixel( aViewTransform * ::basegfx::B2DPoint() ); |
| |
| // setup a canvas with device coordinate space, the slide |
| // bitmap already has the correct dimension. |
| ::cppcanvas::CanvasSharedPtr pDevicePixelCanvas( pCanvas->clone() ); |
| pDevicePixelCanvas->setTransformation( ::basegfx::B2DHomMatrix() ); |
| |
| // render at given output position |
| pBitmap->move( aOutPosPixel ); |
| |
| // clear clip (might have been changed, e.g. from comb |
| // transition) |
| pBitmap->clip( ::basegfx::B2DPolyPolygon() ); |
| pBitmap->draw( pDevicePixelCanvas ); |
| } |
| |
| private: |
| SlideImpl& mrSlide; |
| }; |
| |
| |
| ////////////////////////////////////////////////////////////////////////////////// |
| |
| |
| SlideImpl::SlideImpl( const uno::Reference< drawing::XDrawPage >& xDrawPage, |
| const uno::Reference<drawing::XDrawPagesSupplier>& xDrawPages, |
| const uno::Reference< animations::XAnimationNode >& xRootNode, |
| EventQueue& rEventQueue, |
| EventMultiplexer& rEventMultiplexer, |
| ScreenUpdater& rScreenUpdater, |
| ActivitiesQueue& rActivitiesQueue, |
| UserEventQueue& rUserEventQueue, |
| CursorManager& rCursorManager, |
| const UnoViewContainer& rViewContainer, |
| const uno::Reference< uno::XComponentContext >& xComponentContext, |
| const ShapeEventListenerMap& rShapeListenerMap, |
| const ShapeCursorMap& rShapeCursorMap, |
| const PolyPolygonVector& rPolyPolygonVector, |
| RGBColor const& aUserPaintColor, |
| double dUserPaintStrokeWidth, |
| bool bUserPaintEnabled, |
| bool bIntrinsicAnimationsAllowed, |
| bool bDisableAnimationZOrder ) : |
| mxDrawPage( xDrawPage ), |
| mxDrawPagesSupplier( xDrawPages ), |
| mxRootNode( xRootNode ), |
| mpLayerManager( new LayerManager( |
| rViewContainer, |
| getSlideRect(), |
| bDisableAnimationZOrder) ), |
| mpShapeManager( new ShapeManagerImpl( |
| rEventMultiplexer, |
| mpLayerManager, |
| rCursorManager, |
| rShapeListenerMap, |
| rShapeCursorMap)), |
| mpSubsettableShapeManager( mpShapeManager ), |
| maContext( mpSubsettableShapeManager, |
| rEventQueue, |
| rEventMultiplexer, |
| rScreenUpdater, |
| rActivitiesQueue, |
| rUserEventQueue, |
| *this, |
| rViewContainer, |
| xComponentContext ), |
| mrCursorManager( rCursorManager ), |
| maAnimations( maContext, |
| getSlideSizeImpl() ), |
| maPolygons(rPolyPolygonVector), |
| maUserPaintColor(aUserPaintColor), |
| mdUserPaintStrokeWidth(dUserPaintStrokeWidth), |
| mpPaintOverlay(), |
| maSlideBitmaps(), |
| meAnimationState( CONSTRUCTING_STATE ), |
| maSlideSize(getSlideSizeImpl()), |
| mnCurrentCursor( awt::SystemPointer::ARROW ), |
| mbIntrinsicAnimationsAllowed( bIntrinsicAnimationsAllowed ), |
| mbUserPaintOverlayEnabled(bUserPaintEnabled), |
| mbShapesLoaded( false ), |
| mbShowLoaded( false ), |
| mbHaveAnimations( false ), |
| mbMainSequenceFound( false ), |
| mbActive( false ), |
| mbPaintOverlayActive( false ) |
| { |
| // clone already existing views for slide bitmaps |
| std::for_each( rViewContainer.begin(), |
| rViewContainer.end(), |
| boost::bind( &SlideImpl::viewAdded, |
| this, |
| _1 )); |
| |
| // register screen update (LayerManager needs to signal pending |
| // updates) |
| maContext.mrScreenUpdater.addViewUpdate(mpShapeManager); |
| } |
| |
| void SlideImpl::update_settings( bool bUserPaintEnabled, RGBColor const& aUserPaintColor, double dUserPaintStrokeWidth ) |
| { |
| maUserPaintColor = aUserPaintColor; |
| mdUserPaintStrokeWidth = dUserPaintStrokeWidth; |
| mbUserPaintOverlayEnabled = bUserPaintEnabled; |
| } |
| |
| SlideImpl::~SlideImpl() |
| { |
| if( mpShapeManager ) |
| { |
| maContext.mrScreenUpdater.removeViewUpdate(mpShapeManager); |
| mpShapeManager->dispose(); |
| |
| // TODO(Q3): Make sure LayerManager (and thus Shapes) dies |
| // first, because SlideShowContext has SubsettableShapeManager |
| // as reference member. |
| mpLayerManager.reset(); |
| } |
| } |
| |
| void SlideImpl::dispose() |
| { |
| maSlideBitmaps.clear(); |
| mpPaintOverlay.reset(); |
| maAnimations.dispose(); |
| maContext.dispose(); |
| |
| if( mpShapeManager ) |
| { |
| maContext.mrScreenUpdater.removeViewUpdate(mpShapeManager); |
| mpShapeManager->dispose(); |
| } |
| |
| // TODO(Q3): Make sure LayerManager (and thus Shapes) dies first, |
| // because SlideShowContext has SubsettableShapeManager as |
| // reference member. |
| mpLayerManager.reset(); |
| mpSubsettableShapeManager.reset(); |
| mpShapeManager.reset(); |
| mxRootNode.clear(); |
| mxDrawPage.clear(); |
| mxDrawPagesSupplier.clear(); |
| } |
| |
| bool SlideImpl::prefetch() |
| { |
| if( !mxRootNode.is() ) |
| return false; |
| |
| return applyInitialShapeAttributes(mxRootNode); |
| } |
| |
| bool SlideImpl::show( bool bSlideBackgoundPainted ) |
| { |
| // --------------------------------------------------------------- |
| |
| if( mbActive ) |
| return true; // already active |
| |
| if( !mpShapeManager || !mpLayerManager ) |
| return false; // disposed |
| |
| // --------------------------------------------------------------- |
| |
| // set initial shape attributes (e.g. hide shapes that have |
| // 'appear' effect set) |
| if( !applyInitialShapeAttributes(mxRootNode) ) |
| return false; |
| |
| // --------------------------------------------------------------- |
| |
| // activate and take over view - clears view, if necessary |
| mbActive = true; |
| requestCursor( mnCurrentCursor ); |
| |
| // enable shape management & event broadcasting for shapes of this |
| // slide. Also enables LayerManager to record updates. Currently, |
| // never let LayerManager render initial slide content, use |
| // buffered slide bitmaps instead. |
| mpShapeManager->activate( true ); |
| |
| // --------------------------------------------------------------- |
| |
| // render slide to screen, if requested |
| if( !bSlideBackgoundPainted ) |
| { |
| std::for_each(maContext.mrViewContainer.begin(), |
| maContext.mrViewContainer.end(), |
| boost::mem_fn(&View::clearAll)); |
| |
| std::for_each( maContext.mrViewContainer.begin(), |
| maContext.mrViewContainer.end(), |
| SlideRenderer(*this) ); |
| maContext.mrScreenUpdater.notifyUpdate(); |
| } |
| |
| // --------------------------------------------------------------- |
| |
| // fire up animations |
| const bool bIsAnimated( isAnimated() ); |
| if( bIsAnimated ) |
| maAnimations.start(); // feeds initial events into queue |
| |
| // NOTE: this looks slightly weird, but is indeed correct: |
| // as isAnimated() might return false, _although_ there is |
| // a main sequence (because the animation nodes don't |
| // contain any executable effects), we gotta check both |
| // conditions here. |
| if( !bIsAnimated || !mbMainSequenceFound ) |
| { |
| // manually trigger a slide animation end event (we don't have |
| // animations at all, or we don't have a main animation |
| // sequence, but if we had, it'd end now). Note that having |
| // animations alone does not matter here, as only main |
| // sequence animations prevents showing the next slide on |
| // nextEvent(). |
| maContext.mrEventMultiplexer.notifySlideAnimationsEnd(); |
| } |
| |
| // enable shape-intrinsic animations (drawing layer animations or |
| // GIF animations) |
| if( mbIntrinsicAnimationsAllowed ) |
| startIntrinsicAnimations(); |
| |
| // --------------------------------------------------------------- |
| |
| // enable paint overlay, if maUserPaintColor is valid |
| activatePaintOverlay(); |
| |
| // --------------------------------------------------------------- |
| |
| // from now on, animations might be showing |
| meAnimationState = SHOWING_STATE; |
| |
| return true; |
| } |
| |
| void SlideImpl::hide() |
| { |
| if( !mbActive || !mpShapeManager ) |
| return; // already hidden/disposed |
| |
| // --------------------------------------------------------------- |
| |
| // from now on, all animations are stopped |
| meAnimationState = FINAL_STATE; |
| |
| // --------------------------------------------------------------- |
| |
| // disable user paint overlay under all circumstances, |
| // this slide now ceases to be active. |
| deactivatePaintOverlay(); |
| |
| // --------------------------------------------------------------- |
| |
| // switch off all shape-intrinsic animations. |
| endIntrinsicAnimations(); |
| |
| // force-end all SMIL animations, too |
| maAnimations.end(); |
| |
| // --------------------------------------------------------------- |
| |
| // disable shape management & event broadcasting for shapes of this |
| // slide. Also disables LayerManager. |
| mpShapeManager->deactivate(); |
| |
| // vanish from view |
| resetCursor(); |
| mbActive = false; |
| |
| // --------------------------------------------------------------- |
| } |
| |
| basegfx::B2ISize SlideImpl::getSlideSize() const |
| { |
| return maSlideSize; |
| } |
| |
| uno::Reference<drawing::XDrawPage > SlideImpl::getXDrawPage() const |
| { |
| return mxDrawPage; |
| } |
| |
| uno::Reference<animations::XAnimationNode> SlideImpl::getXAnimationNode() const |
| { |
| return mxRootNode; |
| } |
| |
| PolyPolygonVector SlideImpl::getPolygons() |
| { |
| if(mbPaintOverlayActive) |
| maPolygons = mpPaintOverlay->getPolygons(); |
| return maPolygons; |
| } |
| |
| SlideBitmapSharedPtr SlideImpl::getCurrentSlideBitmap( const UnoViewSharedPtr& rView ) const |
| { |
| // search corresponding entry in maSlideBitmaps (which |
| // contains the views as the key) |
| VectorOfVectorOfSlideBitmaps::iterator aIter; |
| const VectorOfVectorOfSlideBitmaps::iterator aEnd( maSlideBitmaps.end() ); |
| if( (aIter=std::find_if( maSlideBitmaps.begin(), |
| aEnd, |
| boost::bind( |
| std::equal_to<UnoViewSharedPtr>(), |
| rView, |
| // select view: |
| boost::bind( |
| std::select1st<VectorOfVectorOfSlideBitmaps::value_type>(), |
| _1 )))) == aEnd ) |
| { |
| // corresponding view not found - maybe view was not |
| // added to Slide? |
| ENSURE_OR_THROW( false, |
| "SlideImpl::getInitialSlideBitmap(): view does not " |
| "match any of the added ones" ); |
| } |
| |
| // ensure that the show is loaded |
| if( !mbShowLoaded ) |
| { |
| // only prefetch and init shapes when not done already |
| // (otherwise, at least applyInitialShapeAttributes() will be |
| // called twice for initial slide rendering). Furthermore, |
| // applyInitialShapeAttributes() _always_ performs |
| // initializations, which would be highly unwanted during a |
| // running show. OTOH, a slide whose mbShowLoaded is false is |
| // guaranteed not be running a show. |
| |
| // set initial shape attributes (e.g. hide 'appear' effect |
| // shapes) |
| if( !const_cast<SlideImpl*>(this)->applyInitialShapeAttributes( mxRootNode ) ) |
| ENSURE_OR_THROW(false, |
| "SlideImpl::getCurrentSlideBitmap(): Cannot " |
| "apply initial attributes"); |
| } |
| |
| SlideBitmapSharedPtr& rBitmap( aIter->second.at( meAnimationState )); |
| const ::basegfx::B2ISize& rSlideSize( |
| getSlideSizePixel( getSlideSize(), |
| rView )); |
| |
| // is the bitmap valid (actually existent, and of correct |
| // size)? |
| if( !rBitmap || rBitmap->getSize() != rSlideSize ) |
| { |
| // no bitmap there yet, or wrong size - create one |
| rBitmap = createCurrentSlideBitmap(rView, rSlideSize); |
| } |
| |
| return rBitmap; |
| } |
| |
| |
| // private methods |
| //-------------------------------------------------------------------------------------------------------------- |
| |
| |
| void SlideImpl::viewAdded( const UnoViewSharedPtr& rView ) |
| { |
| maSlideBitmaps.push_back( |
| std::make_pair( rView, |
| VectorOfSlideBitmaps(SlideAnimationState_NUM_ENTRIES) )); |
| |
| if( mpLayerManager ) |
| mpLayerManager->viewAdded( rView ); |
| } |
| |
| void SlideImpl::viewRemoved( const UnoViewSharedPtr& rView ) |
| { |
| if( mpLayerManager ) |
| mpLayerManager->viewRemoved( rView ); |
| |
| const VectorOfVectorOfSlideBitmaps::iterator aEnd( maSlideBitmaps.end() ); |
| maSlideBitmaps.erase( |
| std::remove_if( maSlideBitmaps.begin(), |
| aEnd, |
| boost::bind( |
| std::equal_to<UnoViewSharedPtr>(), |
| rView, |
| // select view: |
| boost::bind( |
| std::select1st<VectorOfVectorOfSlideBitmaps::value_type>(), |
| _1 ))), |
| aEnd ); |
| } |
| |
| void SlideImpl::viewChanged( const UnoViewSharedPtr& rView ) |
| { |
| // nothing to do for the Slide - getCurrentSlideBitmap() lazily |
| // handles bitmap resizes |
| if( mbActive && mpLayerManager ) |
| mpLayerManager->viewChanged(rView); |
| } |
| |
| void SlideImpl::viewsChanged() |
| { |
| // nothing to do for the Slide - getCurrentSlideBitmap() lazily |
| // handles bitmap resizes |
| if( mbActive && mpLayerManager ) |
| mpLayerManager->viewsChanged(); |
| } |
| |
| bool SlideImpl::requestCursor( sal_Int16 nCursorShape ) |
| { |
| mnCurrentCursor = nCursorShape; |
| return mrCursorManager.requestCursor(mnCurrentCursor); |
| } |
| |
| void SlideImpl::resetCursor() |
| { |
| mnCurrentCursor = awt::SystemPointer::ARROW; |
| mrCursorManager.resetCursor(); |
| } |
| |
| bool SlideImpl::isShowing() const |
| { |
| return meAnimationState == SHOWING_STATE; |
| } |
| |
| bool SlideImpl::isAnimated() |
| { |
| // prefetch, but don't apply initial shape attributes |
| if( !implPrefetchShow() ) |
| return false; |
| |
| return mbHaveAnimations && maAnimations.isAnimated(); |
| } |
| |
| SlideBitmapSharedPtr SlideImpl::createCurrentSlideBitmap( const UnoViewSharedPtr& rView, |
| const ::basegfx::B2ISize& rBmpSize ) const |
| { |
| ENSURE_OR_THROW( rView && rView->getCanvas(), |
| "SlideImpl::createCurrentSlideBitmap(): Invalid view" ); |
| ENSURE_OR_THROW( mpLayerManager, |
| "SlideImpl::createCurrentSlideBitmap(): Invalid layer manager" ); |
| ENSURE_OR_THROW( mbShowLoaded, |
| "SlideImpl::createCurrentSlideBitmap(): No show loaded" ); |
| |
| ::cppcanvas::CanvasSharedPtr pCanvas( rView->getCanvas() ); |
| |
| // create a bitmap of appropriate size |
| ::cppcanvas::BitmapSharedPtr pBitmap( |
| ::cppcanvas::BaseGfxFactory::getInstance().createBitmap( |
| pCanvas, |
| rBmpSize ) ); |
| |
| ENSURE_OR_THROW( pBitmap, |
| "SlideImpl::createCurrentSlideBitmap(): Cannot create page bitmap" ); |
| |
| ::cppcanvas::BitmapCanvasSharedPtr pBitmapCanvas( pBitmap->getBitmapCanvas() ); |
| |
| ENSURE_OR_THROW( pBitmapCanvas, |
| "SlideImpl::createCurrentSlideBitmap(): Cannot create page bitmap canvas" ); |
| |
| // apply linear part of destination canvas transformation (linear means in this context: |
| // transformation without any translational components) |
| ::basegfx::B2DHomMatrix aLinearTransform( rView->getTransformation() ); |
| aLinearTransform.set( 0, 2, 0.0 ); |
| aLinearTransform.set( 1, 2, 0.0 ); |
| pBitmapCanvas->setTransformation( aLinearTransform ); |
| |
| // output all shapes to bitmap |
| initSlideBackground( pBitmapCanvas, rBmpSize ); |
| mpLayerManager->renderTo( pBitmapCanvas ); |
| |
| return SlideBitmapSharedPtr( new SlideBitmap( pBitmap ) ); |
| } |
| |
| namespace |
| { |
| class MainSequenceSearcher |
| { |
| public: |
| MainSequenceSearcher() |
| { |
| maSearchKey.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "node-type" ) ); |
| maSearchKey.Value <<= presentation::EffectNodeType::MAIN_SEQUENCE; |
| } |
| |
| void operator()( const uno::Reference< animations::XAnimationNode >& xChildNode ) |
| { |
| uno::Sequence< beans::NamedValue > aUserData( xChildNode->getUserData() ); |
| |
| if( findNamedValue( aUserData, maSearchKey ) ) |
| { |
| maMainSequence = xChildNode; |
| } |
| } |
| |
| uno::Reference< animations::XAnimationNode > getMainSequence() const |
| { |
| return maMainSequence; |
| } |
| |
| private: |
| beans::NamedValue maSearchKey; |
| uno::Reference< animations::XAnimationNode > maMainSequence; |
| }; |
| } |
| |
| bool SlideImpl::implPrefetchShow() |
| { |
| if( mbShowLoaded ) |
| return true; |
| |
| ENSURE_OR_RETURN_FALSE( mxDrawPage.is(), |
| "SlideImpl::implPrefetchShow(): Invalid draw page" ); |
| ENSURE_OR_RETURN_FALSE( mpLayerManager, |
| "SlideImpl::implPrefetchShow(): Invalid layer manager" ); |
| |
| // fetch desired page content |
| // ========================== |
| |
| if( !loadShapes() ) |
| return false; |
| |
| // New animations framework: import the shape effect info |
| // ====================================================== |
| |
| try |
| { |
| if( mxRootNode.is() ) |
| { |
| if( !maAnimations.importAnimations( mxRootNode ) ) |
| { |
| OSL_ENSURE( false, |
| "SlideImpl::implPrefetchShow(): have animation nodes, " |
| "but import animations failed." ); |
| |
| // could not import animation framework, |
| // _although_ some animation nodes are there - |
| // this is an error (not finding animations at |
| // all is okay - might be a static slide) |
| return false; |
| } |
| |
| // now check whether we've got a main sequence (if |
| // not, we must manually call |
| // EventMultiplexer::notifySlideAnimationsEnd() |
| // above, as e.g. interactive sequences alone |
| // don't block nextEvent() from issuing the next |
| // slide) |
| MainSequenceSearcher aSearcher; |
| if( ::anim::for_each_childNode( mxRootNode, aSearcher ) ) |
| mbMainSequenceFound = aSearcher.getMainSequence().is(); |
| |
| // import successfully done |
| mbHaveAnimations = true; |
| } |
| } |
| catch( uno::RuntimeException& ) |
| { |
| throw; |
| } |
| catch( uno::Exception& ) |
| { |
| OSL_ENSURE( |
| false, |
| rtl::OUStringToOString( |
| comphelper::anyToString(cppu::getCaughtException()), |
| RTL_TEXTENCODING_UTF8 ) ); |
| // TODO(E2): Error handling. For now, bail out |
| } |
| |
| mbShowLoaded = true; |
| |
| return true; |
| } |
| |
| void SlideImpl::enablePaintOverlay() |
| { |
| if( !mbUserPaintOverlayEnabled || !mbPaintOverlayActive ) |
| { |
| mbUserPaintOverlayEnabled = true; |
| activatePaintOverlay(); |
| } |
| } |
| |
| void SlideImpl::disablePaintOverlay() |
| { |
| } |
| |
| void SlideImpl::activatePaintOverlay() |
| { |
| if( mbUserPaintOverlayEnabled || !maPolygons.empty() ) |
| { |
| mpPaintOverlay = UserPaintOverlay::create( maUserPaintColor, |
| mdUserPaintStrokeWidth, |
| maContext, |
| maPolygons, |
| mbUserPaintOverlayEnabled ); |
| mbPaintOverlayActive = true; |
| } |
| } |
| |
| void SlideImpl::drawPolygons() const |
| { |
| if( mpPaintOverlay ) |
| mpPaintOverlay->drawPolygons(); |
| } |
| |
| void SlideImpl::addPolygons(PolyPolygonVector aPolygons) |
| { |
| if(!aPolygons.empty()) |
| { |
| for( PolyPolygonVector::iterator aIter=aPolygons.begin(), |
| aEnd=aPolygons.end(); |
| aIter!=aEnd; |
| ++aIter ) |
| { |
| maPolygons.push_back(*aIter); |
| } |
| } |
| } |
| |
| bool SlideImpl::isPaintOverlayActive() const |
| { |
| return mbPaintOverlayActive; |
| } |
| |
| void SlideImpl::deactivatePaintOverlay() |
| { |
| if(mbPaintOverlayActive) |
| maPolygons = mpPaintOverlay->getPolygons(); |
| |
| mpPaintOverlay.reset(); |
| mbPaintOverlayActive = false; |
| } |
| |
| ::basegfx::B2DRectangle SlideImpl::getSlideRect() const |
| { |
| const basegfx::B2ISize slideSize( getSlideSizeImpl() ); |
| return ::basegfx::B2DRectangle(0.0,0.0, |
| slideSize.getX(), |
| slideSize.getY()); |
| } |
| |
| void SlideImpl::endIntrinsicAnimations() |
| { |
| mpSubsettableShapeManager->notifyIntrinsicAnimationsDisabled(); |
| } |
| |
| void SlideImpl::startIntrinsicAnimations() |
| { |
| mpSubsettableShapeManager->notifyIntrinsicAnimationsEnabled(); |
| } |
| |
| bool SlideImpl::applyInitialShapeAttributes( |
| const uno::Reference< animations::XAnimationNode >& xRootAnimationNode ) |
| { |
| if( !implPrefetchShow() ) |
| return false; |
| |
| if( !xRootAnimationNode.is() ) |
| { |
| meAnimationState = INITIAL_STATE; |
| |
| return true; // no animations - no attributes to apply - |
| // succeeded |
| } |
| |
| uno::Reference< animations::XTargetPropertiesCreator > xPropsCreator; |
| |
| try |
| { |
| ENSURE_OR_RETURN_FALSE( maContext.mxComponentContext.is(), |
| "SlideImpl::applyInitialShapeAttributes(): Invalid component context" ); |
| |
| uno::Reference<lang::XMultiComponentFactory> xFac( |
| maContext.mxComponentContext->getServiceManager() ); |
| |
| xPropsCreator.set( |
| xFac->createInstanceWithContext( |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( |
| "com.sun.star.animations.TargetPropertiesCreator") ), |
| maContext.mxComponentContext ), |
| uno::UNO_QUERY_THROW ); |
| } |
| catch( uno::RuntimeException& ) |
| { |
| throw; |
| } |
| catch( uno::Exception& ) |
| { |
| OSL_ENSURE( |
| false, |
| rtl::OUStringToOString( |
| comphelper::anyToString(cppu::getCaughtException()), |
| RTL_TEXTENCODING_UTF8 ) ); |
| |
| // could not determine initial shape attributes - this |
| // is an error, as some effects might then be plainly |
| // invisible |
| ENSURE_OR_RETURN_FALSE( false, |
| "SlideImpl::applyInitialShapeAttributes(): " |
| "couldn't create TargetPropertiesCreator." ); |
| } |
| |
| uno::Sequence< animations::TargetProperties > aProps( |
| xPropsCreator->createInitialTargetProperties( xRootAnimationNode ) ); |
| |
| // apply extracted values to our shapes |
| const ::std::size_t nSize( aProps.getLength() ); |
| for( ::std::size_t i=0; i<nSize; ++i ) |
| { |
| sal_Int16 nParaIndex( -1 ); |
| uno::Reference< drawing::XShape > xShape( aProps[i].Target, |
| uno::UNO_QUERY ); |
| |
| if( !xShape.is() ) |
| { |
| // not a shape target. Maybe a ParagraphTarget? |
| presentation::ParagraphTarget aParaTarget; |
| |
| if( (aProps[i].Target >>= aParaTarget) ) |
| { |
| // yep, ParagraphTarget found - extract shape |
| // and index |
| xShape = aParaTarget.Shape; |
| nParaIndex = aParaTarget.Paragraph; |
| } |
| } |
| |
| if( xShape.is() ) |
| { |
| ShapeSharedPtr pShape( mpLayerManager->lookupShape( xShape ) ); |
| |
| if( !pShape ) |
| { |
| OSL_ENSURE( false, |
| "SlideImpl::applyInitialShapeAttributes(): no shape found for given target" ); |
| continue; |
| } |
| |
| AttributableShapeSharedPtr pAttrShape( |
| ::boost::dynamic_pointer_cast< AttributableShape >( pShape ) ); |
| |
| if( !pAttrShape ) |
| { |
| OSL_ENSURE( false, |
| "SlideImpl::applyInitialShapeAttributes(): shape found does not " |
| "implement AttributableShape interface" ); |
| continue; |
| } |
| |
| if( nParaIndex != -1 ) |
| { |
| // our target is a paragraph subset, thus look |
| // this up first. |
| const DocTreeNodeSupplier& rNodeSupplier( pAttrShape->getTreeNodeSupplier() ); |
| |
| pAttrShape = pAttrShape->getSubset( |
| rNodeSupplier.getTreeNode( |
| nParaIndex, |
| DocTreeNode::NODETYPE_LOGICAL_PARAGRAPH ) ); |
| |
| if( !pAttrShape ) |
| { |
| OSL_ENSURE( false, |
| "SlideImpl::applyInitialShapeAttributes(): shape found does not " |
| "provide a subset for requested paragraph index" ); |
| continue; |
| } |
| } |
| |
| const uno::Sequence< beans::NamedValue >& rShapeProps( aProps[i].Properties ); |
| const ::std::size_t nShapePropSize( rShapeProps.getLength() ); |
| for( ::std::size_t j=0; j<nShapePropSize; ++j ) |
| { |
| bool bVisible=false; |
| if( rShapeProps[j].Name.equalsIgnoreAsciiCaseAscii("visibility") && |
| extractValue( bVisible, |
| rShapeProps[j].Value, |
| pShape, |
| getSlideSize() )) |
| { |
| pAttrShape->setVisibility( bVisible ); |
| } |
| else |
| { |
| OSL_ENSURE( false, |
| "SlideImpl::applyInitialShapeAttributes(): Unexpected " |
| "(and unimplemented) property encountered" ); |
| } |
| } |
| } |
| } |
| |
| meAnimationState = INITIAL_STATE; |
| |
| return true; |
| } |
| |
| bool SlideImpl::loadShapes() |
| { |
| if( mbShapesLoaded ) |
| return true; |
| |
| ENSURE_OR_RETURN_FALSE( mxDrawPage.is(), |
| "SlideImpl::loadShapes(): Invalid draw page" ); |
| ENSURE_OR_RETURN_FALSE( mpLayerManager, |
| "SlideImpl::loadShapes(): Invalid layer manager" ); |
| |
| // fetch desired page content |
| // ========================== |
| |
| // also take master page content |
| uno::Reference< drawing::XDrawPage > xMasterPage; |
| uno::Reference< drawing::XShapes > xMasterPageShapes; |
| sal_Int32 nCurrCount(0); |
| |
| uno::Reference< drawing::XMasterPageTarget > xMasterPageTarget( mxDrawPage, |
| uno::UNO_QUERY ); |
| if( xMasterPageTarget.is() ) |
| { |
| xMasterPage = xMasterPageTarget->getMasterPage(); |
| xMasterPageShapes.set( xMasterPage, |
| uno::UNO_QUERY ); |
| |
| if( xMasterPage.is() && xMasterPageShapes.is() ) |
| { |
| // TODO(P2): maybe cache master pages here (or treat the |
| // masterpage as a single metafile. At least currently, |
| // masterpages do not contain animation effects) |
| try |
| { |
| // load the masterpage shapes |
| // ------------------------------------------------------------------------- |
| ShapeImporter aMPShapesFunctor( xMasterPage, |
| mxDrawPage, |
| mxDrawPagesSupplier, |
| maContext, |
| 0, /* shape num starts at 0 */ |
| true ); |
| |
| mpLayerManager->addShape( |
| aMPShapesFunctor.importBackgroundShape() ); |
| |
| while( !aMPShapesFunctor.isImportDone() ) |
| { |
| ShapeSharedPtr const& rShape( |
| aMPShapesFunctor.importShape() ); |
| if( rShape ) |
| mpLayerManager->addShape( rShape ); |
| } |
| addPolygons(aMPShapesFunctor.getPolygons()); |
| |
| nCurrCount = xMasterPageShapes->getCount() + 1; |
| } |
| catch( uno::RuntimeException& ) |
| { |
| throw; |
| } |
| catch( ShapeLoadFailedException& ) |
| { |
| // TODO(E2): Error handling. For now, bail out |
| OSL_ENSURE( false, |
| "SlideImpl::loadShapes(): caught ShapeLoadFailedException" ); |
| return false; |
| |
| } |
| catch( uno::Exception& ) |
| { |
| OSL_ENSURE( false, |
| rtl::OUStringToOString( |
| comphelper::anyToString( cppu::getCaughtException() ), |
| RTL_TEXTENCODING_UTF8 ).getStr() ); |
| |
| return false; |
| } |
| } |
| } |
| |
| try |
| { |
| // load the normal page shapes |
| // ------------------------------------------------------------------------- |
| |
| ShapeImporter aShapesFunctor( mxDrawPage, |
| mxDrawPage, |
| mxDrawPagesSupplier, |
| maContext, |
| nCurrCount, |
| false ); |
| |
| while( !aShapesFunctor.isImportDone() ) |
| { |
| ShapeSharedPtr const& rShape( |
| aShapesFunctor.importShape() ); |
| if( rShape ) |
| mpLayerManager->addShape( rShape ); |
| } |
| addPolygons(aShapesFunctor.getPolygons()); |
| } |
| catch( uno::RuntimeException& ) |
| { |
| throw; |
| } |
| catch( ShapeLoadFailedException& ) |
| { |
| // TODO(E2): Error handling. For now, bail out |
| OSL_ENSURE( false, |
| "SlideImpl::loadShapes(): caught ShapeLoadFailedException" ); |
| return false; |
| } |
| catch( uno::Exception& ) |
| { |
| OSL_ENSURE( false, |
| rtl::OUStringToOString( |
| comphelper::anyToString( cppu::getCaughtException() ), |
| RTL_TEXTENCODING_UTF8 ).getStr() ); |
| |
| return false; |
| } |
| |
| mbShapesLoaded = true; |
| |
| return true; |
| } |
| |
| basegfx::B2ISize SlideImpl::getSlideSizeImpl() const |
| { |
| uno::Reference< beans::XPropertySet > xPropSet( |
| mxDrawPage, uno::UNO_QUERY_THROW ); |
| |
| sal_Int32 nDocWidth = 0; |
| sal_Int32 nDocHeight = 0; |
| xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Width") ) ) >>= nDocWidth; |
| xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Height") ) ) >>= nDocHeight; |
| |
| return basegfx::B2ISize( nDocWidth, nDocHeight ); |
| } |
| |
| } // namespace |
| |
| |
| SlideSharedPtr createSlide( const uno::Reference< drawing::XDrawPage >& xDrawPage, |
| const uno::Reference<drawing::XDrawPagesSupplier>& xDrawPages, |
| const uno::Reference< animations::XAnimationNode >& xRootNode, |
| EventQueue& rEventQueue, |
| EventMultiplexer& rEventMultiplexer, |
| ScreenUpdater& rScreenUpdater, |
| ActivitiesQueue& rActivitiesQueue, |
| UserEventQueue& rUserEventQueue, |
| CursorManager& rCursorManager, |
| const UnoViewContainer& rViewContainer, |
| const uno::Reference< uno::XComponentContext >& xComponentContext, |
| const ShapeEventListenerMap& rShapeListenerMap, |
| const ShapeCursorMap& rShapeCursorMap, |
| const PolyPolygonVector& rPolyPolygonVector, |
| RGBColor const& rUserPaintColor, |
| double dUserPaintStrokeWidth, |
| bool bUserPaintEnabled, |
| bool bIntrinsicAnimationsAllowed, |
| bool bDisableAnimationZOrder ) |
| { |
| boost::shared_ptr<SlideImpl> pRet( new SlideImpl( xDrawPage, xDrawPages, xRootNode, rEventQueue, |
| rEventMultiplexer, rScreenUpdater, |
| rActivitiesQueue, rUserEventQueue, |
| rCursorManager, rViewContainer, |
| xComponentContext, rShapeListenerMap, |
| rShapeCursorMap, rPolyPolygonVector, rUserPaintColor, |
| dUserPaintStrokeWidth, bUserPaintEnabled, |
| bIntrinsicAnimationsAllowed, |
| bDisableAnimationZOrder )); |
| |
| rEventMultiplexer.addViewHandler( pRet ); |
| |
| return pRet; |
| } |
| |
| } // namespace internal |
| } // namespace slideshow |
