| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| |
| #include "precompiled_slideshow.hxx" |
| |
| #include "effectrewinder.hxx" |
| #include "eventqueue.hxx" |
| #include "usereventqueue.hxx" |
| #include "mouseeventhandler.hxx" |
| #include "animationnodes/basecontainernode.hxx" |
| #include "delayevent.hxx" |
| |
| #include <com/sun/star/awt/MouseEvent.hpp> |
| #include <com/sun/star/animations/Event.hpp> |
| #include <com/sun/star/animations/EventTrigger.hpp> |
| #include <com/sun/star/container/XEnumerationAccess.hpp> |
| #include <boost/function.hpp> |
| #include <boost/bind.hpp> |
| #include <boost/enable_shared_from_this.hpp> |
| |
| using ::com::sun::star::uno::Reference; |
| using namespace ::com::sun::star; |
| |
| namespace slideshow { namespace internal { |
| |
| |
| namespace { |
| |
| class RewinderEventHandler : public EventHandler |
| { |
| public: |
| typedef ::boost::function<bool(void)> Action; |
| RewinderEventHandler (const Action& rAction) : maAction(rAction) {} |
| virtual ~RewinderEventHandler (void) {} |
| private: |
| const Action maAction; |
| virtual bool handleEvent (void) { return maAction(); } |
| }; |
| |
| |
| |
| class RewinderAnimationEventHandler : public AnimationEventHandler |
| { |
| public: |
| typedef ::boost::function<bool(const AnimationNodeSharedPtr& rpNode)> Action; |
| RewinderAnimationEventHandler (const Action& rAction) : maAction(rAction) {} |
| virtual ~RewinderAnimationEventHandler (void) {} |
| private: |
| const Action maAction; |
| virtual bool handleAnimationEvent (const AnimationNodeSharedPtr& rpNode) |
| { return maAction(rpNode); } |
| }; |
| |
| |
| |
| } // end of anonymous namespace |
| |
| |
| //----- EffectRewinder -------------------------------------------------------------- |
| |
| EffectRewinder::EffectRewinder ( |
| EventMultiplexer& rEventMultiplexer, |
| EventQueue& rEventQueue, |
| UserEventQueue& rUserEventQueue) |
| : mrEventMultiplexer(rEventMultiplexer), |
| mrEventQueue(rEventQueue), |
| mrUserEventQueue(rUserEventQueue), |
| mpSlideStartHandler(), |
| mpSlideEndHandler(), |
| mpAnimationStartHandler(), |
| mnMainSequenceEffectCount(0), |
| mpAsynchronousRewindEvent(), |
| mxCurrentAnimationRootNode(), |
| mbNonUserTriggeredMainSequenceEffectSeen(false) |
| { |
| initialize(); |
| } |
| |
| |
| |
| |
| void EffectRewinder::initialize (void) |
| { |
| // Add some event handlers so that we are informed when |
| // a) an animation is started (we then check whether that belongs to a |
| // main sequence effect and if so, increase the respective counter), |
| // b,c) a slide was started or ended (in which case the effect counter |
| // is reset. |
| |
| mpAnimationStartHandler.reset( |
| new RewinderAnimationEventHandler( |
| ::boost::bind(&EffectRewinder::notifyAnimationStart, this, _1))); |
| mrEventMultiplexer.addAnimationStartHandler(mpAnimationStartHandler); |
| |
| mpSlideStartHandler.reset( |
| new RewinderEventHandler( |
| ::boost::bind(&EffectRewinder::resetEffectCount, this))); |
| mrEventMultiplexer.addSlideStartHandler(mpSlideStartHandler); |
| |
| mpSlideEndHandler.reset( |
| new RewinderEventHandler( |
| ::boost::bind(&EffectRewinder::resetEffectCount, this))); |
| mrEventMultiplexer.addSlideEndHandler(mpSlideEndHandler); |
| } |
| |
| |
| |
| |
| EffectRewinder::~EffectRewinder (void) |
| { |
| dispose(); |
| } |
| |
| |
| |
| |
| void EffectRewinder::dispose (void) |
| { |
| if (mpAsynchronousRewindEvent) |
| { |
| mpAsynchronousRewindEvent->dispose(); |
| mpAsynchronousRewindEvent.reset(); |
| } |
| |
| if (mpAnimationStartHandler) |
| { |
| mrEventMultiplexer.removeAnimationStartHandler(mpAnimationStartHandler); |
| mpAnimationStartHandler.reset(); |
| } |
| |
| if (mpSlideStartHandler) |
| { |
| mrEventMultiplexer.removeSlideStartHandler(mpSlideStartHandler); |
| mpSlideStartHandler.reset(); |
| } |
| |
| if (mpSlideEndHandler) |
| { |
| mrEventMultiplexer.removeSlideEndHandler(mpSlideEndHandler); |
| mpSlideEndHandler.reset(); |
| } |
| } |
| |
| |
| |
| |
| void EffectRewinder::setRootAnimationNode ( |
| const uno::Reference<animations::XAnimationNode>& xRootNode) |
| { |
| mxCurrentAnimationRootNode = xRootNode; |
| } |
| |
| |
| |
| |
| bool EffectRewinder::rewind ( |
| const ::boost::shared_ptr<ScreenUpdater::UpdateLock>& rpPaintLock, |
| const ::boost::function<void(void)>& rSlideRewindFunctor, |
| const ::boost::function<void(void)>& rPreviousSlideFunctor) |
| { |
| mpPaintLock = rpPaintLock; |
| |
| // Do not allow nested rewinds. |
| if (mpAsynchronousRewindEvent) |
| { |
| OSL_ASSERT( ! mpAsynchronousRewindEvent); |
| return false; |
| } |
| |
| // Abort (and skip over the rest of) any currently active animation. |
| mrUserEventQueue.callSkipEffectEventHandler(); |
| mrEventQueue.forceEmpty(); |
| |
| const int nSkipCount (mnMainSequenceEffectCount - 1); |
| if (nSkipCount < 0) |
| { |
| if ( ! rPreviousSlideFunctor) |
| { |
| OSL_ASSERT(rPreviousSlideFunctor); |
| return false; |
| } |
| |
| // No main sequence effects to rewind on the current slide. |
| // Go back to the previous slide. |
| mpAsynchronousRewindEvent = makeEvent( |
| ::boost::bind( |
| &EffectRewinder::asynchronousRewindToPreviousSlide, |
| this, |
| rPreviousSlideFunctor), |
| "EffectRewinder::asynchronousRewindToPreviousSlide"); |
| } |
| else |
| { |
| // The actual rewinding is done asynchronously so that we can safely |
| // call other methods. |
| mpAsynchronousRewindEvent = makeEvent( |
| ::boost::bind( |
| &EffectRewinder::asynchronousRewind, |
| this, |
| nSkipCount, |
| true, |
| rSlideRewindFunctor), |
| "EffectRewinder::asynchronousRewind"); |
| } |
| |
| if (mpAsynchronousRewindEvent) |
| mrEventQueue.addEvent(mpAsynchronousRewindEvent); |
| |
| return mpAsynchronousRewindEvent.get()!=NULL; |
| } |
| |
| |
| |
| |
| void EffectRewinder::skipAllMainSequenceEffects (void) |
| { |
| // Do not allow nested rewinds. |
| if (mpAsynchronousRewindEvent) |
| { |
| OSL_ASSERT(!mpAsynchronousRewindEvent); |
| return; |
| } |
| |
| const int nTotalMainSequenceEffectCount (countMainSequenceEffects()); |
| mpAsynchronousRewindEvent = makeEvent( |
| ::boost::bind( |
| &EffectRewinder::asynchronousRewind, |
| this, |
| nTotalMainSequenceEffectCount, |
| false, |
| ::boost::function<void(void)>()), |
| "EffectRewinder::asynchronousRewind"); |
| mrEventQueue.addEvent(mpAsynchronousRewindEvent); |
| } |
| |
| |
| |
| |
| sal_Int32 EffectRewinder::countMainSequenceEffects (void) |
| { |
| // Determine the number of main sequence effects. |
| sal_Int32 nMainSequenceNodeCount (0); |
| |
| ::std::queue<uno::Reference<animations::XAnimationNode> > aNodeQueue; |
| aNodeQueue.push(mxCurrentAnimationRootNode); |
| while ( ! aNodeQueue.empty()) |
| { |
| const uno::Reference<animations::XAnimationNode> xNode (aNodeQueue.front()); |
| aNodeQueue.pop(); |
| |
| // Does the current node belong to the main sequence? |
| if (xNode.is()) |
| { |
| animations::Event aEvent; |
| if (xNode->getBegin() >>= aEvent) |
| if (aEvent.Trigger == animations::EventTrigger::ON_NEXT) |
| ++nMainSequenceNodeCount; |
| } |
| |
| // If the current node is a container then prepare its children for investigation. |
| uno::Reference<container::XEnumerationAccess> xEnumerationAccess (xNode, uno::UNO_QUERY); |
| if (xEnumerationAccess.is()) |
| { |
| uno::Reference<container::XEnumeration> xEnumeration ( |
| xEnumerationAccess->createEnumeration()); |
| if (xEnumeration.is()) |
| while (xEnumeration->hasMoreElements()) |
| { |
| aNodeQueue.push( |
| uno::Reference<animations::XAnimationNode>( |
| xEnumeration->nextElement(), uno::UNO_QUERY)); |
| } |
| } |
| } |
| |
| return nMainSequenceNodeCount; |
| |
| // // Skip all main sequence nodes. |
| // SkipSomeMainSequenceEffects(nMainSequenceNodeCount); |
| } |
| |
| |
| |
| |
| void EffectRewinder::skipSomeMainSequenceEffects (sal_Int32 nSkipCount) |
| { |
| while (--nSkipCount >= 0) |
| skipSingleMainSequenceEffects(); |
| } |
| |
| |
| |
| |
| void EffectRewinder::skipSingleMainSequenceEffects (void) |
| { |
| // This basically just starts the next effect and then skips over its |
| // animation. |
| mrEventMultiplexer.notifyNextEffect(); |
| mrEventQueue.forceEmpty(); |
| mrUserEventQueue.callSkipEffectEventHandler(); |
| mrEventQueue.forceEmpty(); |
| } |
| |
| |
| |
| |
| bool EffectRewinder::resetEffectCount (void) |
| { |
| mnMainSequenceEffectCount = 0; |
| return false; |
| } |
| |
| |
| |
| |
| bool EffectRewinder::notifyAnimationStart (const AnimationNodeSharedPtr& rpNode) |
| { |
| // This notification is only relevant for us when the rpNode belongs to |
| // the main sequence. |
| BaseNodeSharedPtr pBaseNode (::boost::dynamic_pointer_cast<BaseNode>(rpNode)); |
| if ( ! pBaseNode) |
| return false; |
| |
| BaseContainerNodeSharedPtr pParent (pBaseNode->getParentNode()); |
| if ( ! (pParent && pParent->isMainSequenceRootNode())) |
| return false; |
| |
| // This notification is only relevant for us when the effect is user |
| // triggered. |
| bool bIsUserTriggered (false); |
| |
| Reference<animations::XAnimationNode> xNode (rpNode->getXAnimationNode()); |
| if (xNode.is()) |
| { |
| animations::Event aEvent; |
| if ((xNode->getBegin() >>= aEvent)) |
| bIsUserTriggered = (aEvent.Trigger == animations::EventTrigger::ON_NEXT); |
| } |
| |
| if (bIsUserTriggered) |
| ++mnMainSequenceEffectCount; |
| else |
| mbNonUserTriggeredMainSequenceEffectSeen = true; |
| |
| return false; |
| } |
| |
| |
| |
| |
| void EffectRewinder::asynchronousRewind ( |
| sal_Int32 nEffectCount, |
| const bool bRedisplayCurrentSlide, |
| const boost::function<void(void)>& rSlideRewindFunctor) |
| { |
| OSL_ASSERT(mpAsynchronousRewindEvent); |
| |
| if (bRedisplayCurrentSlide) |
| { |
| mpPaintLock->Activate(); |
| // Re-display the current slide. |
| if (rSlideRewindFunctor) |
| rSlideRewindFunctor(); |
| mpAsynchronousRewindEvent = makeEvent( |
| ::boost::bind( |
| &EffectRewinder::asynchronousRewind, |
| this, |
| nEffectCount, |
| false, |
| rSlideRewindFunctor), |
| "EffectRewinder::asynchronousRewind"); |
| mrEventQueue.addEvent(mpAsynchronousRewindEvent); |
| } |
| else |
| { |
| // Process initial events and skip any animations that are started |
| // when the slide is shown. |
| mbNonUserTriggeredMainSequenceEffectSeen = false; |
| mrEventQueue.forceEmpty(); |
| if (mbNonUserTriggeredMainSequenceEffectSeen) |
| { |
| mrUserEventQueue.callSkipEffectEventHandler(); |
| mrEventQueue.forceEmpty(); |
| } |
| |
| while (--nEffectCount >= 0) |
| skipSingleMainSequenceEffects(); |
| |
| mpAsynchronousRewindEvent.reset(); |
| mpPaintLock.reset(); |
| } |
| } |
| |
| |
| |
| |
| void EffectRewinder::asynchronousRewindToPreviousSlide ( |
| const ::boost::function<void(void)>& rSlideRewindFunctor) |
| { |
| OSL_ASSERT(mpAsynchronousRewindEvent); |
| |
| mpAsynchronousRewindEvent.reset(); |
| rSlideRewindFunctor(); |
| } |
| |
| |
| |
| |
| } } // end of namespace ::slideshow::internal |
