summaryrefslogtreecommitdiff
path: root/slideshow
diff options
context:
space:
mode:
authorArmin Le Grand <Armin.Le.Grand@Sun.COM>2009-12-21 20:40:13 +0100
committerArmin Le Grand <Armin.Le.Grand@Sun.COM>2009-12-21 20:40:13 +0100
commitaa009b1d9a3a8b691e01e9c28db0adcae84cbafc (patch)
tree980567c28bd94ea0f35a36c588a3cfc44a7f9f02 /slideshow
parent2546b368921c771c4336e6db18543497389eaab7 (diff)
parenteb86211c1db0bb492669e7ac8302b89254ed4793 (diff)
aw078: resync to DEV300m68for integration
Diffstat (limited to 'slideshow')
-rw-r--r--slideshow/source/engine/activities/activitiesfactory.cxx9
-rw-r--r--slideshow/source/engine/animationnodes/animationaudionode.cxx9
-rw-r--r--slideshow/source/engine/animationnodes/animationbasenode.cxx3
-rw-r--r--slideshow/source/engine/animationnodes/animationcommandnode.cxx3
-rw-r--r--slideshow/source/engine/animationnodes/animationsetnode.cxx3
-rw-r--r--slideshow/source/engine/animationnodes/basenode.cxx9
-rw-r--r--slideshow/source/engine/animationnodes/basenode.hxx4
-rw-r--r--slideshow/source/engine/animationnodes/generateevent.cxx36
-rw-r--r--slideshow/source/engine/animationnodes/paralleltimecontainer.cxx3
-rw-r--r--slideshow/source/engine/animationnodes/sequentialtimecontainer.cxx19
-rw-r--r--slideshow/source/engine/debug.cxx327
-rw-r--r--slideshow/source/engine/effectrewinder.cxx436
-rw-r--r--slideshow/source/engine/effectrewinder.hxx185
-rw-r--r--slideshow/source/engine/eventmultiplexer.cxx25
-rw-r--r--slideshow/source/engine/eventqueue.cxx78
-rw-r--r--slideshow/source/engine/makefile.mk4
-rw-r--r--slideshow/source/engine/rehearsetimingsactivity.cxx3
-rw-r--r--slideshow/source/engine/screenupdater.cxx83
-rw-r--r--slideshow/source/engine/shapes/drawshape.cxx6
-rw-r--r--slideshow/source/engine/shapes/viewmediashape.cxx12
-rw-r--r--slideshow/source/engine/shapes/viewmediashape.hxx1
-rw-r--r--slideshow/source/engine/slide/layermanager.cxx105
-rw-r--r--slideshow/source/engine/slide/layermanager.hxx35
-rw-r--r--slideshow/source/engine/slideshowimpl.cxx469
-rw-r--r--slideshow/source/engine/slideview.cxx22
-rw-r--r--slideshow/source/engine/usereventqueue.cxx58
-rw-r--r--slideshow/source/engine/wakeupevent.cxx3
-rw-r--r--slideshow/source/inc/debug.hxx80
-rw-r--r--slideshow/source/inc/delayevent.hxx55
-rw-r--r--slideshow/source/inc/event.hxx14
-rw-r--r--slideshow/source/inc/eventqueue.hxx8
-rw-r--r--slideshow/source/inc/interruptabledelayevent.hxx5
-rw-r--r--slideshow/source/inc/screenupdater.hxx21
-rw-r--r--slideshow/source/inc/unoview.hxx10
-rw-r--r--slideshow/source/inc/usereventqueue.hxx16
-rw-r--r--slideshow/test/makefile.mk13
-rw-r--r--slideshow/test/slidetest.cxx2
-rw-r--r--slideshow/test/testshape.cxx2
-rw-r--r--slideshow/test/testview.cxx2
-rw-r--r--slideshow/test/views.cxx2
40 files changed, 1952 insertions, 228 deletions
diff --git a/slideshow/source/engine/activities/activitiesfactory.cxx b/slideshow/source/engine/activities/activitiesfactory.cxx
index 39cd7d733110..398a813a62aa 100644
--- a/slideshow/source/engine/activities/activitiesfactory.cxx
+++ b/slideshow/source/engine/activities/activitiesfactory.cxx
@@ -289,11 +289,18 @@ public:
BaseType::getNumberOfKeyTimes() ) ) ) );
}
+ using BaseType::isAutoReverse;
+
virtual void performEnd()
{
// xxx todo: good guess
if (mpAnim)
- (*mpAnim)( getPresentationValue( maEndValue ) );
+ {
+ if (isAutoReverse())
+ (*mpAnim)( getPresentationValue( maStartValue ) );
+ else
+ (*mpAnim)( getPresentationValue( maEndValue ) );
+ }
}
/// Disposable:
diff --git a/slideshow/source/engine/animationnodes/animationaudionode.cxx b/slideshow/source/engine/animationnodes/animationaudionode.cxx
index 634dc0342515..24c3a95382bf 100644
--- a/slideshow/source/engine/animationnodes/animationaudionode.cxx
+++ b/slideshow/source/engine/animationnodes/animationaudionode.cxx
@@ -94,14 +94,16 @@ void AnimationAudioNode::activate_st()
// no node duration. Take inherent media time, then
scheduleDeactivationEvent(
makeDelay( boost::bind( &AnimationNode::deactivate, getSelf() ),
- mpPlayer->getDuration() ) );
+ mpPlayer->getDuration(),
+ "AnimationAudioNode::deactivate with delay") );
}
}
else
{
// deactivate ASAP:
scheduleDeactivationEvent(
- makeEvent( boost::bind( &AnimationNode::deactivate, getSelf() ) ) );
+ makeEvent( boost::bind( &AnimationNode::deactivate, getSelf() ),
+ "AnimationAudioNode::deactivate without delay") );
}
}
@@ -127,7 +129,8 @@ void AnimationAudioNode::deactivate_st( NodeState /*eDestState*/ )
getContext().mrEventQueue.addEvent(
makeEvent( boost::bind( &EventMultiplexer::notifyAudioStopped,
boost::ref(getContext().mrEventMultiplexer),
- getSelf() ) ) );
+ getSelf() ),
+ "AnimationAudioNode::notifyAudioStopped") );
}
bool AnimationAudioNode::hasPendingAnimation() const
diff --git a/slideshow/source/engine/animationnodes/animationbasenode.cxx b/slideshow/source/engine/animationnodes/animationbasenode.cxx
index 82868063fefa..19a6df2a8244 100644
--- a/slideshow/source/engine/animationnodes/animationbasenode.cxx
+++ b/slideshow/source/engine/animationnodes/animationbasenode.cxx
@@ -456,7 +456,8 @@ AnimationBaseNode::fillCommonParameters() const
EventSharedPtr pEndEvent;
if (pSelf) {
pEndEvent = makeEvent(
- boost::bind( &AnimationNode::deactivate, pSelf ) );
+ boost::bind( &AnimationNode::deactivate, pSelf ),
+ "AnimationBaseNode::deactivate");
}
// Calculate the minimum frame count that depends on the duration and
diff --git a/slideshow/source/engine/animationnodes/animationcommandnode.cxx b/slideshow/source/engine/animationnodes/animationcommandnode.cxx
index f9104f37a45a..2adbe2b9b75a 100644
--- a/slideshow/source/engine/animationnodes/animationcommandnode.cxx
+++ b/slideshow/source/engine/animationnodes/animationcommandnode.cxx
@@ -124,7 +124,8 @@ void AnimationCommandNode::activate_st()
// deactivate ASAP:
scheduleDeactivationEvent(
- makeEvent( boost::bind( &AnimationNode::deactivate, getSelf() ) ) );
+ makeEvent( boost::bind( &AnimationNode::deactivate, getSelf() ),
+ "AnimationCommandNode::deactivate" ) );
}
bool AnimationCommandNode::hasPendingAnimation() const
diff --git a/slideshow/source/engine/animationnodes/animationsetnode.cxx b/slideshow/source/engine/animationnodes/animationsetnode.cxx
index f7669b7214d3..ba1f015cd4fe 100644
--- a/slideshow/source/engine/animationnodes/animationsetnode.cxx
+++ b/slideshow/source/engine/animationnodes/animationsetnode.cxx
@@ -80,7 +80,8 @@ AnimationActivitySharedPtr AnimationSetNode::createActivity() const
pSelf, "cannot cast getSelf() to my type!" );
aParms.mpEndEvent = makeEvent(
boost::bind( &AnimationSetNode::implScheduleDeactivationEvent,
- pSelf ) );
+ pSelf ),
+ "AnimationSetNode::implScheduleDeactivationEvent");
}
switch (AnimationFactory::classifyAttributeName( attrName )) {
diff --git a/slideshow/source/engine/animationnodes/basenode.cxx b/slideshow/source/engine/animationnodes/basenode.cxx
index 9f74a75fd571..6ad15e43462f 100644
--- a/slideshow/source/engine/animationnodes/basenode.cxx
+++ b/slideshow/source/engine/animationnodes/basenode.cxx
@@ -50,6 +50,7 @@
#include "tools.hxx"
#include "nodetools.hxx"
#include "generateevent.hxx"
+#include "debug.hxx"
#include <boost/bind.hpp>
#include <vector>
@@ -312,6 +313,10 @@ public:
mpNode->meCurrState = meToState;
clear();
}
+
+ // Uncomment the following line to write the node tree to file on
+ // every state change of one of its nodes.
+ // Debug_ShowNodeTree(mpNode->mpSelf);
}
void clear() {
@@ -488,7 +493,9 @@ bool BaseNode::resolve()
// schedule delayed activation event. Take iterate node
// timeout into account
mpCurrentEvent = makeDelay(
- boost::bind( &AnimationNode::activate, mpSelf ), mnStartDelay );
+ boost::bind( &AnimationNode::activate, mpSelf ),
+ mnStartDelay,
+ "AnimationNode::activate with delay");
maContext.mrEventQueue.addEvent( mpCurrentEvent );
}
diff --git a/slideshow/source/engine/animationnodes/basenode.hxx b/slideshow/source/engine/animationnodes/basenode.hxx
index 68ec92f0fea7..3a0b25e7ea94 100644
--- a/slideshow/source/engine/animationnodes/basenode.hxx
+++ b/slideshow/source/engine/animationnodes/basenode.hxx
@@ -137,6 +137,8 @@ public:
// nop:
virtual void notifyDeactivating( const AnimationNodeSharedPtr& rNotifier );
+ bool isMainSequenceRootNode() const { return mbIsMainSequenceRootNode; }
+
protected:
void scheduleDeactivationEvent( EventSharedPtr const& pEvent =
EventSharedPtr() );
@@ -144,8 +146,6 @@ protected:
SlideShowContext const& getContext() const { return maContext; }
::boost::shared_ptr<BaseNode> const& getSelf() const { return mpSelf; }
- bool isMainSequenceRootNode() const { return mbIsMainSequenceRootNode; }
-
bool checkValidNode() const {
ENSURE_OR_THROW( mpSelf, "no self ptr set!" );
bool const bRet = (meCurrState != INVALID);
diff --git a/slideshow/source/engine/animationnodes/generateevent.cxx b/slideshow/source/engine/animationnodes/generateevent.cxx
index 0983019dafef..015db5586834 100644
--- a/slideshow/source/engine/animationnodes/generateevent.cxx
+++ b/slideshow/source/engine/animationnodes/generateevent.cxx
@@ -111,7 +111,9 @@ EventSharedPtr generateEvent(
case animations::EventTrigger::BEGIN_EVENT:
// try to extract XAnimationNode event source
if (aEvent.Source >>= xNode) {
- pEvent = makeDelay( rFunctor, nDelay2 + nAdditionalDelay );
+ pEvent = makeDelay( rFunctor,
+ nDelay2 + nAdditionalDelay,
+ "generateEvent, BEGIN_EVENT");
rContext.mrUserEventQueue.registerAnimationStartEvent(
pEvent, xNode );
}
@@ -123,7 +125,9 @@ EventSharedPtr generateEvent(
case animations::EventTrigger::END_EVENT:
// try to extract XAnimationNode event source
if (aEvent.Source >>= xNode) {
- pEvent = makeDelay( rFunctor, nDelay2 + nAdditionalDelay );
+ pEvent = makeDelay( rFunctor,
+ nDelay2 + nAdditionalDelay,
+ "generateEvent, END_EVENT");
rContext.mrUserEventQueue.registerAnimationEndEvent(
pEvent, xNode );
}
@@ -137,7 +141,9 @@ EventSharedPtr generateEvent(
if ((aEvent.Source >>= xShape) &&
(pShape = rContext.mpSubsettableShapeManager->lookupShape(xShape)).get())
{
- pEvent = makeDelay( rFunctor, nDelay2 + nAdditionalDelay );
+ pEvent = makeDelay( rFunctor,
+ nDelay2 + nAdditionalDelay,
+ "generateEvent, ON_CLICK");
rContext.mrUserEventQueue.registerShapeClickEvent(
pEvent, pShape );
}
@@ -151,7 +157,9 @@ EventSharedPtr generateEvent(
if ((aEvent.Source >>= xShape) &&
(pShape = rContext.mpSubsettableShapeManager->lookupShape(xShape)).get())
{
- pEvent = makeDelay( rFunctor, nDelay2 + nAdditionalDelay );
+ pEvent = makeDelay( rFunctor,
+ nDelay2 + nAdditionalDelay,
+ "generateEvent, ON_DBL_CLICK");
rContext.mrUserEventQueue.registerShapeDoubleClickEvent(
pEvent, pShape );
}
@@ -165,7 +173,9 @@ EventSharedPtr generateEvent(
if ((aEvent.Source >>= xShape) &&
(pShape = rContext.mpSubsettableShapeManager->lookupShape(xShape)).get())
{
- pEvent = makeDelay( rFunctor, nDelay2 + nAdditionalDelay );
+ pEvent = makeDelay( rFunctor,
+ nDelay2 + nAdditionalDelay,
+ "generateEvent, ON_MOUSE_ENTER");
rContext.mrUserEventQueue.registerMouseEnterEvent(
pEvent, pShape );
}
@@ -179,7 +189,9 @@ EventSharedPtr generateEvent(
if ((aEvent.Source >>= xShape) &&
(pShape = rContext.mpSubsettableShapeManager->lookupShape(xShape)).get())
{
- pEvent = makeDelay( rFunctor, nDelay2 + nAdditionalDelay );
+ pEvent = makeDelay( rFunctor,
+ nDelay2 + nAdditionalDelay,
+ "generateEvent, ON_MOUSE_LEAVE");
rContext.mrUserEventQueue.registerMouseLeaveEvent(
pEvent, pShape );
}
@@ -193,13 +205,17 @@ EventSharedPtr generateEvent(
"mapped to ON_NEXT!" );
// FALLTHROUGH intended
case animations::EventTrigger::ON_NEXT:
- pEvent = makeDelay( rFunctor, nDelay2 + nAdditionalDelay );
+ pEvent = makeDelay( rFunctor,
+ nDelay2 + nAdditionalDelay,
+ "generateEvent, ON_NEXT");
rContext.mrUserEventQueue.registerNextEffectEvent( pEvent );
break;
case animations::EventTrigger::ON_STOP_AUDIO:
// try to extract XAnimationNode event source
if (aEvent.Source >>= xNode) {
- pEvent = makeDelay( rFunctor, nDelay2 + nAdditionalDelay );
+ pEvent = makeDelay( rFunctor,
+ nDelay2 + nAdditionalDelay,
+ "generateEvent, ON_STOP_AUDIO");
rContext.mrUserEventQueue.registerAudioStoppedEvent(
pEvent, xNode );
}
@@ -218,7 +234,9 @@ EventSharedPtr generateEvent(
"not yet implemented!" );
}
else if (rEventDescription >>= nDelay1) {
- pEvent = makeDelay( rFunctor, nDelay1 + nAdditionalDelay );
+ pEvent = makeDelay( rFunctor,
+ nDelay1 + nAdditionalDelay,
+ "generateEvent with delay");
// schedule delay event
rContext.mrEventQueue.addEvent( pEvent );
}
diff --git a/slideshow/source/engine/animationnodes/paralleltimecontainer.cxx b/slideshow/source/engine/animationnodes/paralleltimecontainer.cxx
index 0bd4c524586e..0581c78e9c47 100644
--- a/slideshow/source/engine/animationnodes/paralleltimecontainer.cxx
+++ b/slideshow/source/engine/animationnodes/paralleltimecontainer.cxx
@@ -53,7 +53,8 @@ void ParallelTimeContainer::activate_st()
if (isDurationIndefinite() && maChildren.empty()) {
// deactivate ASAP:
scheduleDeactivationEvent(
- makeEvent( boost::bind( &AnimationNode::deactivate, getSelf() ) ) );
+ makeEvent( boost::bind( &AnimationNode::deactivate, getSelf() ),
+ "ParallelTimeContainer::deactivate") );
}
else { // use default
scheduleDeactivationEvent();
diff --git a/slideshow/source/engine/animationnodes/sequentialtimecontainer.cxx b/slideshow/source/engine/animationnodes/sequentialtimecontainer.cxx
index 683fe7bd9707..79046f50251a 100644
--- a/slideshow/source/engine/animationnodes/sequentialtimecontainer.cxx
+++ b/slideshow/source/engine/animationnodes/sequentialtimecontainer.cxx
@@ -63,7 +63,9 @@ void SequentialTimeContainer::activate_st()
{
// deactivate ASAP:
scheduleDeactivationEvent(
- makeEvent( boost::bind< void >( boost::mem_fn( &AnimationNode::deactivate ), getSelf() ) ) );
+ makeEvent(
+ boost::bind< void >( boost::mem_fn( &AnimationNode::deactivate ), getSelf() ),
+ "SequentialTimeContainer::deactivate") );
}
else // use default
scheduleDeactivationEvent();
@@ -88,8 +90,10 @@ void SequentialTimeContainer::skipEffect(
if (isChildNode(pChildNode)) {
// empty all events ignoring timings => until next effect
getContext().mrEventQueue.forceEmpty();
- getContext().mrEventQueue.addEventForNextRound(
- makeEvent( boost::bind<void>( boost::mem_fn( &AnimationNode::deactivate ), pChildNode ) ) );
+ getContext().mrEventQueue.addEvent(
+ makeEvent(
+ boost::bind<void>( boost::mem_fn( &AnimationNode::deactivate ), pChildNode ),
+ "SequentialTimeContainer::deactivate, skipEffect with delay") );
}
else
OSL_ENSURE( false, "unknown notifier!" );
@@ -116,16 +120,19 @@ bool SequentialTimeContainer::resolveChild(
mpCurrentSkipEvent = makeEvent(
boost::bind( &SequentialTimeContainer::skipEffect,
boost::dynamic_pointer_cast<SequentialTimeContainer>( getSelf() ),
- pChildNode ) );
+ pChildNode ),
+ "SequentialTimeContainer::skipEffect, resolveChild");
// event that will reresolve the resolved/activated child:
mpCurrentRewindEvent = makeEvent(
boost::bind( &SequentialTimeContainer::rewindEffect,
boost::dynamic_pointer_cast<SequentialTimeContainer>( getSelf() ),
- pChildNode ) );
+ pChildNode ),
+ "SequentialTimeContainer::rewindEffect, resolveChild");
// deactivate child node when skip event occurs:
getContext().mrUserEventQueue.registerSkipEffectEvent(
- mpCurrentSkipEvent );
+ mpCurrentSkipEvent,
+ mnFinishedChildren+1<maChildren.size());
// rewind to previous child:
getContext().mrUserEventQueue.registerRewindEffectEvent(
mpCurrentRewindEvent );
diff --git a/slideshow/source/engine/debug.cxx b/slideshow/source/engine/debug.cxx
new file mode 100644
index 000000000000..75d1c30d5013
--- /dev/null
+++ b/slideshow/source/engine/debug.cxx
@@ -0,0 +1,327 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2008 by Sun Microsystems, Inc.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * $RCSfile: layer.hxx,v $
+ * $Revision: 1.3 $
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#include "precompiled_slideshow.hxx"
+
+#include "debug.hxx"
+
+#if OSL_DEBUG_LEVEL > 1
+
+#include "animationnodes/basecontainernode.hxx"
+#include "animationnodes/paralleltimecontainer.hxx"
+#include "animationnodes/sequentialtimecontainer.hxx"
+#include "animationnodes/animationtransitionfilternode.hxx"
+#include "animationnodes/animationaudionode.hxx"
+#include "animationnodes/animationcolornode.hxx"
+#include "animationnodes/animationcommandnode.hxx"
+#include "animationnodes/animationpathmotionnode.hxx"
+#include "animationnodes/animationsetnode.hxx"
+#include "animationnodes/animationtransformnode.hxx"
+#include "animationnodes/propertyanimationnode.hxx"
+
+#include <com/sun/star/animations/XAnimationNode.hpp>
+#include <com/sun/star/animations/Event.hpp>
+
+#include <cstdio>
+#include <cstdarg>
+
+using ::rtl::OUString;
+using namespace ::com::sun::star;
+
+
+namespace slideshow { namespace internal {
+
+namespace {
+
+class NodeContainer : public BaseContainerNode
+{
+public:
+ void ShowChildrenState (void) const;
+};
+
+
+
+
+OUString DebugGetDescription (const AnimationNodeSharedPtr& rpNode)
+{
+ if (::boost::dynamic_pointer_cast<BaseContainerNode>(rpNode))
+ {
+ // Node is a container.
+ if (::boost::dynamic_pointer_cast<ParallelTimeContainer>(rpNode))
+ return OUString::createFromAscii("ParallelTimeContainer");
+ else if (::boost::dynamic_pointer_cast<SequentialTimeContainer>(rpNode))
+ return OUString::createFromAscii("SequentialTimeContainer");
+ else
+ return OUString::createFromAscii("<unknown container>");
+ }
+ else if (::boost::dynamic_pointer_cast<AnimationTransitionFilterNode>(rpNode))
+ return OUString::createFromAscii("AnimationTransitionFilterNode");
+ else if (::boost::dynamic_pointer_cast<AnimationAudioNode>(rpNode))
+ return OUString::createFromAscii("AnimationAudioNode");
+ else if (::boost::dynamic_pointer_cast<AnimationColorNode>(rpNode))
+ return OUString::createFromAscii("AnimationColorNode");
+ else if (::boost::dynamic_pointer_cast<AnimationCommandNode>(rpNode))
+ return OUString::createFromAscii("AnimationCommandNode");
+ else if (::boost::dynamic_pointer_cast<AnimationPathMotionNode>(rpNode))
+ return OUString::createFromAscii("AnimationPathMotionNode");
+ else if (::boost::dynamic_pointer_cast<AnimationSetNode>(rpNode))
+ return OUString::createFromAscii("AnimationSetNode");
+ else if (::boost::dynamic_pointer_cast<AnimationTransformNode>(rpNode))
+ return OUString::createFromAscii("AnimationTransformNode");
+ else if (::boost::dynamic_pointer_cast<PropertyAnimationNode>(rpNode))
+ return OUString::createFromAscii("PropertyAnimationNode");
+ else
+ return OUString::createFromAscii("<unknown node type>");
+}
+
+
+
+
+void DebugShowState (const AnimationNodeSharedPtr& rpNode)
+{
+ if ( ! rpNode)
+ return;
+
+ OUString sState;
+ OUString sStateColor;
+ switch (rpNode->getState())
+ {
+ default:
+ case AnimationNode::INVALID:
+ sState = OUString::createFromAscii("Invalid");
+ sStateColor = OUString::createFromAscii("firebrick1");
+ break;
+ case AnimationNode::UNRESOLVED:
+ sState = OUString::createFromAscii("Unresolved");
+ sStateColor = OUString::createFromAscii("dodgerblue4");
+ break;
+ case AnimationNode::RESOLVED:
+ sState = OUString::createFromAscii("Resolved");
+ sStateColor = OUString::createFromAscii("dodgerblue");
+ break;
+ case AnimationNode::ACTIVE:
+ sState = OUString::createFromAscii("Active");
+ sStateColor = OUString::createFromAscii("seagreen1");
+ break;
+ case AnimationNode::FROZEN:
+ sState = OUString::createFromAscii("Frozen");
+ sStateColor = OUString::createFromAscii("lightskyblue1");
+ break;
+ case AnimationNode::ENDED:
+ sState = OUString::createFromAscii("Ended");
+ sStateColor = OUString::createFromAscii("slategray3");
+ break;
+ }
+
+ const uno::Any aBegin (rpNode->getXAnimationNode()->getBegin());
+ OUString sTrigger;
+ if (aBegin.hasValue())
+ {
+ animations::Event aEvent;
+ double nTimeOffset;
+ const static char* sEventTriggers[] = {
+ "NONE", "ON_BEGIN", "ON_END", "BEGIN_EVENT", "END_EVENT", "ON_CLICK",
+ "ON_DBL_CLICK", "ON_MOUSE_ENTER", "ON_MOUSE_LEAVE", "ON_NEXT", "ON_PREV",
+ "ON_STOP_AUDIO", "REPEAT"};
+ if (aBegin >>= aEvent)
+ {
+ sTrigger = OUString::createFromAscii(sEventTriggers[aEvent.Trigger]);
+ }
+ else if (aBegin >>= nTimeOffset)
+ {
+ sTrigger = OUString::valueOf(nTimeOffset);
+ }
+ else
+ {
+ sTrigger = OUString::createFromAscii("other");
+ }
+ }
+ else
+ sTrigger = ::rtl::OUString::createFromAscii("void");
+
+ TRACE("Node state: n%x [label=\"%x / %x / %s\\n%s\\n%s\",style=filled,fillcolor=\"%s\"]\r",
+ rpNode.get(),
+ rpNode.get(),
+ rpNode->getXAnimationNode().get(),
+ ::rtl::OUStringToOString(sState, RTL_TEXTENCODING_ASCII_US).getStr(),
+ ::rtl::OUStringToOString(DebugGetDescription(rpNode), RTL_TEXTENCODING_ASCII_US).getStr(),
+ ::rtl::OUStringToOString(sTrigger, RTL_TEXTENCODING_ASCII_US).getStr(),
+ ::rtl::OUStringToOString(sStateColor, RTL_TEXTENCODING_ASCII_US).getStr());
+
+ BaseContainerNodeSharedPtr pContainer (
+ ::boost::dynamic_pointer_cast<BaseContainerNode>(rpNode));
+ if (pContainer)
+ ::boost::static_pointer_cast<NodeContainer>(rpNode)->ShowChildrenState();
+}
+
+
+
+
+void NodeContainer::ShowChildrenState (void) const
+{
+ for (std::size_t nIndex=0; nIndex<maChildren.size(); ++nIndex)
+ {
+ TRACE("Node connection: n%x -> n%x", this, maChildren[nIndex].get());
+ DebugShowState(maChildren[nIndex]);
+ }
+}
+
+
+
+
+AnimationNodeSharedPtr DebugGetTreeRoot (const BaseNodeSharedPtr& rpNode)
+{
+ BaseNodeSharedPtr pNode (rpNode);
+ if (pNode)
+ {
+ BaseNodeSharedPtr pParent (pNode->getParentNode());
+ while (pParent)
+ {
+ pNode = pParent;
+ pParent = pNode->getParentNode();
+ }
+ }
+ return pNode;
+}
+
+} // end of anonymous namespace
+
+
+
+
+void Debug_ShowNodeTree (const AnimationNodeSharedPtr& rpNode)
+{
+ DebugTraceScope aTraceScope ("NodeTree");
+
+ DebugShowState(DebugGetTreeRoot(::boost::dynamic_pointer_cast<BaseNode>(rpNode)));
+}
+
+
+
+
+//----- Tracing ---------------------------------------------------------------
+
+extern "C" {
+
+ namespace {
+
+ class TraceData
+ {
+ public:
+ TraceData (void)
+ : mnIndentation(0),
+ mpFile(fopen(TRACE_LOG_FILE_NAME, "w")),
+ maTime()
+ {
+ }
+
+ int mnIndentation;
+ FILE* mpFile;
+ ::canvas::tools::ElapsedTime maTime;
+ };
+ static TraceData gTraceData;
+
+ inline void SAL_CALL DebugTrace (
+ const int nIndentationOffset,
+ const sal_Char* sFormat,
+ va_list args)
+ {
+ if (gTraceData.mpFile != NULL)
+ {
+ // Write line head with current time and indentation.
+ // Adapt indentation.
+ if (nIndentationOffset < 0)
+ gTraceData.mnIndentation += nIndentationOffset;
+ fprintf(gTraceData.mpFile, "%10.8f ", gTraceData.maTime.getElapsedTime());
+ for (int nIndentation=0; nIndentation<gTraceData.mnIndentation; ++nIndentation)
+ fprintf(gTraceData.mpFile, " ");
+ if (nIndentationOffset > 0)
+ gTraceData.mnIndentation += nIndentationOffset;
+
+ // Write message.
+ vfprintf(gTraceData.mpFile, sFormat, args);
+ fprintf(gTraceData.mpFile, "\n");
+ fflush(gTraceData.mpFile);
+ }
+ }
+
+} // end of anonymous namespace
+
+
+} // end of extern "C"
+
+void SAL_CALL DebugTraceBegin (const sal_Char* sFormat, ...)
+{
+ va_list args;
+ va_start(args, sFormat);
+ DebugTrace(+1,sFormat, args);
+ va_end(args);
+}
+
+void SAL_CALL DebugTraceEnd (const sal_Char* sFormat, ...)
+{
+ va_list args;
+ va_start(args, sFormat);
+ DebugTrace(-1,sFormat, args);
+ va_end(args);
+}
+
+void SAL_CALL DebugTraceMessage (const sal_Char* sFormat, ...)
+{
+ va_list args;
+ va_start(args, sFormat);
+ DebugTrace(0,sFormat, args);
+ va_end(args);
+}
+
+
+
+DebugTraceScope::DebugTraceScope (const sal_Char* sFormat, ...)
+ : msMessage(new sal_Char[mnBufferSize])
+{
+ va_list args;
+ va_start(args, sFormat);
+
+ msMessage[mnBufferSize-1] = 0;
+ _vsnprintf(msMessage, mnBufferSize-1, sFormat, args);
+ TRACE_BEGIN("[ %s", msMessage);
+ va_end(args);
+}
+
+DebugTraceScope::~DebugTraceScope (void)
+{
+ TRACE_END("] %s", msMessage);
+ delete [] msMessage;
+}
+
+
+} }
+
+#endif // OSL_DEBUG_LEVEL > 1
diff --git a/slideshow/source/engine/effectrewinder.cxx b/slideshow/source/engine/effectrewinder.cxx
new file mode 100644
index 000000000000..3f6ceb54bb8e
--- /dev/null
+++ b/slideshow/source/engine/effectrewinder.cxx
@@ -0,0 +1,436 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2008 by Sun Microsystems, Inc.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * $RCSfile: slideshowimpl.cxx,v $
+ * $Revision: 1.10 $
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 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
diff --git a/slideshow/source/engine/effectrewinder.hxx b/slideshow/source/engine/effectrewinder.hxx
new file mode 100644
index 000000000000..804696c99c92
--- /dev/null
+++ b/slideshow/source/engine/effectrewinder.hxx
@@ -0,0 +1,185 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2008 by Sun Microsystems, Inc.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * $RCSfile: slideshowimpl.cxx,v $
+ * $Revision: 1.10 $
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#ifndef INCLUDED_SLIDESHOW_EFFECT_REWINDER_HXX
+#define INCLUDED_SLIDESHOW_EFFECT_REWINDER_HXX
+
+#include "animationnode.hxx"
+#include "eventhandler.hxx"
+#include "animationeventhandler.hxx"
+#include "event.hxx"
+#include "screenupdater.hxx"
+
+#include <com/sun/star/presentation/XSlideShow.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/function.hpp>
+#include <vector>
+
+namespace css = ::com::sun::star;
+
+namespace slideshow { namespace internal {
+
+class EventMultiplexer;
+class EventQueue;
+class UserEventQueue;
+
+/** Rewind single effects of the main effect sequence. A rewind is
+ initiated by calling the Rewind() method. Part of the processing is
+ done asynchronously. Multiple EventQueue::update() calls may be
+ necessary to finish a rewind.
+
+ Remember to call SetRootAnimationNode() when switching to a different
+ slide so that the EffectRewinder can determine the number of main
+ sequence effects.
+*/
+class EffectRewinder
+{
+public:
+ EffectRewinder (
+ EventMultiplexer& rEventMultiplexer,
+ EventQueue& rEventQueue,
+ UserEventQueue& rUserEventQueue);
+ ~EffectRewinder (void);
+
+ /** Call Dispose() before the ownder of an EffectRewinder object dies so
+ that the EffectRewinder can release all references to the owner.
+
+ */
+ void dispose (void);
+
+ /** Store the root node of the animation tree. It is used in
+ CountMainSequenceEffects() to count the number of main sequence
+ effects (or effect groups.)
+ */
+ void setRootAnimationNode (
+ const css::uno::Reference<css::animations::XAnimationNode>& xRootNode);
+
+ /** Rewind one effect of the main effect sequence. When the current
+ slide has not effects or no main sequence effect has yet been played
+ then switch to the previous slide and replay all of its main
+ sequence effects.
+ The caller has to pass two functors that redisplay the current slide
+ or switch to the previous slide so that it does not have to expose
+ its internals to us. Only one of the two functors is called.
+ @param rpPaintLock
+ This paint lock is released after the whole asynchronous
+ procoess of rewinding the current effect is completed. It
+ prevents intermediate repaints that would show partial replay
+ of effects.
+ @param rSlideRewindFunctor
+ This functor is called when the current slide is to be
+ redisplayed. When it is called then the other functor is not
+ called.
+ @param rPreviousSlideFunctor
+ This functor is called to switch to the previous slide. When it
+ is called then the other functor is not called.
+ */
+ bool rewind (
+ const ::boost::shared_ptr<ScreenUpdater::UpdateLock>& rpPaintLock,
+ const ::boost::function<void(void)>& rSlideRewindFunctor,
+ const ::boost::function<void(void)>& rPreviousSlideFunctor);
+
+ /** Call this method after gotoPreviousEffect() triggered a slide change
+ to the previous slide.
+ */
+ void skipAllMainSequenceEffects (void);
+
+private:
+ EventMultiplexer& mrEventMultiplexer;
+ EventQueue& mrEventQueue;
+ UserEventQueue& mrUserEventQueue;
+
+ EventHandlerSharedPtr mpSlideStartHandler;
+ EventHandlerSharedPtr mpSlideEndHandler;
+ AnimationEventHandlerSharedPtr mpAnimationStartHandler;
+
+ /** The number off main sequence effects so far.
+ */
+ sal_Int32 mnMainSequenceEffectCount;
+
+ /** This is the currently scheduled event that executes the asynchronous
+ part of the effect rewinding. It is also used as flag that prevents
+ nested rewinds.
+ */
+ EventSharedPtr mpAsynchronousRewindEvent;
+
+ css::uno::Reference<css::animations::XAnimationNode> mxCurrentAnimationRootNode;
+ ::boost::shared_ptr<ScreenUpdater::UpdateLock> mpPaintLock;
+
+ bool mbNonUserTriggeredMainSequenceEffectSeen;
+
+ void initialize (void);
+
+ bool resetEffectCount (void);
+ /** Called by listeners when an animation (not necessarily of a main
+ sequence effect) starts.
+ */
+ bool notifyAnimationStart (const AnimationNodeSharedPtr& rpNode);
+
+ /** Count the number of effects (or effect groups) in the main effect
+ sequence.
+ */
+ sal_Int32 countMainSequenceEffects (void);
+
+ /** Skip the next main sequence effect.
+ */
+ void skipSingleMainSequenceEffects (void);
+
+ /** Skip the specified number of main sequence effects.
+ */
+ void skipSomeMainSequenceEffects (const sal_Int32 nSkipCount);
+
+ /** Rewind the last effect of the main effect sequence by replaying all
+ previous effects.
+ @param nEffectCount
+ The number of main sequence effects to replay.
+ @param bRedisplayCurrentSlide
+ When <TRUE/> then the current slide is redisplayed before the
+ effects are replayed.
+ @param rSlideRewindFunctor
+ This functor is used to redisplay the current slide.
+ */
+ void asynchronousRewind (
+ sal_Int32 nEffectCount,
+ const bool bRedisplayCurrentSlide,
+ const boost::function<void(void)>& rSlideRewindFunctor);
+
+ /** Go to the previous slide and replay all of its main sequence effects
+ (or effect groups).
+ @param rPreviousSlideFunctor
+ This functor is used to go to the previous slide.
+ */
+ void asynchronousRewindToPreviousSlide (
+ const ::boost::function<void(void)>& rPreviousSlideFunctor);
+};
+
+} } // end of namespace ::slideshow::internal
+
+#endif
diff --git a/slideshow/source/engine/eventmultiplexer.cxx b/slideshow/source/engine/eventmultiplexer.cxx
index 181a787301b7..d62a7946d3c7 100644
--- a/slideshow/source/engine/eventmultiplexer.cxx
+++ b/slideshow/source/engine/eventmultiplexer.cxx
@@ -369,7 +369,8 @@ void SAL_CALL EventMultiplexerListener::mousePressed(
mpEventQueue->addEvent(
makeEvent( boost::bind( &EventMultiplexerImpl::mousePressed,
mpEventMultiplexer,
- e ) ) );
+ e ),
+ "EventMultiplexerImpl::mousePressed") );
}
void SAL_CALL EventMultiplexerListener::mouseReleased(
@@ -383,7 +384,8 @@ void SAL_CALL EventMultiplexerListener::mouseReleased(
mpEventQueue->addEvent(
makeEvent( boost::bind( &EventMultiplexerImpl::mouseReleased,
mpEventMultiplexer,
- e ) ) );
+ e ),
+ "EventMultiplexerImpl::mouseReleased") );
}
void SAL_CALL EventMultiplexerListener::mouseEntered(
@@ -410,7 +412,8 @@ void SAL_CALL EventMultiplexerListener::mouseDragged(
mpEventQueue->addEvent(
makeEvent( boost::bind( &EventMultiplexerImpl::mouseDragged,
mpEventMultiplexer,
- e )) );
+ e ),
+ "EventMultiplexerImpl::mouseDragged") );
}
void SAL_CALL EventMultiplexerListener::mouseMoved(
@@ -424,7 +427,8 @@ void SAL_CALL EventMultiplexerListener::mouseMoved(
mpEventQueue->addEvent(
makeEvent( boost::bind( &EventMultiplexerImpl::mouseMoved,
mpEventMultiplexer,
- e )) );
+ e ),
+ "EventMultiplexerImpl::mouseMoved") );
}
@@ -448,7 +452,15 @@ void EventMultiplexerImpl::forEachView( XSlideShowViewFunc pViewMethod )
for( UnoViewVector::const_iterator aIter( mrViewContainer.begin() ),
aEnd( mrViewContainer.end() ); aIter != aEnd; ++aIter )
{
- ((*aIter)->getUnoView().get()->*pViewMethod)( mxListener.get() );
+ uno::Reference<presentation::XSlideShowView> xView ((*aIter)->getUnoView());
+ if (xView.is())
+ {
+ (xView.get()->*pViewMethod)( mxListener.get() );
+ }
+ else
+ {
+ OSL_ASSERT(xView.is());
+ }
}
}
}
@@ -520,7 +532,8 @@ void EventMultiplexerImpl::scheduleTick()
EventSharedPtr pEvent(
makeDelay( boost::bind( &EventMultiplexerImpl::tick,
this ),
- mnTimeout ));
+ mnTimeout,
+ "EventMultiplexerImpl::tick with delay"));
// store weak reference to generated event, to notice when
// the event queue gets cleansed (we then have to
diff --git a/slideshow/source/engine/eventqueue.cxx b/slideshow/source/engine/eventqueue.cxx
index 9d7b7ed65eb1..44e1cad2f45e 100644
--- a/slideshow/source/engine/eventqueue.cxx
+++ b/slideshow/source/engine/eventqueue.cxx
@@ -35,6 +35,7 @@
#include <canvas/debug.hxx>
#include <tools/diagnose_ex.h>
#include <canvas/verbosetrace.hxx>
+#include "debug.hxx"
#include <comphelper/anytostring.hxx>
#include <cppuhelper/exc_hlp.hxx>
@@ -66,6 +67,7 @@ namespace slideshow
: maMutex(),
maEvents(),
maNextEvents(),
+ maNextNextEvents(),
mpTimer( pPresTimer )
{
}
@@ -103,6 +105,13 @@ namespace slideshow
{
::osl::MutexGuard aGuard( maMutex );
+#if OSL_DEBUG_LEVEL > 1 && defined (SLIDESHOW_ADD_DESCRIPTIONS_TO_EVENTS)
+ OSL_TRACE("adding at %f event [%s] at %x with delay %f\r",
+ mpTimer->getElapsedTime(),
+ OUStringToOString(rEvent->GetDescription(), RTL_TEXTENCODING_UTF8).getStr(),
+ rEvent.get(),
+ rEvent->getActivationTime(0.0));
+#endif
ENSURE_OR_RETURN( rEvent,
"EventQueue::addEvent: event ptr NULL" );
@@ -124,6 +133,14 @@ namespace slideshow
{
::osl::MutexGuard aGuard( maMutex );
+#if OSL_DEBUG_LEVEL > 1 && defined (SLIDESHOW_ADD_DESCRIPTIONS_TO_EVENTS)
+ OSL_TRACE("adding at %f event [%s] at %x for next round with delay %f\r",
+ mpTimer->getElapsedTime(),
+ OUStringToOString(rEvent->GetDescription(), RTL_TEXTENCODING_UTF8).getStr(),
+ rEvent.get(),
+ rEvent->getActivationTime(0.0));
+#endif
+
ENSURE_OR_RETURN( rEvent.get() != NULL,
"EventQueue::addEvent: event ptr NULL" );
maNextEvents.push_back(
@@ -132,6 +149,30 @@ namespace slideshow
return true;
}
+ bool EventQueue::addEventWhenQueueIsEmpty (const EventSharedPtr& rpEvent)
+ {
+ ::osl::MutexGuard aGuard( maMutex );
+
+#if OSL_DEBUG_LEVEL > 1 && defined (SLIDESHOW_ADD_DESCRIPTIONS_TO_EVENTS)
+ OSL_TRACE("adding at %f event [%s] at %x for execution when queue is empty with delay %f\r",
+ mpTimer->getElapsedTime(),
+ OUStringToOString(rpEvent->GetDescription(), RTL_TEXTENCODING_UTF8).getStr(),
+ rpEvent.get(),
+ rpEvent->getActivationTime(0.0));
+#endif
+
+ ENSURE_OR_RETURN(
+ rpEvent.get() != NULL,
+ "EventQueue::addEvent: event ptr NULL");
+
+ maNextNextEvents.push(
+ EventEntry(
+ rpEvent,
+ rpEvent->getActivationTime(mpTimer->getElapsedTime())));
+
+ return true;
+ }
+
void EventQueue::forceEmpty()
{
::osl::MutexGuard aGuard( maMutex );
@@ -163,6 +204,17 @@ namespace slideshow
const double nCurrTime( mpTimer->getElapsedTime() );
+ // When maEvents does not contain any events that are due now
+ // then process one event from maNextNextEvents.
+ if (!maNextNextEvents.empty()
+ && !bFireAllEvents
+ && (maEvents.empty() || maEvents.top().nTime > nCurrTime))
+ {
+ const EventEntry aEvent (maNextNextEvents.top());
+ maNextNextEvents.pop();
+ maEvents.push(aEvent);
+ }
+
// process ready/elapsed events. Note that the 'perceived'
// current time remains constant for this loop, thus we're
// processing only those events which where ready when we
@@ -189,6 +241,14 @@ namespace slideshow
event.pEvent.get(),
event.pEvent->getActivationTime(0.0) );
#endif
+#if OSL_DEBUG_LEVEL > 1 && defined (SLIDESHOW_ADD_DESCRIPTIONS_TO_EVENTS)
+ OSL_TRACE("firing at %f event [%s] at %x with delay %f\r",
+ mpTimer->getElapsedTime(),
+ OUStringToOString(event.pEvent->GetDescription(),
+ RTL_TEXTENCODING_UTF8).getStr(),
+ event.pEvent.get(),
+ event.pEvent->getActivationTime(0.0));
+#endif
event.pEvent->fire();
}
@@ -243,7 +303,7 @@ namespace slideshow
{
::osl::MutexGuard aGuard( maMutex );
- return maEvents.empty();
+ return maEvents.empty() && maNextEvents.empty() && maNextNextEvents.empty();
}
double EventQueue::nextTimeout() const
@@ -251,9 +311,16 @@ namespace slideshow
::osl::MutexGuard aGuard( maMutex );
// return time for next entry (if any)
- return isEmpty() ?
- ::std::numeric_limits<double>::max() :
- maEvents.top().nTime - mpTimer->getElapsedTime();
+ double nTimeout (::std::numeric_limits<double>::max());
+ const double nCurrentTime (mpTimer->getElapsedTime());
+ if ( ! maEvents.empty())
+ nTimeout = maEvents.top().nTime - nCurrentTime;
+ if ( ! maNextEvents.empty())
+ nTimeout = ::std::min(nTimeout, maNextEvents.front().nTime - nCurrentTime);
+ if ( ! maNextNextEvents.empty())
+ nTimeout = ::std::min(nTimeout, maNextNextEvents.top().nTime - nCurrentTime);
+
+ return nTimeout;
}
void EventQueue::clear()
@@ -263,6 +330,9 @@ namespace slideshow
// TODO(P1): Maybe a plain vector and vector.swap will
// be faster here. Profile.
maEvents = ImplQueueType();
+
+ maNextEvents.clear();
+ maNextNextEvents = ImplQueueType();
}
}
}
diff --git a/slideshow/source/engine/makefile.mk b/slideshow/source/engine/makefile.mk
index b064ad7b94cb..84afa7fb657e 100644
--- a/slideshow/source/engine/makefile.mk
+++ b/slideshow/source/engine/makefile.mk
@@ -72,6 +72,7 @@ SLOFILES = $(SLO)$/activitiesqueue.obj \
$(SLO)$/attributemap.obj \
$(SLO)$/color.obj \
$(SLO)$/delayevent.obj \
+ $(SLO)$/effectrewinder.obj \
$(SLO)$/eventmultiplexer.obj \
$(SLO)$/eventqueue.obj \
$(SLO)$/expressionnodefactory.obj \
@@ -89,7 +90,8 @@ SLOFILES = $(SLO)$/activitiesqueue.obj \
$(SLO)$/unoviewcontainer.obj \
$(SLO)$/usereventqueue.obj \
$(SLO)$/waitsymbol.obj \
- $(SLO)$/wakeupevent.obj
+ $(SLO)$/wakeupevent.obj \
+ $(SLO)$/debug.obj
.IF "$(debug)"!="" || "$(DEBUG)"!=""
SLOFILES += $(SLO)$/sp_debug.obj
diff --git a/slideshow/source/engine/rehearsetimingsactivity.cxx b/slideshow/source/engine/rehearsetimingsactivity.cxx
index f8e9cf2f8e6c..90efe8b5aedd 100644
--- a/slideshow/source/engine/rehearsetimingsactivity.cxx
+++ b/slideshow/source/engine/rehearsetimingsactivity.cxx
@@ -72,6 +72,9 @@ public:
WakeupEvent( boost::shared_ptr< ::canvas::tools::ElapsedTime > const& pTimeBase,
ActivitySharedPtr const& rActivity,
ActivitiesQueue & rActivityQueue ) :
+#if OSL_DEBUG_LEVEL > 1
+ Event(::rtl::OUString::createFromAscii("WakeupEvent")),
+#endif
maTimer(pTimeBase),
mnNextTime(0.0),
mpActivity(rActivity),
diff --git a/slideshow/source/engine/screenupdater.cxx b/slideshow/source/engine/screenupdater.cxx
index bf512dfca5db..940d45337919 100644
--- a/slideshow/source/engine/screenupdater.cxx
+++ b/slideshow/source/engine/screenupdater.cxx
@@ -36,6 +36,19 @@
#include <vector>
#include <algorithm>
+namespace {
+ class UpdateLock : public ::slideshow::internal::ScreenUpdater::UpdateLock
+ {
+ public:
+ UpdateLock (::slideshow::internal::ScreenUpdater& rUpdater, const bool bStartLocked);
+ virtual ~UpdateLock (void);
+ virtual void Activate (void);
+ private:
+ ::slideshow::internal::ScreenUpdater& mrUpdater;
+ bool mbIsActivated;
+ };
+}
+
namespace slideshow
{
namespace internal
@@ -64,12 +77,16 @@ namespace internal
/// True, if at least one notifyUpdate() call had bViewClobbered set
bool mbViewClobbered;
+ /// The screen is updated only when mnLockCount==0
+ sal_Int32 mnLockCount;
+
explicit ImplScreenUpdater( UnoViewContainer const& rViewContainer ) :
maUpdaters(),
maViewUpdateRequests(),
mrViewContainer(rViewContainer),
mbUpdateAllRequest(false),
- mbViewClobbered(false)
+ mbViewClobbered(false),
+ mnLockCount(0)
{}
};
@@ -100,6 +117,9 @@ namespace internal
void ScreenUpdater::commitUpdates()
{
+ if (mpImpl->mnLockCount > 0)
+ return;
+
// cases:
//
// (a) no update necessary at all
@@ -178,6 +198,9 @@ namespace internal
void ScreenUpdater::requestImmediateUpdate()
{
+ if (mpImpl->mnLockCount > 0)
+ return;
+
// TODO(F2): This will interfere with other updates, since it
// happens out-of-sync with main animation loop. Might cause
// artifacts.
@@ -186,5 +209,63 @@ namespace internal
boost::mem_fn(&View::updateScreen) );
}
+ void ScreenUpdater::lockUpdates (void)
+ {
+ ++mpImpl->mnLockCount;
+ OSL_ASSERT(mpImpl->mnLockCount>0);
+ }
+
+ void ScreenUpdater::unlockUpdates (void)
+ {
+ OSL_ASSERT(mpImpl->mnLockCount>0);
+ if (mpImpl->mnLockCount > 0)
+ {
+ --mpImpl->mnLockCount;
+ if (mpImpl->mnLockCount)
+ commitUpdates();
+ }
+ }
+
+ ::boost::shared_ptr<ScreenUpdater::UpdateLock> ScreenUpdater::createLock (const bool bStartLocked)
+ {
+ return ::boost::shared_ptr<ScreenUpdater::UpdateLock>(new ::UpdateLock(*this, bStartLocked));
+ }
+
+
} // namespace internal
} // namespace slideshow
+
+namespace {
+
+UpdateLock::UpdateLock (
+ ::slideshow::internal::ScreenUpdater& rUpdater,
+ const bool bStartLocked)
+ : mrUpdater(rUpdater),
+ mbIsActivated(false)
+{
+ if (bStartLocked)
+ Activate();
+}
+
+
+
+
+UpdateLock::~UpdateLock (void)
+{
+ if (mbIsActivated)
+ mrUpdater.unlockUpdates();
+}
+
+
+
+
+void UpdateLock::Activate (void)
+{
+ if ( ! mbIsActivated)
+ {
+ mbIsActivated = true;
+ mrUpdater.lockUpdates();
+ }
+}
+
+}
diff --git a/slideshow/source/engine/shapes/drawshape.cxx b/slideshow/source/engine/shapes/drawshape.cxx
index e588a8fb4e58..899804fe1896 100644
--- a/slideshow/source/engine/shapes/drawshape.cxx
+++ b/slideshow/source/engine/shapes/drawshape.cxx
@@ -262,7 +262,8 @@ namespace slideshow
void DrawShape::updateStateIds() const
{
- // update the states, we've just redrawn
+ // Update the states, we've just redrawn or created a new
+ // attribute layer.
if( mpAttributeLayer )
{
mnAttributeTransformationState = mpAttributeLayer->getTransformationState();
@@ -1277,6 +1278,9 @@ namespace slideshow
// create new layer, with last as its new child
mpAttributeLayer.reset( new ShapeAttributeLayer( mpAttributeLayer ) );
+ // Update the local state ids to reflect those of the new layer.
+ updateStateIds();
+
return mpAttributeLayer;
}
diff --git a/slideshow/source/engine/shapes/viewmediashape.cxx b/slideshow/source/engine/shapes/viewmediashape.cxx
index a02c795d4943..03fdff737e7c 100644
--- a/slideshow/source/engine/shapes/viewmediashape.cxx
+++ b/slideshow/source/engine/shapes/viewmediashape.cxx
@@ -71,6 +71,7 @@
#include "viewmediashape.hxx"
#include "mediashape.hxx"
#include "tools.hxx"
+#include "unoview.hxx"
using namespace ::com::sun::star;
@@ -88,12 +89,19 @@ namespace slideshow
mxShape( rxShape ),
mxPlayer(),
mxPlayerWindow(),
- mxComponentContext( rxContext )
+ mxComponentContext( rxContext ),
+ mbIsSoundEnabled(true)
{
ENSURE_OR_THROW( mxShape.is(), "ViewMediaShape::ViewMediaShape(): Invalid Shape" );
ENSURE_OR_THROW( mpViewLayer, "ViewMediaShape::ViewMediaShape(): Invalid View" );
ENSURE_OR_THROW( mpViewLayer->getCanvas(), "ViewMediaShape::ViewMediaShape(): Invalid ViewLayer canvas" );
ENSURE_OR_THROW( mxComponentContext.is(), "ViewMediaShape::ViewMediaShape(): Invalid component context" );
+
+ UnoViewSharedPtr pUnoView (::boost::dynamic_pointer_cast<UnoView>(rViewLayer));
+ if (pUnoView)
+ {
+ mbIsSoundEnabled = pUnoView->isSoundEnabled();
+ }
}
// ---------------------------------------------------------------------
@@ -352,7 +360,7 @@ namespace slideshow
getPropertyValue( bMute,
rxProps,
::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Mute" )));
- mxPlayer->setMute( bMute );
+ mxPlayer->setMute( bMute || !mbIsSoundEnabled);
sal_Int16 nVolumeDB(0);
getPropertyValue( nVolumeDB,
diff --git a/slideshow/source/engine/shapes/viewmediashape.hxx b/slideshow/source/engine/shapes/viewmediashape.hxx
index 09f4d4fa53ef..f28fe3d74f75 100644
--- a/slideshow/source/engine/shapes/viewmediashape.hxx
+++ b/slideshow/source/engine/shapes/viewmediashape.hxx
@@ -166,6 +166,7 @@ namespace slideshow
::com::sun::star::uno::Reference< ::com::sun::star::media::XPlayer > mxPlayer;
::com::sun::star::uno::Reference< ::com::sun::star::media::XPlayerWindow > mxPlayerWindow;
::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext> mxComponentContext;
+ bool mbIsSoundEnabled;
};
typedef ::boost::shared_ptr< ViewMediaShape > ViewMediaShapeSharedPtr;
diff --git a/slideshow/source/engine/slide/layermanager.cxx b/slideshow/source/engine/slide/layermanager.cxx
index ceff661890bf..251cff3a73b3 100644
--- a/slideshow/source/engine/slide/layermanager.cxx
+++ b/slideshow/source/engine/slide/layermanager.cxx
@@ -67,11 +67,11 @@ namespace slideshow
{
LayerSharedPtr pCurrLayer;
ViewLayerSharedPtr pCurrViewLayer;
- LayerShapeSet::const_iterator aIter( maAllShapes.begin() );
- const LayerShapeSet::const_iterator aEnd ( maAllShapes.end() );
+ LayerShapeMap::const_iterator aIter( maAllShapes.begin() );
+ const LayerShapeMap::const_iterator aEnd ( maAllShapes.end() );
while( aIter != aEnd )
{
- LayerSharedPtr pLayer = aIter->mpLayer.lock();
+ LayerSharedPtr pLayer = aIter->second.lock();
if( pLayer && pLayer != pCurrLayer )
{
pCurrLayer = pLayer;
@@ -79,7 +79,7 @@ namespace slideshow
}
if( pCurrViewLayer )
- shapeFunc(aIter->mpShape,pCurrViewLayer);
+ shapeFunc(aIter->first,pCurrViewLayer);
++aIter;
}
@@ -164,9 +164,18 @@ namespace slideshow
std::for_each(maAllShapes.begin(),
maAllShapes.end(),
boost::bind( &Shape::clearAllViewLayers,
- boost::bind( &ShapeEntry::getShape,
+ boost::bind( std::select1st<LayerShapeMap::value_type>(),
_1 )));
+ for (LayerShapeMap::iterator
+ iShape (maAllShapes.begin()),
+ iEnd (maAllShapes.end());
+ iShape!=iEnd;
+ ++iShape)
+ {
+ iShape->second.reset();
+ }
+
if( bMoreThanOneLayer )
maLayers.erase(maLayers.begin()+1,
maLayers.end());
@@ -265,8 +274,7 @@ namespace slideshow
std::for_each( maAllShapes.begin(),
maAllShapes.end(),
boost::bind(&Shape::render,
- boost::bind(&ShapeEntry::getShape,
- _1)) );
+ boost::bind( ::std::select1st<LayerShapeMap::value_type>(), _1)) );
}
void LayerManager::addShape( const ShapeSharedPtr& rShape )
@@ -287,13 +295,11 @@ namespace slideshow
implAddShape( rShape );
}
- void LayerManager::putShape2BackgroundLayer( const ShapeEntry& rShapeEntry )
+ void LayerManager::putShape2BackgroundLayer( LayerShapeMap::value_type& rShapeEntry )
{
LayerSharedPtr& rBgLayer( maLayers.front() );
- rBgLayer->setShapeViews(rShapeEntry.mpShape);
- // changing a part of the ShapeEntry irrelevant for the
- // set sort order
- const_cast<ShapeEntry&>(rShapeEntry).mpLayer = rBgLayer;
+ rBgLayer->setShapeViews(rShapeEntry.first);
+ rShapeEntry.second = rBgLayer;
}
void LayerManager::implAddShape( const ShapeSharedPtr& rShape )
@@ -301,16 +307,16 @@ namespace slideshow
OSL_ASSERT( !maLayers.empty() ); // always at least background layer
ENSURE_OR_THROW( rShape, "LayerManager::implAddShape(): invalid Shape" );
- ShapeEntry aShapeEntry(rShape);
+ LayerShapeMap::value_type aValue (rShape, LayerWeakPtr());
- OSL_ASSERT( maAllShapes.find(aShapeEntry) == maAllShapes.end() ); // shape must not be added already
+ OSL_ASSERT( maAllShapes.find(rShape) == maAllShapes.end() ); // shape must not be added already
mbLayerAssociationDirty = true;
if( mbDisableAnimationZOrder )
putShape2BackgroundLayer(
- *maAllShapes.insert(aShapeEntry).first );
+ *maAllShapes.insert(aValue).first );
else
- maAllShapes.insert(aShapeEntry);
+ maAllShapes.insert(aValue);
// update shape, it's just added and not yet painted
if( rShape->isVisible() )
@@ -323,8 +329,7 @@ namespace slideshow
if( maXShapeHash.erase( rShape->getXShape() ) == 0 )
return false; // shape not in map
- OSL_ASSERT( maAllShapes.find(
- ShapeEntry(rShape)) != maAllShapes.end() );
+ OSL_ASSERT( maAllShapes.find(rShape) != maAllShapes.end() );
implRemoveShape( rShape );
@@ -336,9 +341,7 @@ namespace slideshow
OSL_ASSERT( !maLayers.empty() ); // always at least background layer
ENSURE_OR_THROW( rShape, "LayerManager::implRemoveShape(): invalid Shape" );
- const LayerShapeSet::iterator aShapeEntry(
- maAllShapes.find(
- ShapeEntry(rShape)) );
+ const LayerShapeMap::iterator aShapeEntry( maAllShapes.find(rShape) );
if( aShapeEntry == maAllShapes.end() )
return;
@@ -354,7 +357,7 @@ namespace slideshow
(rShape->isVisible() &&
!rShape->isBackgroundDetached()) )
{
- LayerSharedPtr pLayer = aShapeEntry->mpLayer.lock();
+ LayerSharedPtr pLayer = aShapeEntry->second.lock();
if( pLayer )
{
// store area early, once the shape is removed from
@@ -419,8 +422,7 @@ namespace slideshow
if( rOrigShape->revokeSubset( rSubsetShape ) )
{
- OSL_ASSERT( maAllShapes.find(
- ShapeEntry(rSubsetShape)) != maAllShapes.end() );
+ OSL_ASSERT( maAllShapes.find(rSubsetShape) != maAllShapes.end() );
implRemoveShape( rSubsetShape );
@@ -584,11 +586,11 @@ namespace slideshow
bool bIsCurrLayerUpdating(false);
Layer::EndUpdater aEndUpdater;
LayerSharedPtr pCurrLayer;
- LayerShapeSet::const_iterator aIter( maAllShapes.begin() );
- const LayerShapeSet::const_iterator aEnd ( maAllShapes.end() );
+ LayerShapeMap::const_iterator aIter( maAllShapes.begin() );
+ const LayerShapeMap::const_iterator aEnd ( maAllShapes.end() );
while( aIter != aEnd )
{
- LayerSharedPtr pLayer = aIter->mpLayer.lock();
+ LayerSharedPtr pLayer = aIter->second.lock();
if( pLayer != pCurrLayer )
{
pCurrLayer = pLayer;
@@ -599,10 +601,10 @@ namespace slideshow
}
if( bIsCurrLayerUpdating &&
- !aIter->mpShape->isBackgroundDetached() &&
- pCurrLayer->isInsideUpdateArea(aIter->mpShape) )
+ !aIter->first->isBackgroundDetached() &&
+ pCurrLayer->isInsideUpdateArea(aIter->first) )
{
- if( !aIter->mpShape->render() )
+ if( !aIter->first->render() )
bRet = false;
}
@@ -694,8 +696,8 @@ namespace slideshow
bool bRet( true );
ViewLayerSharedPtr pTmpLayer( new DummyLayer( rTargetCanvas ) );
- LayerShapeSet::const_iterator aIter( maAllShapes.begin() );
- const LayerShapeSet::const_iterator aEnd ( maAllShapes.end() );
+ LayerShapeMap::const_iterator aIter( maAllShapes.begin() );
+ const LayerShapeMap::const_iterator aEnd ( maAllShapes.end() );
while( aIter != aEnd )
{
try
@@ -705,11 +707,11 @@ namespace slideshow
// ViewLayer. Since we add the shapes in the
// maShapeSet order (which is also the render order),
// this is equivalent to a subsequent render() call)
- aIter->mpShape->addViewLayer( pTmpLayer,
- true );
+ aIter->first->addViewLayer( pTmpLayer,
+ true );
// and remove again, this is only temporary
- aIter->mpShape->removeViewLayer( pTmpLayer );
+ aIter->first->removeViewLayer( pTmpLayer );
}
catch( uno::Exception& )
{
@@ -735,21 +737,19 @@ namespace slideshow
OSL_ASSERT( !maLayers.empty() ); // always at least background layer
ENSURE_OR_THROW( rShape, "LayerManager::addUpdateArea(): invalid Shape" );
- const LayerShapeSet::const_iterator aShapeEntry(
- maAllShapes.find(
- ShapeEntry(rShape)) );
+ const LayerShapeMap::const_iterator aShapeEntry( maAllShapes.find(rShape) );
if( aShapeEntry == maAllShapes.end() )
return;
- LayerSharedPtr pLayer = aShapeEntry->mpLayer.lock();
+ LayerSharedPtr pLayer = aShapeEntry->second.lock();
if( pLayer )
pLayer->addUpdateRange( rShape->getUpdateArea() );
}
void LayerManager::commitLayerChanges( std::size_t nCurrLayerIndex,
- LayerShapeSet::const_iterator aFirstLayerShape,
- LayerShapeSet::const_iterator aEndLayerShapes )
+ LayerShapeMap::const_iterator aFirstLayerShape,
+ LayerShapeMap::const_iterator aEndLayerShapes )
{
const bool bLayerExists( maLayers.size() > nCurrLayerIndex );
if( bLayerExists )
@@ -768,8 +768,8 @@ namespace slideshow
// render and remove from update set
while( aFirstLayerShape != aEndLayerShapes )
{
- maUpdateShapes.erase(aFirstLayerShape->mpShape);
- aFirstLayerShape->mpShape->render();
+ maUpdateShapes.erase(aFirstLayerShape->first);
+ aFirstLayerShape->first->render();
++aFirstLayerShape;
}
}
@@ -825,13 +825,13 @@ namespace slideshow
std::size_t nCurrLayerIndex(0);
bool bIsBackgroundLayer(true);
bool bLastWasBackgroundDetached(false); // last shape sprite state
- LayerShapeSet::iterator aCurrShapeEntry( maAllShapes.begin() );
- LayerShapeSet::iterator aCurrLayerFirstShapeEntry( maAllShapes.begin() );
- const LayerShapeSet::iterator aEndShapeEntry ( maAllShapes.end() );
+ LayerShapeMap::iterator aCurrShapeEntry( maAllShapes.begin() );
+ LayerShapeMap::iterator aCurrLayerFirstShapeEntry( maAllShapes.begin() );
+ const LayerShapeMap::iterator aEndShapeEntry ( maAllShapes.end() );
ShapeUpdateSet aUpdatedShapes; // shapes that need update
while( aCurrShapeEntry != aEndShapeEntry )
{
- const ShapeSharedPtr pCurrShape( aCurrShapeEntry->mpShape );
+ const ShapeSharedPtr pCurrShape( aCurrShapeEntry->first );
const bool bThisIsBackgroundDetached(
pCurrShape->isBackgroundDetached() );
@@ -851,7 +851,7 @@ namespace slideshow
bIsBackgroundLayer = false;
if( aWeakLayers.size() <= nCurrLayerIndex ||
- aWeakLayers.at(nCurrLayerIndex) != aCurrShapeEntry->mpLayer )
+ aWeakLayers.at(nCurrLayerIndex) != aCurrShapeEntry->second )
{
// no more layers left, or shape was not
// member of this layer - create a new one
@@ -868,7 +868,7 @@ namespace slideshow
// above invalidates iterators
LayerSharedPtr& rCurrLayer( maLayers.at(nCurrLayerIndex) );
LayerWeakPtr& rCurrWeakLayer( aWeakLayers.at(nCurrLayerIndex) );
- if( rCurrWeakLayer != aCurrShapeEntry->mpLayer )
+ if( rCurrWeakLayer != aCurrShapeEntry->second )
{
// mismatch: shape is not contained in current
// layer - move shape to that layer, then.
@@ -879,7 +879,7 @@ namespace slideshow
// non-sprite shape
if( !bThisIsBackgroundDetached && pCurrShape->isVisible() )
{
- LayerSharedPtr pOldLayer( aCurrShapeEntry->mpLayer.lock() );
+ LayerSharedPtr pOldLayer( aCurrShapeEntry->second.lock() );
if( pOldLayer )
{
// old layer still valid? then we need to
@@ -894,10 +894,7 @@ namespace slideshow
maUpdateShapes.insert( pCurrShape );
}
- // std::set iterators are const for a reason - but
- // here, we need modify an aspect of the
- // ShapeEntry that has no influence on sort order
- const_cast<ShapeEntry&>(*aCurrShapeEntry).mpLayer = rCurrWeakLayer;
+ aCurrShapeEntry->second = rCurrWeakLayer;
}
// update layerbounds regardless of the fact that the
diff --git a/slideshow/source/engine/slide/layermanager.hxx b/slideshow/source/engine/slide/layermanager.hxx
index 2fb72af1be18..5a1512bb4f7e 100644
--- a/slideshow/source/engine/slide/layermanager.hxx
+++ b/slideshow/source/engine/slide/layermanager.hxx
@@ -254,33 +254,18 @@ namespace slideshow
hash< ::com::sun::star::uno::Reference<
::com::sun::star::drawing::XShape > > > XShapeHash;
- /** Element of all-shapes set
- */
- struct ShapeEntry
+ class ShapeComparator
{
- /// Shape this entry stands for
- ShapeSharedPtr mpShape;
-
- /// Layer this shape is currently displayed on
- LayerWeakPtr mpLayer;
-
- explicit ShapeEntry( ShapeSharedPtr const& rShape ) :
- mpShape(rShape),
- mpLayer()
- {}
-
- ShapeSharedPtr const& getShape() const { return mpShape; }
-
- bool operator<( const ShapeEntry& rRHS ) const
+ public:
+ bool operator() (const ShapeSharedPtr& rpS1, const ShapeSharedPtr& rpS2 ) const
{
- return Shape::lessThanShape::compare(mpShape.get(),
- rRHS.mpShape.get());
+ return Shape::lessThanShape::compare(rpS1.get(), rpS2.get());
}
};
-
/** Set of all shapes
*/
- typedef ::std::set< ShapeEntry > LayerShapeSet;
+ private:
+ typedef ::std::map< ShapeSharedPtr, LayerWeakPtr, ShapeComparator > LayerShapeMap;
typedef ::std::set< ShapeSharedPtr > ShapeUpdateSet;
@@ -309,12 +294,12 @@ namespace slideshow
denoting one-behind-the-last shape of nCurrLayerIndex
*/
void commitLayerChanges( std::size_t nCurrLayerIndex,
- LayerShapeSet::const_iterator aFirstLayerShape,
- LayerShapeSet::const_iterator aEndLayerShapes );
+ LayerShapeMap::const_iterator aFirstLayerShape,
+ LayerShapeMap::const_iterator aEndLayerShapes );
/** Init Shape layers with background layer.
*/
- void putShape2BackgroundLayer( const ShapeEntry& rShapeEntry );
+ void putShape2BackgroundLayer( LayerShapeMap::value_type& rShapeEntry );
/** Commits any pending layer reorg, due to shapes either
entering or leaving animation mode
@@ -364,7 +349,7 @@ namespace slideshow
for buffering animation enable/disable changes, and
shape update requests.
*/
- LayerShapeSet maAllShapes;
+ LayerShapeMap maAllShapes;
/** Set of shapes that have requested an update
diff --git a/slideshow/source/engine/slideshowimpl.cxx b/slideshow/source/engine/slideshowimpl.cxx
index d8dc7931add1..109e64ca63c1 100644
--- a/slideshow/source/engine/slideshowimpl.cxx
+++ b/slideshow/source/engine/slideshowimpl.cxx
@@ -71,6 +71,7 @@
#include <com/sun/star/animations/TransitionType.hpp>
#include <com/sun/star/animations/TransitionSubType.hpp>
#include <com/sun/star/presentation/XSlideShow.hpp>
+#include <com/sun/star/presentation/XSlideShowListener.hpp>
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/lang/XServiceName.hpp>
#include <com/sun/star/loader/CannotActivateFactoryException.hpp>
@@ -93,6 +94,7 @@
#include "slidebitmap.hxx"
#include "rehearsetimingsactivity.hxx"
#include "waitsymbol.hxx"
+#include "effectrewinder.hxx"
#include "framerate.hxx"
#include <boost/noncopyable.hpp>
@@ -109,6 +111,73 @@ using namespace ::slideshow::internal;
namespace {
+/** During animations the update() method tells its caller to call it as
+ soon as possible. This gives us more time to render the next frame and
+ still maintain a steady frame rate. This class is responsible for
+ synchronizing the display of new frames and thus keeping the frame rate
+ steady.
+*/
+class FrameSynchronization
+{
+public:
+ /** Create new object with a predefined duration between two frames.
+ @param nFrameDuration
+ The preferred duration between the display of two frames in
+ seconds.
+ */
+ FrameSynchronization (const double nFrameDuration);
+
+ /** Set the current time as the time at which the current frame is
+ displayed. From this the target time of the next frame is derived.
+ */
+ void MarkCurrentFrame (void);
+
+ /** When there is time left until the next frame is due then wait.
+ Otherwise return without delay.
+ */
+ void Synchronize (void);
+
+ /** Activate frame synchronization when an animation is active and
+ frames are to be displayed in a steady rate. While active
+ Synchronize() will wait until the frame duration time has passed.
+ */
+ void Activate (void);
+
+ /** Deactivate frame sychronization when no animation is active and the
+ time between frames depends on user actions and other external
+ sources. While deactivated Synchronize() will return without delay.
+ */
+ void Deactivate (void);
+
+ /** Return the current time of the timer. It is not synchronized with
+ any other timer so its absolute values are of no concern. Typically
+ used during debugging to measure durations.
+ */
+ double GetCurrentTime (void) const;
+
+private:
+ /** The timer that is used for synchronization is independent from the
+ one used by SlideShowImpl: it is not paused or modified by
+ animations.
+ */
+ canvas::tools::ElapsedTime maTimer;
+ /** Time between the display of frames. Enforced only when mbIsActive
+ is <TRUE/>.
+ */
+ const double mnFrameDuration;
+ /** Time (of maTimer) when the next frame shall be displayed.
+ Synchronize() will wait until this time.
+ */
+ double mnNextFrameTargetTime;
+ /** Synchronize() will wait only when this flag is <TRUE/>. Otherwise
+ it returns immediately.
+ */
+ bool mbIsActive;
+};
+
+
+
+
/******************************************************************************
SlideShowImpl
@@ -196,7 +265,7 @@ public:
This method notifies the end of the third phase.
*/
- void notifySlideEnded();
+ void notifySlideEnded (const bool bReverse);
/** Notification from eventmultiplexer that a hyperlink
has been clicked.
@@ -211,6 +280,7 @@ public:
private:
// XSlideShow:
virtual sal_Bool SAL_CALL nextEffect() throw (uno::RuntimeException);
+ virtual sal_Bool SAL_CALL previousEffect() throw (uno::RuntimeException);
virtual sal_Bool SAL_CALL startShapeActivity(
uno::Reference<drawing::XShape> const& xShape )
throw (uno::RuntimeException);
@@ -261,6 +331,12 @@ private:
virtual bool requestCursor( sal_Int16 nCursorShape );
virtual void resetCursor();
+ /** This is somewhat similar to displaySlide when called for the current
+ slide. It has been simplified to take advantage of that no slide
+ change takes place. Furthermore it does not show the slide
+ transition.
+ */
+ void redisplayCurrentSlide (void);
protected:
// WeakComponentImplHelperBase
@@ -316,12 +392,32 @@ private:
const SlideSharedPtr& rEnteringSlide,
const EventSharedPtr& rTransitionEndEvent );
- /// Display/hide wait symbol on all views
- void setWaitState( bool bOn );
+ /** Request/release the wait symbol. The wait symbol is displayed when
+ there are more requests then releases. Locking the wait symbol
+ helps to avoid intermediate repaints.
+
+ Do not call this method directly. Use WaitSymbolLock instead.
+ */
+ void requestWaitSymbol (void);
+ void releaseWaitSymbol (void);
+
+ class WaitSymbolLock {public:
+ WaitSymbolLock(SlideShowImpl& rSlideShowImpl) : mrSlideShowImpl(rSlideShowImpl)
+ { mrSlideShowImpl.requestWaitSymbol(); }
+ ~WaitSymbolLock(void)
+ { mrSlideShowImpl.releaseWaitSymbol(); }
+ private: SlideShowImpl& mrSlideShowImpl;
+ };
+
/// Filter requested cursor shape against hard slideshow cursors (wait, etc.)
sal_Int16 calcActiveCursor( sal_Int16 nCursorShape ) const;
+ /** This method is called asynchronously to finish the rewinding of an
+ effect to the previous slide that was initiated earlier.
+ */
+ void rewindEffectToPreviousSlide (void);
+
/// all registered views
UnoViewContainer maViewContainer;
@@ -368,7 +464,7 @@ private:
sal_Int16 mnCurrentCursor;
- bool mbWaitState;
+ sal_Int32 mnWaitSymbolRequestCount;
bool mbAutomaticAdvancementMode;
bool mbImageAnimationsAllowed;
bool mbNoSlideTransitions;
@@ -377,6 +473,9 @@ private:
bool mbShowPaused;
bool mbSlideShowIdle;
bool mbDisableAnimationZOrder;
+
+ EffectRewinder maEffectRewinder;
+ FrameSynchronization maFrameSynchronization;
};
@@ -411,10 +510,14 @@ struct SlideShowImpl::SeparateListenerImpl : public EventHandler,
// directly, but queue an event. handleEvent()
// might be called from e.g.
// showNext(), and notifySlideAnimationsEnded() must not be called
- // in recursion.
- mrEventQueue.addEvent(
- makeEvent( boost::bind( &SlideShowImpl::notifySlideAnimationsEnded,
- boost::ref(mrShow) )));
+ // in recursion. Note that the event is scheduled for the next
+ // frame so that its expensive execution does not come in between
+ // sprite hiding and shape redraw (at the end of the animation of a
+ // shape), which would cause a flicker.
+ mrEventQueue.addEventForNextRound(
+ makeEvent(
+ boost::bind( &SlideShowImpl::notifySlideAnimationsEnded, boost::ref(mrShow) ),
+ "SlideShowImpl::notifySlideAnimationsEnded"));
return true;
}
@@ -468,7 +571,7 @@ SlideShowImpl::SlideShowImpl(
mxPrefetchSlide(),
mxPrefetchAnimationNode(),
mnCurrentCursor(awt::SystemPointer::ARROW),
- mbWaitState(false),
+ mnWaitSymbolRequestCount(0),
mbAutomaticAdvancementMode(false),
mbImageAnimationsAllowed( true ),
mbNoSlideTransitions( false ),
@@ -476,7 +579,10 @@ SlideShowImpl::SlideShowImpl(
mbForceManualAdvance( false ),
mbShowPaused( false ),
mbSlideShowIdle( true ),
- mbDisableAnimationZOrder( false )
+ mbDisableAnimationZOrder( false ),
+ maEffectRewinder(maEventMultiplexer, maEventQueue, maUserEventQueue),
+ maFrameSynchronization(1.0 / FrameRate::PreferredFramesPerSecond)
+
{
// keep care not constructing any UNO references to this inside ctor,
// shift that code to create()!
@@ -516,6 +622,8 @@ void SlideShowImpl::disposing()
{
osl::MutexGuard const guard( m_aMutex );
+ maEffectRewinder.dispose();
+
// stop slide transition sound, if any:
stopSlideTransitionSound();
@@ -616,7 +724,7 @@ ActivitySharedPtr SlideShowImpl::createSlideTransition(
const uno::Reference< drawing::XDrawPage >& xDrawPage,
const SlideSharedPtr& rLeavingSlide,
const SlideSharedPtr& rEnteringSlide,
- const EventSharedPtr& rTransitionEndEvent )
+ const EventSharedPtr& rTransitionEndEvent)
{
ENSURE_OR_THROW( !maViewContainer.empty(),
"createSlideTransition(): No views" );
@@ -736,7 +844,8 @@ ActivitySharedPtr SlideShowImpl::createSlideTransition(
&::slideshow::internal::Animation::prefetch,
pTransition,
AnimatableShapeSharedPtr(),
- ShapeAttributeLayerSharedPtr())));
+ ShapeAttributeLayerSharedPtr()),
+ "Animation::prefetch"));
return ActivitySharedPtr(
ActivitiesFactory::createSimpleActivity(
@@ -787,20 +896,43 @@ SlideSharedPtr SlideShowImpl::makeSlide(
return pSlide;
}
-void SlideShowImpl::setWaitState( bool bOn )
+void SlideShowImpl::requestWaitSymbol (void)
{
- mbWaitState = bOn;
- if( !mpWaitSymbol ) // fallback to cursor
- requestCursor(awt::SystemPointer::WAIT);
- else if( mbWaitState )
- mpWaitSymbol->show();
- else
- mpWaitSymbol->hide();
+ ++mnWaitSymbolRequestCount;
+ OSL_ASSERT(mnWaitSymbolRequestCount>0);
+
+ if (mnWaitSymbolRequestCount == 1)
+ {
+ if( !mpWaitSymbol )
+ {
+ // fall back to cursor
+ requestCursor(calcActiveCursor(mnCurrentCursor));
+ }
+ else
+ mpWaitSymbol->show();
+ }
+}
+
+void SlideShowImpl::releaseWaitSymbol (void)
+{
+ --mnWaitSymbolRequestCount;
+ OSL_ASSERT(mnWaitSymbolRequestCount>=0);
+
+ if (mnWaitSymbolRequestCount == 0)
+ {
+ if( !mpWaitSymbol )
+ {
+ // fall back to cursor
+ requestCursor(calcActiveCursor(mnCurrentCursor));
+ }
+ else
+ mpWaitSymbol->hide();
+ }
}
sal_Int16 SlideShowImpl::calcActiveCursor( sal_Int16 nCursorShape ) const
{
- if( mbWaitState && !mpWaitSymbol ) // enforce wait cursor
+ if( mnWaitSymbolRequestCount>0 && !mpWaitSymbol ) // enforce wait cursor
nCursorShape = awt::SystemPointer::WAIT;
else if( !mbMouseVisible ) // enforce INVISIBLE
nCursorShape = awt::SystemPointer::INVISIBLE;
@@ -844,10 +976,19 @@ void SlideShowImpl::stopShow()
}
}
-struct SlideShowImpl::PrefetchPropertiesFunc
+
+
+class SlideShowImpl::PrefetchPropertiesFunc
{
- SlideShowImpl *const that;
- PrefetchPropertiesFunc( SlideShowImpl * that_ ) : that(that_) {}
+public:
+ PrefetchPropertiesFunc( SlideShowImpl * that_,
+ bool& rbSkipAllMainSequenceEffects,
+ bool& rbSkipSlideTransition)
+ : mpSlideShowImpl(that_),
+ mrbSkipAllMainSequenceEffects(rbSkipAllMainSequenceEffects),
+ mrbSkipSlideTransition(rbSkipSlideTransition)
+ {}
+
void operator()( beans::PropertyValue const& rProperty ) const {
if (rProperty.Name.equalsAsciiL(
RTL_CONSTASCII_STRINGPARAM("Prefetch") ))
@@ -855,16 +996,30 @@ struct SlideShowImpl::PrefetchPropertiesFunc
uno::Sequence<uno::Any> seq;
if ((rProperty.Value >>= seq) && seq.getLength() == 2)
{
- seq[0] >>= that->mxPrefetchSlide;
- seq[1] >>= that->mxPrefetchAnimationNode;
+ seq[0] >>= mpSlideShowImpl->mxPrefetchSlide;
+ seq[1] >>= mpSlideShowImpl->mxPrefetchAnimationNode;
}
}
+ else if (rProperty.Name.equalsAsciiL(
+ RTL_CONSTASCII_STRINGPARAM("SkipAllMainSequenceEffects") ))
+ {
+ rProperty.Value >>= mrbSkipAllMainSequenceEffects;
+ }
+ else if (rProperty.Name.equalsAsciiL(
+ RTL_CONSTASCII_STRINGPARAM("SkipSlideTransition") ))
+ {
+ rProperty.Value >>= mrbSkipSlideTransition;
+ }
else
{
OSL_ENSURE( false, rtl::OUStringToOString(
rProperty.Name, RTL_TEXTENCODING_UTF8 ).getStr() );
}
}
+private:
+ SlideShowImpl *const mpSlideShowImpl;
+ bool& mrbSkipAllMainSequenceEffects;
+ bool& mrbSkipSlideTransition;
};
void SlideShowImpl::displaySlide(
@@ -878,6 +1033,8 @@ void SlideShowImpl::displaySlide(
if (isDisposed())
return;
+ maEffectRewinder.setRootAnimationNode(xRootNode);
+
// precondition: must only be called from the main thread!
DBG_TESTSOLARMUTEX();
@@ -890,9 +1047,11 @@ void SlideShowImpl::displaySlide(
// shape animations (drawing layer and
// GIF) will not be stopped.
+ bool bSkipAllMainSequenceEffects (false);
+ bool bSkipSlideTransition (false);
std::for_each( rProperties.getConstArray(),
rProperties.getConstArray() + rProperties.getLength(),
- PrefetchPropertiesFunc(this) );
+ PrefetchPropertiesFunc(this, bSkipAllMainSequenceEffects, bSkipSlideTransition) );
OSL_ENSURE( !maViewContainer.empty(), "### no views!" );
if (maViewContainer.empty())
@@ -900,9 +1059,7 @@ void SlideShowImpl::displaySlide(
// this here might take some time
{
- comphelper::ScopeGuard const scopeGuard(
- boost::bind( &SlideShowImpl::setWaitState, this, false ) );
- setWaitState(true);
+ WaitSymbolLock aLock (*this);
mpPreviousSlide = mpCurrentSlide;
mpCurrentSlide.reset();
@@ -944,15 +1101,26 @@ void SlideShowImpl::displaySlide(
// create slide transition, and add proper end event
// (which then starts the slide effects
// via CURRENT_SLIDE.show())
- ActivitySharedPtr const pSlideChangeActivity(
- createSlideTransition( mpCurrentSlide->getXDrawPage(),
- mpPreviousSlide,
- mpCurrentSlide,
- makeEvent(
- boost::bind(
- &SlideShowImpl::notifySlideTransitionEnded,
- this,
- false ))));
+ ActivitySharedPtr pSlideChangeActivity (
+ createSlideTransition(
+ mpCurrentSlide->getXDrawPage(),
+ mpPreviousSlide,
+ mpCurrentSlide,
+ makeEvent(
+ boost::bind(
+ &SlideShowImpl::notifySlideTransitionEnded,
+ this,
+ false ),
+ "SlideShowImpl::notifySlideTransitionEnded")));
+
+ if (bSkipSlideTransition)
+ {
+ // The transition activity was created for the side effects
+ // (like sound transitions). Because we want to skip the
+ // acutual transition animation we do not need the activity
+ // anymore.
+ pSlideChangeActivity.reset();
+ }
if (pSlideChangeActivity)
{
@@ -968,7 +1136,8 @@ void SlideShowImpl::displaySlide(
boost::bind(
&SlideShowImpl::notifySlideTransitionEnded,
this,
- true )));
+ true ),
+ "SlideShowImpl::notifySlideTransitionEnded"));
}
}
} // finally
@@ -976,6 +1145,42 @@ void SlideShowImpl::displaySlide(
maEventMultiplexer.notifySlideTransitionStarted();
maListenerContainer.forEach<presentation::XSlideShowListener>(
boost::mem_fn( &presentation::XSlideShowListener::slideTransitionStarted ) );
+
+ // We are currently rewinding an effect. This lead us from the next
+ // slide to this one. To complete this we have to play back all main
+ // sequence effects on this slide.
+ if (bSkipAllMainSequenceEffects)
+ maEffectRewinder.skipAllMainSequenceEffects();
+}
+
+void SlideShowImpl::redisplayCurrentSlide (void)
+{
+ osl::MutexGuard const guard( m_aMutex );
+
+ if (isDisposed())
+ return;
+
+ // precondition: must only be called from the main thread!
+ DBG_TESTSOLARMUTEX();
+ stopShow();
+
+ OSL_ENSURE( !maViewContainer.empty(), "### no views!" );
+ if (maViewContainer.empty())
+ return;
+
+ // No transition effect on this slide - schedule slide
+ // effect start event right away.
+ maEventQueue.addEvent(
+ makeEvent(
+ boost::bind(
+ &SlideShowImpl::notifySlideTransitionEnded,
+ this,
+ true ),
+ "SlideShowImpl::notifySlideTransitionEnded"));
+
+ maEventMultiplexer.notifySlideTransitionStarted();
+ maListenerContainer.forEach<presentation::XSlideShowListener>(
+ boost::mem_fn( &presentation::XSlideShowListener::slideTransitionStarted ) );
}
sal_Bool SlideShowImpl::nextEffect() throw (uno::RuntimeException)
@@ -994,6 +1199,50 @@ sal_Bool SlideShowImpl::nextEffect() throw (uno::RuntimeException)
return maEventMultiplexer.notifyNextEffect();
}
+
+sal_Bool SlideShowImpl::previousEffect() throw (uno::RuntimeException)
+{
+ osl::MutexGuard const guard( m_aMutex );
+
+ if (isDisposed())
+ return false;
+
+ // precondition: must only be called from the main thread!
+ DBG_TESTSOLARMUTEX();
+
+ if (mbShowPaused)
+ return true;
+ else
+ {
+ return maEffectRewinder.rewind(
+ maScreenUpdater.createLock(false),
+ ::boost::bind<void>(::boost::mem_fn(&SlideShowImpl::redisplayCurrentSlide), this),
+ ::boost::bind<void>(::boost::mem_fn(&SlideShowImpl::rewindEffectToPreviousSlide), this));
+ }
+}
+
+void SlideShowImpl::rewindEffectToPreviousSlide (void)
+{
+ // Show the wait symbol now and prevent it from showing temporary slide
+ // content while effects are played back.
+ WaitSymbolLock aLock (*this);
+
+ // A previous call to EffectRewinder::Rewind could not rewind the current
+ // effect because there are no effects on the current slide or none has
+ // yet been displayed. Go to the previous slide.
+ notifySlideEnded(true);
+
+ // Process pending events once more in order to have the following
+ // screen update show the last effect. Not sure whether this should be
+ // necessary.
+ maEventQueue.forceEmpty();
+
+ // We have to call the screen updater before the wait symbol is turned
+ // off. Otherwise the wait symbol would force the display of an
+ // intermediate state of the slide (before the effects are replayed.)
+ maScreenUpdater.commitUpdates();
+}
+
sal_Bool SlideShowImpl::startShapeActivity(
uno::Reference<drawing::XShape> const& /*xShape*/ )
throw (uno::RuntimeException)
@@ -1290,6 +1539,34 @@ sal_Bool SlideShowImpl::setProperty( beans::PropertyValue const& rProperty )
return (rProperty.Value >>= mbNoSlideTransitions);
}
+ if (rProperty.Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("IsSoundEnabled")))
+ {
+ uno::Sequence<uno::Any> aValues;
+ uno::Reference<presentation::XSlideShowView> xView;
+ sal_Bool bValue (false);
+ if ((rProperty.Value >>= aValues)
+ && aValues.getLength()==2
+ && (aValues[0] >>= xView)
+ && (aValues[1] >>= bValue))
+ {
+ // Look up the view.
+ for (UnoViewVector::const_iterator
+ iView (maViewContainer.begin()),
+ iEnd (maViewContainer.end());
+ iView!=iEnd;
+ ++iView)
+ {
+ if (*iView && (*iView)->getUnoView()==xView)
+ {
+ // Store the flag at the view so that media shapes have
+ // access to it.
+ (*iView)->setIsSoundEnabled(bValue);
+ return true;
+ }
+ }
+ }
+ }
+
return false;
}
@@ -1471,25 +1748,24 @@ sal_Bool SlideShowImpl::update( double & nNextTimeout )
// TODO(F2): re-evaluate whether that timer lagging makes
// sense.
- // hold timer, while processing the queues (ensures
- // same time for all activities and events)
+ // hold timer, while processing the queues:
+ // 1. when there is more than one active activity this ensures the
+ // same time for all activities and events
+ // 2. processing of events may lead to creation of further events
+ // that have zero delay. While the timer is stopped these events
+ // are processed in the same run.
{
comphelper::ScopeGuard scopeGuard(
boost::bind( &canvas::tools::ElapsedTime::releaseTimer,
boost::cref(mpPresTimer) ) );
-
- // no need to hold timer for only one active animation -
- // it's only meant to keep multiple ones in sync
- if( maActivitiesQueue.size() > 1 )
- mpPresTimer->holdTimer();
- else
- scopeGuard.dismiss(); // we're not holding the timer
+ mpPresTimer->holdTimer();
// process queues
maEventQueue.process();
maActivitiesQueue.process();
// commit frame to screen
+ maFrameSynchronization.Synchronize();
maScreenUpdater.commitUpdates();
// TODO(Q3): remove need to call dequeued() from
@@ -1533,7 +1809,13 @@ sal_Bool SlideShowImpl::update( double & nNextTimeout )
{
// Activity queue is not empty. Tell caller that we would
// like to render another frame.
- nNextTimeout = 1.0 / FrameRate::PreferredFramesPerSecond;
+
+ // Return a zero time-out to signal our caller to call us
+ // back as soon as possible. The actual timing, waiting the
+ // appropriate amount of time between frames, is then done
+ // by the maFrameSynchronization object.
+ nNextTimeout = 0;
+ maFrameSynchronization.Activate();
}
else
{
@@ -1547,6 +1829,10 @@ sal_Bool SlideShowImpl::update( double & nNextTimeout )
// ensure positive value:
nNextTimeout = std::max( 0.0, maEventQueue.nextTimeout() );
+
+ // There is no active animation so the frame rate does not
+ // need to be synchronized.
+ maFrameSynchronization.Deactivate();
}
mbSlideShowIdle = false;
@@ -1668,7 +1954,7 @@ void SlideShowImpl::notifySlideAnimationsEnded()
// schedule a slide end event, with automatic mode's
// delay
aNotificationEvents = makeInterruptableDelay(
- boost::bind<void>( boost::mem_fn(&SlideShowImpl::notifySlideEnded), this ),
+ boost::bind<void>( boost::mem_fn(&SlideShowImpl::notifySlideEnded), this, false ),
maEventMultiplexer.getAutomaticTimeout() );
}
else
@@ -1693,7 +1979,7 @@ void SlideShowImpl::notifySlideAnimationsEnded()
bHasAutomaticNextSlide )
{
aNotificationEvents = makeInterruptableDelay(
- boost::bind<void>( boost::mem_fn(&SlideShowImpl::notifySlideEnded), this ),
+ boost::bind<void>( boost::mem_fn(&SlideShowImpl::notifySlideEnded), this, false ),
nAutomaticNextSlideTimeout);
// TODO(F2): Provide a mechanism to let the user override
@@ -1710,7 +1996,8 @@ void SlideShowImpl::notifySlideAnimationsEnded()
// timeout involved.
aNotificationEvents.mpImmediateEvent =
makeEvent( boost::bind<void>(
- boost::mem_fn(&SlideShowImpl::notifySlideEnded), this ) );
+ boost::mem_fn(&SlideShowImpl::notifySlideEnded), this, false ),
+ "SlideShowImpl::notifySlideEnded");
}
}
@@ -1731,9 +2018,7 @@ void SlideShowImpl::notifySlideAnimationsEnded()
// change setup time a lot). Show the wait cursor, this
// indeed might take some seconds.
{
- comphelper::ScopeGuard const scopeGuard(
- boost::bind( &SlideShowImpl::setWaitState, this, false ) );
- setWaitState(true);
+ WaitSymbolLock aLock (*this);
if (! matches( mpPrefetchSlide,
mxPrefetchSlide, mxPrefetchAnimationNode ))
@@ -1755,13 +2040,13 @@ void SlideShowImpl::notifySlideAnimationsEnded()
boost::mem_fn( &presentation::XSlideShowListener::slideAnimationsEnded ) );
}
-void SlideShowImpl::notifySlideEnded()
+void SlideShowImpl::notifySlideEnded (const bool bReverse)
{
osl::MutexGuard const guard( m_aMutex );
OSL_ENSURE( !isDisposed(), "### already disposed!" );
- if (mpRehearseTimingsActivity)
+ if (mpRehearseTimingsActivity && !bReverse)
{
const double time = mpRehearseTimingsActivity->stop();
if (mpRehearseTimingsActivity->hasBeenClicked())
@@ -1782,7 +2067,8 @@ void SlideShowImpl::notifySlideEnded()
}
}
- maEventMultiplexer.notifySlideEndEvent();
+ if (bReverse)
+ maEventMultiplexer.notifySlideEndEvent();
stopShow(); // MUST call that: results in
// maUserEventQueue.clear(). What's more,
@@ -1794,7 +2080,10 @@ void SlideShowImpl::notifySlideEnded()
// GIF) will not be stopped.
maListenerContainer.forEach<presentation::XSlideShowListener>(
- boost::mem_fn( &presentation::XSlideShowListener::slideEnded ) );
+ boost::bind<void>(
+ ::boost::mem_fn(&presentation::XSlideShowListener::slideEnded),
+ _1,
+ sal_Bool(bReverse)));
}
bool SlideShowImpl::notifyHyperLinkClicked( rtl::OUString const& hyperLink )
@@ -1840,6 +2129,66 @@ bool SlideShowImpl::handleAnimationEvent( const AnimationNodeSharedPtr& rNode )
return true;
}
+
+//===== FrameSynchronization ==================================================
+
+FrameSynchronization::FrameSynchronization (const double nFrameDuration)
+ : maTimer(),
+ mnFrameDuration(nFrameDuration),
+ mnNextFrameTargetTime(0),
+ mbIsActive(false)
+{
+ MarkCurrentFrame();
+}
+
+
+
+
+void FrameSynchronization::MarkCurrentFrame (void)
+{
+ mnNextFrameTargetTime = maTimer.getElapsedTime() + mnFrameDuration;
+}
+
+
+
+
+void FrameSynchronization::Synchronize (void)
+{
+ if (mbIsActive)
+ {
+ // Do busy waiting for now.
+ while (maTimer.getElapsedTime() < mnNextFrameTargetTime)
+ ;
+ }
+
+ MarkCurrentFrame();
+}
+
+
+
+
+void FrameSynchronization::Activate (void)
+{
+ mbIsActive = true;
+}
+
+
+
+
+void FrameSynchronization::Deactivate (void)
+{
+ mbIsActive = false;
+}
+
+
+
+
+double FrameSynchronization::GetCurrentTime (void) const
+{
+ return maTimer.getElapsedTime();
+}
+
+
} // anon namespace
namespace sdecl = comphelper::service_decl;
diff --git a/slideshow/source/engine/slideview.cxx b/slideshow/source/engine/slideview.cxx
index 9d48612457b3..dcca4a51b4d7 100644
--- a/slideshow/source/engine/slideview.cxx
+++ b/slideshow/source/engine/slideview.cxx
@@ -715,6 +715,8 @@ private:
// UnoView:
virtual void _dispose();
virtual uno::Reference<presentation::XSlideShowView> getUnoView()const;
+ virtual void setIsSoundEnabled (const bool bValue);
+ virtual bool isSoundEnabled (void) const;
// XEventListener:
virtual void SAL_CALL disposing( lang::EventObject const& evt )
@@ -755,6 +757,7 @@ private:
basegfx::B2DHomMatrix maViewTransform;
basegfx::B2DSize maUserSize;
+ bool mbIsSoundEnabled;
};
@@ -770,7 +773,8 @@ SlideView::SlideView( const uno::Reference<presentation::XSlideShowView>& xView,
maViewLayers(),
maClip(),
maViewTransform(),
- maUserSize( 1.0, 1.0 ) // default size: one-by-one rectangle
+ maUserSize( 1.0, 1.0 ), // default size: one-by-one rectangle
+ mbIsSoundEnabled(true)
{
// take care not constructing any UNO references to this _inside_
// ctor, shift that code to createSlideView()!
@@ -1001,6 +1005,16 @@ uno::Reference<presentation::XSlideShowView> SlideView::getUnoView() const
return mxView;
}
+void SlideView::setIsSoundEnabled (const bool bValue)
+{
+ mbIsSoundEnabled = bValue;
+}
+
+bool SlideView::isSoundEnabled (void) const
+{
+ return mbIsSoundEnabled;
+}
+
void SlideView::_dispose()
{
dispose();
@@ -1071,7 +1085,8 @@ void SlideView::modified( const lang::EventObject& /*aEvent*/ )
makeEvent( boost::bind( (bool (EventMultiplexer::*)(
const uno::Reference<presentation::XSlideShowView>&))
&EventMultiplexer::notifyViewChanged,
- boost::ref(mrEventMultiplexer), mxView )));
+ boost::ref(mrEventMultiplexer), mxView ),
+ "EventMultiplexer::notifyViewChanged"));
}
// XPaintListener
@@ -1086,7 +1101,8 @@ void SlideView::windowPaint( const awt::PaintEvent& /*e*/ )
// this might not be the main thread!
mrEventQueue.addEvent(
makeEvent( boost::bind( &EventMultiplexer::notifyViewClobbered,
- boost::ref(mrEventMultiplexer), mxView ) ) );
+ boost::ref(mrEventMultiplexer), mxView ),
+ "EventMultiplexer::notifyViewClobbered") );
}
void SlideView::updateCanvas()
diff --git a/slideshow/source/engine/usereventqueue.cxx b/slideshow/source/engine/usereventqueue.cxx
index ac7f39174118..4415599f84d8 100644
--- a/slideshow/source/engine/usereventqueue.cxx
+++ b/slideshow/source/engine/usereventqueue.cxx
@@ -306,26 +306,45 @@ public:
EventMultiplexer & rEventMultiplexer )
: ClickEventHandler(rEventQueue),
mrEventQueue(rEventQueue),
- mrEventMultiplexer(rEventMultiplexer) {}
+ mrEventMultiplexer(rEventMultiplexer),
+ mbSkipTriggersNextEffect(true) {}
+
+ /** Remember to trigger (or not to trigger) the next effect after the
+ current effect is skiped.
+ */
+ void setSkipTriggersNextEffect (const bool bSkipTriggersNextEffect)
+ { mbSkipTriggersNextEffect = bSkipTriggersNextEffect; }
+
+ /// Skip the current effect but do not triggere the next effect.
+ void skipEffect (void) { handleEvent_impl(false); }
private:
virtual bool handleEvent_impl()
{
+ return handleEvent_impl(true);
+ }
+
+ bool handleEvent_impl (bool bNotifyNextEffect)
+ {
// fire all events, so animation nodes can register their
// next effect listeners:
if(fireAllEvents( maEvents, mrEventQueue ))
{
- // then simulate a next effect event:
- // this skip effect handler is triggered upon next effect
- // events (multiplexer prio=-1)!
- // Posting a notifyNextEffect() here is only safe
- // (we don't run into busy loop), because we assume that
- // someone has registerered above for next effects
- // (multiplexer prio=0) at the user event queue.
- return mrEventQueue.addEventForNextRound(
- makeEvent( boost::bind(
- &EventMultiplexer::notifyNextEffect,
- boost::ref(mrEventMultiplexer) ) ) );
+ if (mbSkipTriggersNextEffect && bNotifyNextEffect)
+ {
+ // then simulate a next effect event: this skip effect
+ // handler is triggered upon next effect events (multiplexer
+ // prio=-1)! Posting a notifyNextEffect() here is only safe
+ // (we don't run into busy loop), because we assume that
+ // someone has registerered above for next effects
+ // (multiplexer prio=0) at the user event queue.
+ return mrEventQueue.addEventWhenQueueIsEmpty(
+ makeEvent( boost::bind( &EventMultiplexer::notifyNextEffect,
+ boost::ref(mrEventMultiplexer) ),
+ "EventMultiplexer::notifyNextEffect") );
+ }
+ else
+ return true;
}
return false;
}
@@ -333,6 +352,7 @@ private:
private:
EventQueue & mrEventQueue;
EventMultiplexer & mrEventMultiplexer;
+ bool mbSkipTriggersNextEffect;
};
class RewindEffectEventHandler : public MouseEventHandler_,
@@ -772,6 +792,7 @@ void UserEventQueue::setAdvanceOnClick( bool bAdvanceOnClick )
mpClickEventHandler->setAdvanceOnClick( bAdvanceOnClick );
}
+
void UserEventQueue::registerSlideStartEvent( const EventSharedPtr& rEvent )
{
registerEvent( mpStartEventHandler,
@@ -888,7 +909,9 @@ void UserEventQueue::registerNextEffectEvent( const EventSharedPtr& rEvent )
mbAdvanceOnClick ) );
}
-void UserEventQueue::registerSkipEffectEvent( EventSharedPtr const & pEvent )
+void UserEventQueue::registerSkipEffectEvent(
+ EventSharedPtr const & pEvent,
+ const bool bSkipTriggersNextEffect)
{
if(!mpSkipEffectEventHandler)
{
@@ -905,6 +928,7 @@ void UserEventQueue::registerSkipEffectEvent( EventSharedPtr const & pEvent )
// we're called here)
mpSkipEffectEventHandler->setAdvanceOnClick( mbAdvanceOnClick );
}
+ mpSkipEffectEventHandler->setSkipTriggersNextEffect(bSkipTriggersNextEffect);
mpSkipEffectEventHandler->addEvent( pEvent );
}
@@ -973,6 +997,14 @@ void UserEventQueue::registerMouseLeaveEvent( const EventSharedPtr& rEvent,
0.0 /* default prio */ ) );
}
+void UserEventQueue::callSkipEffectEventHandler (void)
+{
+ ::boost::shared_ptr<SkipEffectEventHandler> pHandler (
+ ::boost::dynamic_pointer_cast<SkipEffectEventHandler>(mpSkipEffectEventHandler));
+ if (pHandler)
+ pHandler->skipEffect();
+}
+
} // namespace internal
} // namespace presentation
diff --git a/slideshow/source/engine/wakeupevent.cxx b/slideshow/source/engine/wakeupevent.cxx
index 0b30510f9cb3..d2e13d188e14 100644
--- a/slideshow/source/engine/wakeupevent.cxx
+++ b/slideshow/source/engine/wakeupevent.cxx
@@ -45,6 +45,9 @@ namespace slideshow
WakeupEvent::WakeupEvent(
boost::shared_ptr<canvas::tools::ElapsedTime> const & pTimeBase,
ActivitiesQueue& rActivityQueue ) :
+#if OSL_DEBUG_LEVEL > 1
+ Event(::rtl::OUString::createFromAscii("WakeupEvent")),
+#endif
maTimer(pTimeBase),
mnNextTime(0.0),
mpActivity(),
diff --git a/slideshow/source/inc/debug.hxx b/slideshow/source/inc/debug.hxx
new file mode 100644
index 000000000000..53c031231370
--- /dev/null
+++ b/slideshow/source/inc/debug.hxx
@@ -0,0 +1,80 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2008 by Sun Microsystems, Inc.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * $RCSfile: layer.hxx,v $
+ * $Revision: 1.3 $
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#ifndef INCLUDED_SLIDESHOW_DEBUG_HXX
+#define INCLUDED_SLIDESHOW_DEBUG_HXX
+
+#include <osl/diagnose.h>
+
+#if OSL_DEBUG_LEVEL > 1
+
+#include "animationnode.hxx"
+
+
+namespace slideshow { namespace internal {
+
+void Debug_ShowNodeTree (const AnimationNodeSharedPtr& rpNode);
+
+// Change this to a valid filename. The file is created anew with every
+// office start (and execution of at least one TRACE... command.)
+#define TRACE_LOG_FILE_NAME "d:\\tmp\\log.txt"
+
+class DebugTraceScope
+{
+public:
+ DebugTraceScope (const sal_Char* sFormat, ...);
+ ~DebugTraceScope (void);
+private:
+ static const sal_Int32 mnBufferSize = 512;
+ sal_Char* msMessage;
+};
+
+void SAL_CALL DebugTraceBegin (const sal_Char* sFormat, ...);
+void SAL_CALL DebugTraceEnd (const sal_Char* sFormat, ...);
+void SAL_CALL DebugTraceMessage (const sal_Char* sFormat, ...);
+
+} } // end of namespace ::slideshow::internal
+
+
+#define TRACE_BEGIN DebugTraceBegin
+#define TRACE_END DebugTraceEnd
+#define TRACE DebugTraceMessage
+#define TRACE_SCOPE DebugTraceScope aTraceScope
+
+#else // OSL_DEBUG_LEVEL > 1
+
+#define TRACE_BEGIN 1 ? ((void)0) : DebugTraceBegin
+#define TRACE_END 1 ? ((void)0) : DebugTraceEnd
+#define TRACE 1 ? ((void)0) : DebugTraceMessage
+#define TRACE_SCOPE
+
+#endif // OSL_DEBUG_LEVEL > 1
+
+#endif
diff --git a/slideshow/source/inc/delayevent.hxx b/slideshow/source/inc/delayevent.hxx
index 10960e395feb..1c4e09faa7da 100644
--- a/slideshow/source/inc/delayevent.hxx
+++ b/slideshow/source/inc/delayevent.hxx
@@ -33,6 +33,7 @@
#include <boost/function.hpp>
#include "event.hxx"
+#include "debug.hxx"
#include <boost/noncopyable.hpp>
namespace slideshow {
@@ -46,16 +47,23 @@ public:
typedef ::boost::function0<void> FunctorT;
template <typename FuncT>
- Delay( FuncT const& func, double nTimeout )
- : mnTimeout(nTimeout), maFunc(func), mbWasFired(false) {}
+ Delay( FuncT const& func,
+ double nTimeout
+#if OSL_DEBUG_LEVEL > 1
+ , const ::rtl::OUString& rsDescription
+ ) : Event(rsDescription),
+#else
+ ) :
+#endif
+ mnTimeout(nTimeout), maFunc(func), mbWasFired(false) {}
-#if defined(VERBOSE) && defined(DBG_UTIL)
Delay( const boost::function0<void>& func,
- double nTimeout,
- char const* const ) :
+ double nTimeout
+#if OSL_DEBUG_LEVEL > 1
+ , const ::rtl::OUString& rsDescription
+ ) : Event(rsDescription),
#else
- Delay( const boost::function0<void>& func,
- double nTimeout ) :
+ ) :
#endif
mnTimeout(nTimeout),
maFunc(func),
@@ -74,7 +82,7 @@ private:
bool mbWasFired;
};
-#if OSL_DEBUG_LEVEL < 1
+#if OSL_DEBUG_LEVEL <= 1
/** Generate delay event
@@ -87,7 +95,7 @@ private:
@return generated delay event
*/
template <typename FuncT>
-inline EventSharedPtr makeDelay( FuncT const& func, double nTimeout )
+inline EventSharedPtr makeDelay_( FuncT const& func, double nTimeout )
{
return EventSharedPtr( new Delay( func, nTimeout ) );
}
@@ -100,19 +108,25 @@ inline EventSharedPtr makeDelay( FuncT const& func, double nTimeout )
@return generated immediate event.
*/
template <typename FuncT>
-inline EventSharedPtr makeEvent( FuncT const& func )
+inline EventSharedPtr makeEvent_( FuncT const& func )
{
return EventSharedPtr( new Delay( func, 0.0 ) );
}
+
+// Strip away description.
+#define makeDelay(f, t, d) makeDelay_(f, t)
+#define makeEvent(f, d) makeEvent_(f)
+
#else // OSL_DEBUG_LEVEL > 1
class Delay_ : public Delay {
public:
template <typename FuncT>
Delay_( FuncT const& func, double nTimeout,
- char const* from_function, char const* from_file, int from_line )
- : Delay(func, nTimeout),
+ char const* from_function, char const* from_file, int from_line,
+ const ::rtl::OUString& rsDescription)
+ : Delay(func, nTimeout, rsDescription),
FROM_FUNCTION(from_function),
FROM_FILE(from_file), FROM_LINE(from_line) {}
@@ -124,18 +138,21 @@ public:
template <typename FuncT>
inline EventSharedPtr makeDelay_(
FuncT const& func, double nTimeout,
- char const* from_function, char const* from_file, int from_line )
+ char const* from_function, char const* from_file, int from_line,
+ const ::rtl::OUString& rsDescription)
{
return EventSharedPtr( new Delay_( func, nTimeout,
- from_function, from_file, from_line ) );
+ from_function, from_file, from_line, rsDescription) );
}
-#define makeDelay(f, t) makeDelay_(f, t, \
-BOOST_CURRENT_FUNCTION, __FILE__, __LINE__)
-#define makeEvent(f) makeDelay_(f, 0.0, \
-BOOST_CURRENT_FUNCTION, __FILE__, __LINE__)
+#define makeDelay(f, t, d) makeDelay_(f, t, \
+ BOOST_CURRENT_FUNCTION, __FILE__, __LINE__, \
+ ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(d)))
+#define makeEvent(f, d) makeDelay_(f, 0.0, \
+ BOOST_CURRENT_FUNCTION, __FILE__, __LINE__, \
+ ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(d)))
-#endif // OSL_DEBUG_LEVEL < 1
+#endif // OSL_DEBUG_LEVEL <= 1
} // namespace internal
} // namespace presentation
diff --git a/slideshow/source/inc/event.hxx b/slideshow/source/inc/event.hxx
index 80e825cc8049..6e41e5c30123 100644
--- a/slideshow/source/inc/event.hxx
+++ b/slideshow/source/inc/event.hxx
@@ -31,7 +31,8 @@
#define INCLUDED_SLIDESHOW_EVENT_HXX
#include "disposable.hxx"
-
+#include "debug.hxx"
+#include <rtl/ustring.hxx>
#include <boost/shared_ptr.hpp>
#include <vector>
@@ -43,6 +44,10 @@ namespace internal {
class Event : public Disposable
{
public:
+#if OSL_DEBUG_LEVEL > 1
+ Event (const ::rtl::OUString& rsDescription) : msDescription(rsDescription) {};
+#endif
+
/** Execute the event.
@return true, if event was successfully executed.
@@ -72,6 +77,13 @@ public:
event is to be fired.
*/
virtual double getActivationTime( double nCurrentTime ) const = 0;
+
+#if OSL_DEBUG_LEVEL > 1
+ ::rtl::OUString GetDescription (void) const { return msDescription; }
+
+private:
+ const ::rtl::OUString msDescription;
+#endif
};
typedef ::boost::shared_ptr< Event > EventSharedPtr;
diff --git a/slideshow/source/inc/eventqueue.hxx b/slideshow/source/inc/eventqueue.hxx
index 5963552d9c60..35adcf69c068 100644
--- a/slideshow/source/inc/eventqueue.hxx
+++ b/slideshow/source/inc/eventqueue.hxx
@@ -72,6 +72,13 @@ namespace slideshow
*/
bool addEventForNextRound( const EventSharedPtr& event );
+ /** Another way to control the order of asynchronous event
+ exeqution. Use this method to schedule events that are to
+ be executed after all regular events that have no delay,
+ even when they schedule new regular events without delay.
+ */
+ bool addEventWhenQueueIsEmpty (const EventSharedPtr& rpEvent);
+
/** Process the event queue.
This method executes all events whose timeout has
@@ -138,6 +145,7 @@ namespace slideshow
ImplQueueType maEvents;
typedef ::std::vector<EventEntry> EventEntryVector;
EventEntryVector maNextEvents;
+ ImplQueueType maNextNextEvents;
void process_( bool bFireAllEvents );
// perform timing of events via relative time
diff --git a/slideshow/source/inc/interruptabledelayevent.hxx b/slideshow/source/inc/interruptabledelayevent.hxx
index 96795dfa51d4..485c96bc8c2c 100644
--- a/slideshow/source/inc/interruptabledelayevent.hxx
+++ b/slideshow/source/inc/interruptabledelayevent.hxx
@@ -49,6 +49,9 @@ namespace slideshow
public:
DelayFacade( const EventSharedPtr& rEvent,
double nTimeout ) :
+#if OSL_DEBUG_LEVEL > 1
+ Event(::rtl::OUString::createFromAscii("DelayFacade")),
+#endif
mpEvent( rEvent ),
mnTimeout( nTimeout )
{
@@ -138,7 +141,7 @@ namespace slideshow
{
InterruptableEventPair aRes;
- aRes.mpImmediateEvent = makeEvent( rFunctor );
+ aRes.mpImmediateEvent = makeEvent( rFunctor, "makeInterruptableDelay");
aRes.mpTimeoutEvent.reset( new DelayFacade( aRes.mpImmediateEvent,
nTimeout ) );
diff --git a/slideshow/source/inc/screenupdater.hxx b/slideshow/source/inc/screenupdater.hxx
index 07837d6bfc4c..33d6c5d7263f 100644
--- a/slideshow/source/inc/screenupdater.hxx
+++ b/slideshow/source/inc/screenupdater.hxx
@@ -111,9 +111,30 @@ namespace slideshow
*/
void requestImmediateUpdate();
+ class UpdateLock {public: virtual void Activate (void) = 0; };
+
+ /** Call this method to create a lock instead of calling
+ lockUpdates() and unlockUpdates() directly.
+ @param bStartLocked
+ When <TRUE/> then the UpdateLock is created already
+ locked. When <FALSE/> then Activate() has to be called in order
+ to lock the lock.
+ */
+ ::boost::shared_ptr<UpdateLock> createLock (const bool bStartLocked);
+
+ /** Lock updates to prevent intermediate repaints.
+ */
+ void lockUpdates (void);
+
+ /** When called as often as lockUpdates() then commitUpdates()
+ is called.
+ */
+ void unlockUpdates (void);
+
private:
struct ImplScreenUpdater;
boost::scoped_ptr<ImplScreenUpdater> mpImpl;
+
};
}
}
diff --git a/slideshow/source/inc/unoview.hxx b/slideshow/source/inc/unoview.hxx
index 471cdae98a70..6dfc99da5a65 100644
--- a/slideshow/source/inc/unoview.hxx
+++ b/slideshow/source/inc/unoview.hxx
@@ -68,6 +68,16 @@ namespace slideshow
with a different calling convention under Windows).
*/
virtual void _dispose() = 0;
+
+ /** Return whether the sound play back is enabled.
+ */
+ virtual bool isSoundEnabled (void) const = 0;
+
+ /** Tell the view whether it may play sounds. Disabling this
+ can be used to prevent different views to play the same
+ sounds at the same time.
+ */
+ virtual void setIsSoundEnabled (const bool bValue) = 0;
};
typedef ::boost::shared_ptr< UnoView > UnoViewSharedPtr;
diff --git a/slideshow/source/inc/usereventqueue.hxx b/slideshow/source/inc/usereventqueue.hxx
index d0ab3b8c1ce5..26be68e1ffa0 100644
--- a/slideshow/source/inc/usereventqueue.hxx
+++ b/slideshow/source/inc/usereventqueue.hxx
@@ -188,8 +188,16 @@ public:
Then, all registered events are fired and removed from this
queue. After firing, a next effect event is issued to this
queue to start the next effect.
+ @param pEvent
+ The event to execute when skipping the current effect.
+ @param bSkipTriggersNextEffect
+ When <TRUE/> then after skipping the current effect the next
+ effect is triggered. When <FALSE/> then the next effect is not
+ triggered.
*/
- void registerSkipEffectEvent( EventSharedPtr const& pEvent );
+ void registerSkipEffectEvent(
+ EventSharedPtr const& pEvent,
+ const bool bSkipTriggersNextEffect);
/** Registes an event that is fired when the current effects(s)
are rewound, .e.g. when the right mouse button is pressed.
@@ -263,6 +271,12 @@ public:
void registerMouseLeaveEvent( const EventSharedPtr& rEvent,
const ShapeSharedPtr& rShape );
+ /** Typically skipping the current effect is triggered by mouse clicks
+ or key presses that trigger the next effect. This method allows the
+ skipping of effects to be triggered programatically.
+ */
+ void callSkipEffectEventHandler (void);
+
private:
/** Generically register an event on one of the handlers.
diff --git a/slideshow/test/makefile.mk b/slideshow/test/makefile.mk
index cde95f49163a..b6bd1cc2889c 100644
--- a/slideshow/test/makefile.mk
+++ b/slideshow/test/makefile.mk
@@ -1,7 +1,7 @@
#*************************************************************************
#
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
-#
+#
# Copyright 2008 by Sun Microsystems, Inc.
#
# OpenOffice.org - a multi-platform office productivity suite
@@ -32,7 +32,7 @@
PRJ=..
PRJNAME=slideshow
-PRJINC=$(PRJ)$/source
+PRJINC=$(PRJ)$/source
TARGET=tests
TARGETTYPE=GUI
@@ -50,13 +50,14 @@ SHL1OBJS= \
$(SLO)$/views.obj \
$(SLO)$/slidetest.obj \
$(SLO)$/testshape.obj \
- $(SLO)$/testview.obj
+ $(SLO)$/testview.obj
SHL1TARGET= tests
SHL1STDLIBS= $(SALLIB) \
$(BASEGFXLIB) \
$(CPPUHELPERLIB) \
$(CPPULIB) \
+ $(TESTSHL2LIB) \
$(CPPUNITLIB) \
$(UNOTOOLSLIB) \
$(VCLLIB)
@@ -70,7 +71,7 @@ SHL1STDLIBS= $(SALLIB) \
SHL1IMPLIB= i$(SHL1TARGET)
DEF1NAME =$(SHL1TARGET)
-SHL1VERSIONMAP = export.map
+SHL1VERSIONMAP = export.map
# END target1 ----------------------------------------------------------
# BEGIN target2 --------------------------------------------------------
@@ -96,9 +97,9 @@ APP2DEF= $(MISC)$/$(TARGET).def
#------------------------------- All object files ----------------------------
# do this here, so we get right dependencies
-SLOFILES=$(SHL1OBJS)
+SLOFILES=$(SHL1OBJS)
# --- Targets ------------------------------------------------------
.INCLUDE : target.mk
-.INCLUDE : _cppunit.mk
+.INCLUDE : _cppunit.mk
diff --git a/slideshow/test/slidetest.cxx b/slideshow/test/slidetest.cxx
index 96ed6f07fb90..633ee324359e 100644
--- a/slideshow/test/slidetest.cxx
+++ b/slideshow/test/slidetest.cxx
@@ -28,7 +28,7 @@
*
************************************************************************/
-#include <cppunit/simpleheader.hxx>
+#include <testshl/simpleheader.hxx>
#include <cppuhelper/compbase1.hxx>
#include <comphelper/broadcasthelper.hxx>
diff --git a/slideshow/test/testshape.cxx b/slideshow/test/testshape.cxx
index 00f9868bcae4..9482b9d31500 100644
--- a/slideshow/test/testshape.cxx
+++ b/slideshow/test/testshape.cxx
@@ -28,7 +28,7 @@
*
************************************************************************/
-#include <cppunit/simpleheader.hxx>
+#include <testshl/simpleheader.hxx>
#include <cppuhelper/compbase1.hxx>
#include <cppuhelper/basemutex.hxx>
#include <comphelper/make_shared_from_uno.hxx>
diff --git a/slideshow/test/testview.cxx b/slideshow/test/testview.cxx
index 57024438ef43..5f4c44f2a50d 100644
--- a/slideshow/test/testview.cxx
+++ b/slideshow/test/testview.cxx
@@ -28,7 +28,7 @@
*
************************************************************************/
-#include <cppunit/simpleheader.hxx>
+#include <testshl/simpleheader.hxx>
#include <cppuhelper/compbase1.hxx>
#include <cppuhelper/basemutex.hxx>
#include <comphelper/make_shared_from_uno.hxx>
diff --git a/slideshow/test/views.cxx b/slideshow/test/views.cxx
index 20a6a06a976a..e53a14e1fa33 100644
--- a/slideshow/test/views.cxx
+++ b/slideshow/test/views.cxx
@@ -28,7 +28,7 @@
*
************************************************************************/
-#include <cppunit/simpleheader.hxx>
+#include <testshl/simpleheader.hxx>
#include <cppuhelper/compbase1.hxx>
#include <comphelper/broadcasthelper.hxx>