Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

72 files changed, 9405 insertions, 0 deletions

diff --git a/slideshow/source/inc/activitiesfactory.hxx b/slideshow/source/inc/activitiesfactory.hxx
new file mode 100644
index 000000000..19ef963bb
--- /dev/null
+++ b/slideshow/source/inc/activitiesfactory.hxx
@@ -0,0 +1,313 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_ACTIVITIESFACTORY_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_ACTIVITIESFACTORY_HXX
+
+#include <com/sun/star/animations/XAnimate.hpp>
+#include <com/sun/star/animations/XAnimateColor.hpp>
+
+#include "animationactivity.hxx"
+#include "activitiesqueue.hxx"
+#include "event.hxx"
+#include "eventqueue.hxx"
+#include "shape.hxx"
+#include "numberanimation.hxx"
+#include "enumanimation.hxx"
+#include "coloranimation.hxx"
+#include "hslcoloranimation.hxx"
+#include "stringanimation.hxx"
+#include "boolanimation.hxx"
+#include "pairanimation.hxx"
+
+#include <optional>
+
+/* Definition of ActivitiesFactory class */
+
+namespace slideshow {
+namespace internal {
+
+namespace ActivitiesFactory
+{
+    /// Collection of common factory parameters
+    struct CommonParameters
+    {
+        CommonParameters(
+            const EventSharedPtr&                 rEndEvent,
+            EventQueue&                           rEventQueue,
+            ActivitiesQueue&                      rActivitiesQueue,
+            double                                nMinDuration,
+            sal_uInt32                            nMinNumberOfFrames,
+            bool                                  bAutoReverse,
+            ::std::optional<double> const&      aRepeats,
+            double                                nAcceleration,
+            double                                nDeceleration,
+            const ShapeSharedPtr&                 rShape,
+            const ::basegfx::B2DVector&           rSlideBounds )
+            : mpEndEvent( rEndEvent ),
+              mrEventQueue( rEventQueue ),
+              mrActivitiesQueue( rActivitiesQueue ),
+              mnMinDuration( nMinDuration ),
+              mnMinNumberOfFrames( nMinNumberOfFrames ),
+              maRepeats( aRepeats ),
+              mnAcceleration( nAcceleration ),
+              mnDeceleration( nDeceleration ),
+              mpShape( rShape ),
+              maSlideBounds( rSlideBounds ),
+              mbAutoReverse( bAutoReverse ) {}
+
+        /// End event to fire when animation is over
+        EventSharedPtr                                  mpEndEvent;
+
+        /// Event queue to insert the end event into.
+        EventQueue&                                     mrEventQueue;
+        /// Event queue to insert the end event into.
+        ActivitiesQueue&                                mrActivitiesQueue;
+
+        /** Simple duration of the activity
+
+            Specifies the minimal simple duration of the
+            activity (minimal, because mnMinNumberOfFrames
+            might prolong the activity). According to SMIL,
+            this might also be indefinite, which for our
+            framework does not make much sense, though
+            (wouldn't have a clue, then, how to scale the
+            animation over time).
+        */
+        double                                          mnMinDuration;
+
+        /** Minimal number of frames for this activity.
+
+            This specifies the minimal number of frames this
+            activity will display per simple duration. If less
+            than this number are displayed until mnMinDuration
+            is over, the activity will be prolonged until
+            mnMinNumberOfFrames are rendered.
+        */
+        sal_uInt32                                      mnMinNumberOfFrames;
+
+        /** Number of repeats for the simple duration
+
+            This specified the number of repeats. The
+            mnMinDuration times maRepeats yields the total
+            duration of this activity. If this value is
+            unspecified, the activity will repeat
+            indefinitely.
+        */
+        ::std::optional<double> const                 maRepeats;
+
+        /// Fraction of simple time to accelerate animation
+        double                                          mnAcceleration;
+
+        /// Fraction of simple time to decelerate animation
+        double                                          mnDeceleration;
+
+        /// Shape, to get bounds from
+        ShapeSharedPtr                                  mpShape;
+
+        /// LayerManager, to get page size from
+        ::basegfx::B2DVector                            maSlideBounds;
+
+        /// When true, activity is played reversed after mnDuration.
+        bool                                            mbAutoReverse;
+    };
+
+    /** Create an activity from an XAnimate node.
+
+        This method creates an animated activity from the
+        given XAnimate node, extracting all necessary
+        animation parameters from that. Note that due to the
+        animator parameter, the animation values must be
+        convertible to a double value.
+
+        @param rParms
+        Factory parameter structure
+
+        @param rAnimator
+        Animator sub-object
+
+        @param xNode
+        The SMIL animation node to animate
+    */
+    AnimationActivitySharedPtr createAnimateActivity(
+        const CommonParameters&                        rParms,
+        const NumberAnimationSharedPtr&                rAnimator,
+        const css::uno::Reference< css::animations::XAnimate >&   xNode );
+
+    /** Create an activity from an XAnimate node.
+
+        This method creates an animated activity from the
+        given XAnimate node, extracting all necessary
+        animation parameters from that. Note that due to the
+        animator parameter, the animation values must be
+        convertible to a double value.
+
+        @param rParms
+        Factory parameter structure
+
+        @param rAnimator
+        Animator sub-object
+
+        @param xNode
+        The SMIL animation node to animate
+    */
+    AnimationActivitySharedPtr createAnimateActivity(
+        const CommonParameters&                        rParms,
+        const EnumAnimationSharedPtr&                  rAnimator,
+        const css::uno::Reference< css::animations::XAnimate >&      xNode );
+
+    /** Create an activity from an XAnimate node.
+
+        This method creates an animated activity from the
+        given XAnimate node, extracting all necessary
+        animation parameters from that. Note that due to the
+        animator parameter, the animation values must be
+        convertible to a color value.
+
+        @param rParms
+        Factory parameter structure
+
+        @param rAnimator
+        Animator sub-object
+
+        @param xNode
+        The SMIL animation node to animate
+    */
+    AnimationActivitySharedPtr createAnimateActivity(
+        const CommonParameters&                        rParms,
+        const ColorAnimationSharedPtr&                 rAnimator,
+        const css::uno::Reference< css::animations::XAnimate >&      xNode );
+
+    /** Create an activity from an XAnimate node.
+
+        This method creates an animated activity from the
+        given XAnimate node, extracting all necessary
+        animation parameters from that. Note that due to the
+        animator parameter, the animation values must be
+        convertible to a color value.
+
+        @param rParms
+        Factory parameter structure
+
+        @param rAnimator
+        Animator sub-object
+
+        @param xNode
+        The SMIL animation node to animate
+    */
+    AnimationActivitySharedPtr createAnimateActivity(
+        const CommonParameters&                            rParms,
+        const HSLColorAnimationSharedPtr&                  rAnimator,
+        const css::uno::Reference< css::animations::XAnimateColor >&     xNode );
+
+    /** Create an activity from an XAnimate node.
+
+        This method creates an animated activity from the
+        given XAnimate node, extracting all necessary
+        animation parameters from that. Note that due to the
+        animator parameter, the animation values must be
+        convertible to a pair of double values.
+
+        @param rParms
+        Factory parameter structure
+
+        @param rAnimator
+        Animator sub-object
+
+        @param xNode
+        The SMIL animation node to animate
+    */
+    AnimationActivitySharedPtr createAnimateActivity(
+        const CommonParameters&                        rParms,
+        const PairAnimationSharedPtr&                  rAnimator,
+        const css::uno::Reference< css::animations::XAnimate >&   xNode );
+
+    /** Create an activity from an XAnimate node.
+
+        This method creates an animated activity from the
+        given XAnimate node, extracting all necessary
+        animation parameters from that. Note that due to the
+        animator parameter, the animation values must be
+        convertible to a string.
+
+        @param rParms
+        Factory parameter structure
+
+        @param rAnimator
+        Animator sub-object
+
+        @param xNode
+        The SMIL animation node to animate
+    */
+    AnimationActivitySharedPtr createAnimateActivity(
+        const CommonParameters&                        rParms,
+        const StringAnimationSharedPtr&                rAnimator,
+        const css::uno::Reference< css::animations::XAnimate >&      xNode );
+
+    /** Create an activity from an XAnimate node.
+
+        This method creates an animated activity from the
+        given XAnimate node, extracting all necessary
+        animation parameters from that. Note that due to the
+        animator parameter, the animation values must be
+        convertible to a bool value.
+
+        @param rParms
+        Factory parameter structure
+
+        @param rAnimator
+        Animator sub-object
+
+        @param xNode
+        The SMIL animation node to animate
+    */
+    AnimationActivitySharedPtr createAnimateActivity(
+        const CommonParameters&                        rParms,
+        const BoolAnimationSharedPtr&                  rAnimator,
+        const css::uno::Reference< css::animations::XAnimate >&      xNode );
+
+    /** Create a simple activity for the given animator
+
+        This method is suited to create activities for custom
+        animations, which need a simple double value and lasts
+        a given timespan. This activity always generates values
+        from the [0,1] range.
+
+        @param rParms
+        Factory parameter structure
+
+        @param rAnimator
+        Animator sub-object
+
+        @param bDirectionForward
+        If true, the activity goes 'forward', i.e. from 0 to
+        1. With false, the direction is reversed.
+    */
+    AnimationActivitySharedPtr createSimpleActivity(
+        const CommonParameters&         rParms,
+        const NumberAnimationSharedPtr& rAnimator,
+        bool                            bDirectionForward );
+}
+
+} // namespace internal
+} // namespace presentation
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_ACTIVITIESFACTORY_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/activitiesqueue.hxx b/slideshow/source/inc/activitiesqueue.hxx
new file mode 100644
index 000000000..b4f88b1b3
--- /dev/null
+++ b/slideshow/source/inc/activitiesqueue.hxx
@@ -0,0 +1,117 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_ACTIVITIESQUEUE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_ACTIVITIESQUEUE_HXX
+
+#include <deque>
+
+#include "activity.hxx"
+
+#include <canvas/elapsedtime.hxx>
+
+#include <memory>
+
+
+/* Definition of ActivitiesQueue class */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** This class handles the XSprite updates needed for
+            animations, such as moves, scales etc. You can add
+            activity objects to this class, which are called in a
+            round-robin fashion.
+        */
+        class ActivitiesQueue
+        {
+        public:
+            /** Create an ActivitiesQueue.
+
+                @param pPresTimer
+                Pointer to global presentation timer. Used for
+                adjusting and holding global presentation time.
+             */
+            explicit ActivitiesQueue(
+                const std::shared_ptr< ::canvas::tools::ElapsedTime >&  pPresTimer );
+            ~ActivitiesQueue();
+            ActivitiesQueue(const ActivitiesQueue&) = delete;
+            ActivitiesQueue& operator=(const ActivitiesQueue&) = delete;
+
+            /** Add the given activity to the queue.
+             */
+            bool addActivity( const ActivitySharedPtr& pActivity );
+
+            /** Process the activities queue.
+
+                This method performs the smallest atomic processing
+                possible on the queue (typically, this means one
+                activity get processed).
+             */
+            void process();
+
+            /** Call all dequeued activities' dequeued() method
+             */
+            void processDequeued();
+
+            /** Query state of the queue
+
+                @return false, if queue is empty, true otherwise
+             */
+            bool isEmpty() const;
+
+            /** Remove all pending activities from the queue.
+             */
+            void clear();
+
+            /** Gets the queue's timer object.
+             */
+            std::shared_ptr< ::canvas::tools::ElapsedTime > const &
+            getTimer() const { return mpTimer; }
+
+        private:
+            std::shared_ptr< ::canvas::tools::ElapsedTime > mpTimer;
+
+            typedef ::std::deque< ActivitySharedPtr > ActivityQueue;
+
+            ActivityQueue           maCurrentActivitiesWaiting;  // currently running
+                                                                 // activities, that still
+                                                                 // await processing for this
+                                                                 // round
+
+            ActivityQueue           maCurrentActivitiesReinsert;    // currently running
+                                                                      // activities, that are
+                                                                      // already processed for
+                                                                      // this round, and wants
+                                                                    // to be reinserted next
+                                                                    // round
+
+            ActivityQueue           maDequeuedActivities; // This list collects all activities which did not request
+                                                          // a reinsertion. After the screen update has been
+                                                          // performed, those are notified via dequeued(). This
+                                                          // facilitates cleanup actions taking place _after_ the
+                                                          // current frame has been displayed.
+        };
+
+    }
+}
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_ACTIVITIESQUEUE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/activity.hxx b/slideshow/source/inc/activity.hxx
new file mode 100644
index 000000000..5627206a5
--- /dev/null
+++ b/slideshow/source/inc/activity.hxx
@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_ACTIVITY_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_ACTIVITY_HXX
+
+#include <memory>
+
+#include "disposable.hxx"
+
+
+/* Definition of Activity interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+
+        class Activity : public Disposable, public virtual SharedPtrAble
+        {
+        public:
+            /** Perform the activity associated with this interface's
+                implementation.
+
+                @return true, if activity continues, or false, if activity has
+                ended.
+            */
+            virtual bool perform() = 0;
+
+            /** Calculates whether the activity lags time.
+
+                If this method returns a time lag greater than 0.0,
+                the ActivitiesQueue will adjust the global slideshow
+                time, by subtracting the given amount of lag.
+
+                @return time lag or 0.0. Value must be greater or
+                equal than zero.
+            */
+            virtual double calcTimeLag() const = 0;
+
+            /** Query whether this activity is still continuing
+
+                @return true, if this activity still
+                continues. Returns false, if activity has ended. It is
+                required that operator() returns false, when
+                isActive() returns false. Furthermore, it is required
+                that the inactive state is persistent; an activity
+                that has become inactive (i.e. isActive() once
+                returned false) must stay in that state eternally.
+            */
+            virtual bool isActive() const = 0;
+
+            /** Notifies the Activity that it has now left the
+                ActivitiesQueue
+
+                Use this method to react on the queue removal
+                event. For animated shapes, this is e.g. used to
+                switch back to the non-sprite presentation mode of the
+                shape.
+             */
+            virtual void dequeued() = 0;
+
+            /** Forces this activity deactivate and get to its end state
+                (if possible), but does _not_ dispose.
+            */
+            virtual void end() = 0;
+        };
+
+        typedef ::std::shared_ptr< Activity > ActivitySharedPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_ACTIVITY_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/animatableshape.hxx b/slideshow/source/inc/animatableshape.hxx
new file mode 100644
index 000000000..b2dd7753f
--- /dev/null
+++ b/slideshow/source/inc/animatableshape.hxx
@@ -0,0 +1,82 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATABLESHAPE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATABLESHAPE_HXX
+
+#include <memory>
+
+#include "shape.hxx"
+
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Represents an animatable shape.
+
+            This interface adds animation handling methods to a
+            shape. It allows transparent switching between
+            sprite-based viewing and static painting, depending on
+            whether animations are currently running.
+         */
+        class AnimatableShape : public Shape
+        {
+        public:
+            // Animation methods
+
+
+            /** Notify the Shape that an animation starts now
+
+                This method enters animation mode on all registered
+                views.
+
+                @attention This method is supposed to be called only
+                from the LayerManager, since it might involve shifting
+                shapes between different layers (and removing this
+                shape from the background layer in the first place)
+             */
+            virtual void enterAnimationMode() = 0;
+
+            /** Notify the Shape that it is no longer animated
+
+                This methods requests the Shape to end animation mode
+                on all registered views, if called more or equal the
+                times enterAnimationMode() was called. That is, the
+                Shape only leaves animation mode, if all requested
+                enterAnimationMode() call sites have issued their
+                matching leaveAnimationMode().
+
+                @attention This method is supposed to be called only
+                from the LayerManager, since it might involve shifting
+                shapes between different layers (and adding this
+                shape to the background layer again)
+             */
+            virtual void leaveAnimationMode() = 0;
+
+        };
+
+        typedef ::std::shared_ptr< AnimatableShape > AnimatableShapeSharedPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATABLESHAPE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/animatedsprite.hxx b/slideshow/source/inc/animatedsprite.hxx
new file mode 100644
index 000000000..80fcc07a6
--- /dev/null
+++ b/slideshow/source/inc/animatedsprite.hxx
@@ -0,0 +1,161 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATEDSPRITE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATEDSPRITE_HXX
+
+#include <basegfx/matrix/b2dhommatrix.hxx>
+#include <basegfx/point/b2dpoint.hxx>
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+
+#include "viewlayer.hxx"
+
+#include <optional>
+#include <memory>
+
+
+/* Definition of AnimatedSprite class */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** This class provides the sprite for animated shapes.
+
+            Besides encapsulating the Canvas sprite for animated
+            shapes, this class also handles dynamic sprite resizing
+            and all the gory details of offset calculations and
+            rounding prevention.
+         */
+        class AnimatedSprite
+        {
+        public:
+            /** Create a new AnimatedSprite, for the given metafile
+                shape.
+
+                @param rViewLayer
+                The destination view layer, on which the animation should appear
+
+                @param rSpriteSizePixel
+                The overall size of the sprite in device coordinate
+                space, sufficient to display all transformations,
+                shape changes and clips.
+
+                @param nSpritePrio
+                Priority of the sprite. Must remain static over the
+                lifetime of this object
+             */
+            AnimatedSprite( const ViewLayerSharedPtr&   rViewLayer,
+                            const ::basegfx::B2DSize&   rSpriteSizePixel,
+                            double                      nSpritePrio );
+            AnimatedSprite(const AnimatedSprite&) = delete;
+            AnimatedSprite& operator=(const AnimatedSprite&) = delete;
+
+            /** Resize the sprite.
+
+                @param rSpriteSizePixel
+                The new size in pixel
+             */
+            void resize( const ::basegfx::B2DSize& rSpriteSizePixel );
+
+            /** Set an offset for the content output in pixel
+
+                This method offsets the output on the sprite content
+                canvas by the specified amount of device pixel (for
+                subsequent render operations).
+             */
+            void                setPixelOffset( const ::basegfx::B2DSize& rPixelOffset );
+
+            /// Show the sprite
+            void show();
+
+            /// Hide the sprite
+            void hide();
+
+            /** Query the content canvas for the current sprite.
+
+                Note that this method must be called
+                <em>every time</em> something is rendered to the
+                sprite, because XCustomSprite does not guarantee the
+                validity of the canvas after a render operation.
+
+                Furthermore, the view transformation on the returned
+                canvas is already correctly setup, matching the
+                associated destination canvas.
+             */
+            ::cppcanvas::CanvasSharedPtr getContentCanvas() const;
+
+            /** Move the sprite in device pixel space.
+
+                If the sprite is not yet created, this method has no
+                effect.
+             */
+            void movePixel( const ::basegfx::B2DPoint& rNewPos );
+
+            /** Set the alpha value of the sprite.
+
+                If the sprite is not yet created, this method has no
+                effect.
+             */
+            void setAlpha( double rAlpha );
+
+            /** Set a sprite clip in user coordinate space.
+
+                If the sprite is not yet created, this method has no
+                effect.
+             */
+            void clip( const ::basegfx::B2DPolyPolygon& rClip );
+
+            /** Clears a sprite clip
+
+                If the sprite is not yet created, this method has no
+                effect.
+             */
+            void clip();
+
+            /** Set a sprite transformation.
+
+                If the sprite is not yet created, this method has no
+                effect.
+             */
+            void transform( const ::basegfx::B2DHomMatrix& rTransform );
+
+        private:
+            ViewLayerSharedPtr                                          mpViewLayer;
+
+            ::cppcanvas::CustomSpriteSharedPtr                          mpSprite;
+            ::basegfx::B2DSize                                          maEffectiveSpriteSizePixel;
+            ::basegfx::B2DSize                                          maContentPixelOffset;
+
+            double                                                      mnSpritePrio;
+            double                                                      mnAlpha;
+            ::std::optional< ::basegfx::B2DPoint >                    maPosPixel;
+            ::std::optional< ::basegfx::B2DPolyPolygon >              maClip;
+
+            bool                                                        mbSpriteVisible;
+        };
+
+        typedef ::std::shared_ptr< AnimatedSprite > AnimatedSpriteSharedPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATEDSPRITE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/animation.hxx b/slideshow/source/inc/animation.hxx
new file mode 100644
index 000000000..b925e2ecf
--- /dev/null
+++ b/slideshow/source/inc/animation.hxx
@@ -0,0 +1,87 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATION_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATION_HXX
+
+#include "animatableshape.hxx"
+#include "shapeattributelayer.hxx"
+#include "disposable.hxx"
+
+
+/* Definition of Animation interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Interface defining a generic animation.
+
+            This interface is used by objects implementing the
+            Activity interface to drive the animation effect. Objects
+            implementing this interface will receive time-varying
+            animation values, which they can forward to the
+            appropriate attributes. The type of these animation values
+            is given in derived interfaces.
+
+            @see NumberAnimation
+            @see ColorAnimation
+            @see PairAnimation
+         */
+        class Animation : public virtual SharedPtrAble
+        {
+        public:
+            /** Notify that the animation going active soon.
+
+                Implementers should preload any buffers, and create
+                any expensive objects at this time.
+
+                @param rShape
+                Shape to apply this animation to.
+
+                @param rAttrLayer
+                Attribute layer to play the animation on.
+             */
+            virtual void prefetch( ) = 0;
+
+            /** Notify that the animation is about to begin.
+
+                Implementers are free to start accompanying effects,
+                such as sounds, and the animation timer now.
+
+                @param rShape
+                Shape to apply this animation to.
+
+                @param rAttrLayer
+                Attribute layer to play the animation on.
+             */
+            virtual void start( const AnimatableShapeSharedPtr&     rShape,
+                                const ShapeAttributeLayerSharedPtr& rAttrLayer ) = 0;
+
+            /** Notify that the animation is about to end.
+             */
+            virtual void end() = 0;
+        };
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATION_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/animationactivity.hxx b/slideshow/source/inc/animationactivity.hxx
new file mode 100644
index 000000000..95d0fd02c
--- /dev/null
+++ b/slideshow/source/inc/animationactivity.hxx
@@ -0,0 +1,69 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATIONACTIVITY_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATIONACTIVITY_HXX
+
+#include "activity.hxx"
+#include "animatableshape.hxx"
+#include "shapeattributelayer.hxx"
+
+
+/* Definition of AnimationActivity interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+
+        /** Extends the Activity interface with animation-specific functions
+         */
+        class AnimationActivity : public Activity
+        {
+        public:
+            /** Sets targets (shape and attributeLayer)
+
+                Since attribute layers can only be generated when the
+                animation starts, the Activity owner must be able to
+                pass it into the Activity after initial creation. The
+                same applies to the actual shape the animation must
+                run for, since e.g. subsetted shapes are generated
+                close before the animation starts, too (this is not
+                necessary in and out of itself, but for performance
+                reasons. Otherwise, character iterations produce tons
+                of subset shapes).
+
+                @param rShape
+                Shape to play the animation on.
+
+                @param rAttrLayer
+                Attribute layer to change the animated values on.
+             */
+            virtual void setTargets( const AnimatableShapeSharedPtr&        rShape,
+                                     const ShapeAttributeLayerSharedPtr&    rAttrLayer ) = 0;
+        };
+
+        typedef ::std::shared_ptr< AnimationActivity > AnimationActivitySharedPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATIONACTIVITY_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/animationeventhandler.hxx b/slideshow/source/inc/animationeventhandler.hxx
new file mode 100644
index 000000000..2d955e6b6
--- /dev/null
+++ b/slideshow/source/inc/animationeventhandler.hxx
@@ -0,0 +1,65 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATIONEVENTHANDLER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATIONEVENTHANDLER_HXX
+
+#include <memory>
+#include "animationnode.hxx"
+
+
+/* Definition of AnimationEventHandler interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+
+        /** Interface for handling animation events.
+
+            Classes implementing this interface can be added to an
+            EventMultiplexer object, and are called from there to
+            handle animation state change events.
+         */
+        class AnimationEventHandler
+        {
+        public:
+            virtual ~AnimationEventHandler() {}
+
+            /** Handle the event.
+
+                @param rNode
+                Animation node which caused this event to fire
+
+                @return true, if this handler has successfully
+                processed the animation event. When this method
+                returns false, possibly other, less prioritized
+                handlers are called, too.
+             */
+            virtual bool handleAnimationEvent( const AnimationNodeSharedPtr& rNode ) = 0;
+        };
+
+        typedef ::std::shared_ptr< AnimationEventHandler > AnimationEventHandlerSharedPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATIONEVENTHANDLER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/animationfactory.hxx b/slideshow/source/inc/animationfactory.hxx
new file mode 100644
index 000000000..7d2f205c6
--- /dev/null
+++ b/slideshow/source/inc/animationfactory.hxx
@@ -0,0 +1,135 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATIONFACTORY_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATIONFACTORY_HXX
+
+
+#include "numberanimation.hxx"
+#include "enumanimation.hxx"
+#include "coloranimation.hxx"
+#include "stringanimation.hxx"
+#include "boolanimation.hxx"
+#include "pairanimation.hxx"
+
+#include "shapemanager.hxx"
+
+/* Definition of AnimationFactory class */
+
+namespace slideshow
+{
+    namespace internal
+    {
+
+        /** Factory for Animation objects
+
+            Given a SMIL XAnimate node, this factory generates the
+            appropriate Animation object from that, which will modify
+            the attribute as specified.
+         */
+        namespace AnimationFactory
+        {
+            /** Classifies the attribute name.
+
+                This enum maps names to appropriate factory methods.
+             */
+            enum AttributeClass
+            {
+                /// Unknown, prolly invalid name
+                CLASS_UNKNOWN_PROPERTY,
+                /// Use createNumberPropertyAnimation
+                CLASS_NUMBER_PROPERTY,
+                /// Use createEnumPropertyAnimation
+                CLASS_ENUM_PROPERTY,
+                /// Use createColorPropertyAnimation
+                CLASS_COLOR_PROPERTY,
+                /// Use createStringPropertyAnimation
+                CLASS_STRING_PROPERTY,
+                /// Use createBoolPropertyAnimation
+                CLASS_BOOL_PROPERTY
+            };
+
+            AttributeClass classifyAttributeName( const OUString& rAttrName );
+
+            /// Collection of flags common to all factory methods
+            enum FactoryFlags
+            {
+                /** Don't call enter/leaveAnimation for the Shape.
+
+                    This is useful for set effects
+                 */
+                FLAG_NO_SPRITE = 1
+            };
+
+            NumberAnimationSharedPtr createNumberPropertyAnimation( const OUString&               rAttrName,
+                                                                           const AnimatableShapeSharedPtr&      rShape,
+                                                                           const ShapeManagerSharedPtr&         rShapeManager,
+                                                                           const ::basegfx::B2DVector&          rSlideSize,
+                                                                           int                                  nFlags=0 );
+
+            EnumAnimationSharedPtr createEnumPropertyAnimation( const OUString&                   rAttrName,
+                                                                       const AnimatableShapeSharedPtr&          rShape,
+                                                                       const ShapeManagerSharedPtr&             rShapeManager,
+                                                                       const ::basegfx::B2DVector&              rSlideSize,
+                                                                       int                                      nFlags );
+
+            ColorAnimationSharedPtr  createColorPropertyAnimation( const OUString&                rAttrName,
+                                                                          const AnimatableShapeSharedPtr&       rShape,
+                                                                          const ShapeManagerSharedPtr&          rShapeManager,
+                                                                          const ::basegfx::B2DVector&           rSlideSize,
+                                                                          int                                   nFlags=0 );
+
+            /** Create scale or move animation
+
+                @param nTransformType
+                Must be one of
+                animations::AnimationTransformType::TRANSLATE or
+                animations::AnimationTransformType::SCALE.
+             */
+            PairAnimationSharedPtr   createPairPropertyAnimation( const AnimatableShapeSharedPtr&        rShape,
+                                                                         const ShapeManagerSharedPtr&           rShapeManager,
+                                                                         const ::basegfx::B2DVector&            rSlideSize,
+                                                                         sal_Int16                              nTransformType,
+                                                                         int                                    nFlags );
+
+            StringAnimationSharedPtr createStringPropertyAnimation( const OUString&               rAttrName,
+                                                                           const AnimatableShapeSharedPtr&      rShape,
+                                                                           const ShapeManagerSharedPtr&         rShapeManager,
+                                                                           const ::basegfx::B2DVector&          rSlideSize,
+                                                                           int                                  nFlags );
+
+            BoolAnimationSharedPtr   createBoolPropertyAnimation( const OUString&                 rAttrName,
+                                                                         const AnimatableShapeSharedPtr&        rShape,
+                                                                         const ShapeManagerSharedPtr&           rShapeManager,
+                                                                         const ::basegfx::B2DVector&            rSlideSize,
+                                                                         int                                    nFlags );
+
+            NumberAnimationSharedPtr createPathMotionAnimation( const OUString&                   rSVGDPath,
+                                                                       sal_Int16                                nAdditive,
+                                                                       const AnimatableShapeSharedPtr&          rShape,
+                                                                       const ShapeManagerSharedPtr&             rShapeManager,
+                                                                       const ::basegfx::B2DVector&              rSlideSize,
+                                                                       int                                      nFlags);
+        }
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATIONFACTORY_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/animationnode.hxx b/slideshow/source/inc/animationnode.hxx
new file mode 100644
index 000000000..34eca1da9
--- /dev/null
+++ b/slideshow/source/inc/animationnode.hxx
@@ -0,0 +1,160 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATIONNODE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATIONNODE_HXX
+
+#include "disposable.hxx"
+
+#include <com/sun/star/animations/XAnimationNode.hpp>
+#include <memory>
+
+
+namespace slideshow {
+namespace internal {
+
+class AnimationNode;
+typedef ::std::shared_ptr< AnimationNode > AnimationNodeSharedPtr;
+
+/** This interface is used to mirror every XAnimateNode object
+    in the presentation core.
+*/
+class AnimationNode : public Disposable
+{
+public:
+    /** The current state of this AnimationNode
+     */
+    enum NodeState {
+        /// Invalid state, node is disposed or otherwise invalid
+        INVALID      =0,
+        /// Unresolved start time
+        UNRESOLVED   =1,
+        /// Resolved start time, node will start eventually
+        RESOLVED     =2,
+        /// Node is active
+        ACTIVE       =4,
+        /// Node is frozen (no longer active, but changes remain in place)
+        FROZEN       =8,
+        /// Node has completed an active lifecycle,
+        /// and any effect is removed from the document
+        ENDED       =16
+    };
+
+    /** Query the corresponding XAnimationNode.
+     */
+    virtual css::uno::Reference< css::animations::XAnimationNode >
+    getXAnimationNode() const = 0;
+
+    /** Init this node
+
+        If this node is not in state INVALID, init() sets up the
+        node state and schedules necessary events.
+        If this node has children, they have their init() called, too.
+        You will call this method whenever a slide is going to be
+        shown.
+
+        @return true, if init was successful; state has changed to UNRESOLVED
+    */
+    virtual bool init() = 0;
+
+    /** Resolve node start time
+
+        Nodes can have unresolved start times, i.e. indefinite
+        start time for container nodes, or child nodes whose
+        parent has not yet started. Calling this method fixes
+        the node's start time. This does not mean that this
+        node immediately starts its animations, that is only
+        the case for begin=0.0. The node will change its state
+        to RESOLVED.
+
+        @return true, if a start event was successfully scheduled.
+    */
+    virtual bool resolve() = 0;
+
+    /** Immediately start this node
+
+        This method starts the animation on this node, without
+        begin timeout. The node will change its state to ACTIVE.
+    */
+    virtual void activate() = 0;
+
+    /** Immediately stop this node
+
+        This method stops the animation on this node. The node
+        will change its state to either ENDED or FROZEN,
+        depending on XAnimationNode attributes.
+    */
+    virtual void deactivate() = 0;
+
+    /** End the animation on this node
+
+        This method force-ends animation on this node. Parents
+        may call this for their children, if their active
+        duration ends. An ended animation will no longer have
+        any effect on the shape attributes. The node will
+        change its state to ENDED.
+    */
+    virtual void end() = 0;
+
+    /** Query node state
+
+        @return the current state of this animation node.
+    */
+    virtual NodeState getState() const = 0;
+
+    /** Register a deactivating listener
+
+        This method registers another AnimationNode as an
+        deactivating listener, which gets notified via a
+        notifyDeactivating() call. The node calls all
+        registered listener, when it leaves the ACTIVE state.
+
+        @param rNotifee AnimationNode to notify
+    */
+    virtual bool registerDeactivatingListener(
+        const AnimationNodeSharedPtr& rNotifee ) = 0;
+
+    /** Called to notify another AnimationNode's deactivation
+
+        @param rNotifier The instance who calls this method.
+    */
+    virtual void notifyDeactivating(
+        const AnimationNodeSharedPtr& rNotifier ) = 0;
+
+    /** Called by the container to remove the animation effect
+        to make the painted shape correct if it restart because
+        of repeat or rewind ( fill mode is AnimationFill::REMOVE )
+        to start state.
+    */
+    virtual void removeEffect() = 0;
+
+    /** Query node whether it has an animation pending.
+
+        @return true, if this node (or at least one of its children)
+        has an animation pending. Used to determine if the main
+        sequence is actually empty, or contains effects
+    */
+    virtual bool hasPendingAnimation() const = 0;
+};
+
+} // namespace internal
+} // namespace presentation
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATIONNODE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/animationnodefactory.hxx b/slideshow/source/inc/animationnodefactory.hxx
new file mode 100644
index 000000000..681cc8518
--- /dev/null
+++ b/slideshow/source/inc/animationnodefactory.hxx
@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATIONNODEFACTORY_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATIONNODEFACTORY_HXX
+
+#include <com/sun/star/uno/Reference.hxx>
+#include <com/sun/star/animations/XAnimationNode.hpp>
+
+#include <basegfx/vector/b2dvector.hxx>
+
+#include "animationnode.hxx"
+#include "slideshowcontext.hxx"
+
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /* Definition of AnimationNodeFactory class */
+
+        namespace AnimationNodeFactory
+        {
+            /** Create an AnimationNode for the given XAnimationNode
+             */
+            AnimationNodeSharedPtr createAnimationNode( const css::uno::Reference< css::animations::XAnimationNode >& xNode,
+                                                        const ::basegfx::B2DVector&                          rSlideSize,
+                                                        const SlideShowContext&                              rContext );
+
+
+#if defined(DBG_UTIL)
+            void showTree( AnimationNodeSharedPtr const & pRootNode );
+# define SHOW_NODE_TREE(a) AnimationNodeFactory::showTree(a)
+#else
+# define SHOW_NODE_TREE(a)
+#endif
+        }
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_ANIMATIONNODEFACTORY_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/attributableshape.hxx b/slideshow/source/inc/attributableshape.hxx
new file mode 100644
index 000000000..4c250e67d
--- /dev/null
+++ b/slideshow/source/inc/attributableshape.hxx
@@ -0,0 +1,222 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_ATTRIBUTABLESHAPE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_ATTRIBUTABLESHAPE_HXX
+
+#include <memory>
+
+#include "animatableshape.hxx"
+#include "shapeattributelayer.hxx"
+#include "doctreenodesupplier.hxx"
+
+namespace slideshow
+{
+    namespace internal
+    {
+        // forward declaration necessary, because methods use AttributableShapeSharedPtr
+        class AttributableShape;
+
+        typedef ::std::shared_ptr< AttributableShape > AttributableShapeSharedPtr;
+
+        /** Represents an animatable shape, that can have its
+            attributes changed.
+
+            Over an animatable shape, this interface adds attribute
+            modification methods. Furthermore, the shape can be
+            queried for sub items, which in turn can be separated out
+            into own AttributableShapes.
+         */
+        class AttributableShape : public AnimatableShape
+        {
+        public:
+            // Attribute layer methods
+
+
+            /** Create a new shape attribute layer.
+
+                This method creates a new layer for shape attributes,
+                which lies atop of all previous attribute layers. That
+                is most typically used when a new SMIL animation
+                starts (which according to the spec always lies atop
+                of all previous animations). Thus, subsequent calls to
+                this method generate a sandwich of attribute layers,
+                which in total define the shape's attributes.
+
+                Please note that the attribute layers do <em>not</em>
+                contain the underlying XShape's attributes as
+                default. Instead, attributes not explicitly set by
+                animations remain in invalid state, allowing the
+                shape's paint method to determine whether they have to
+                override the underlying graphical shape
+                representation. XShape attributes must be passed
+                explicitly to animations which need them (e.g. 'by'
+                animations).
+
+                @return the new layer
+             */
+            virtual ShapeAttributeLayerSharedPtr createAttributeLayer() = 0;
+
+            /** Revoke a previously generated attribute layer.
+
+                This method revokes a previously generated attribute
+                layer, and removes the effect of that layer from this
+                shape. The layer need not be the current toplevel
+                layer, it can also be revoked from in between.
+
+                @param rLayer
+                Layer to revoke. Must have been generated by
+                createAttributeLayer() at the same Shape.
+
+                @return true, if layer was successfully removed, false
+                otherwise (e.g. if the given layer was not generated
+                for this shape).
+             */
+            virtual bool revokeAttributeLayer( const ShapeAttributeLayerSharedPtr& rLayer ) = 0;
+
+            /** Get the topmost shape attribute layer (if any).
+
+                This method returns the topmost layer for shape
+                attributes, i.e. the one which ultimately determines
+                the shape's look.
+
+                Please note that the attribute layers do <em>not</em>
+                contain the underlying XShape's attributes as
+                default. Instead, attributes not explicitly set by
+                animations remain in invalid state, allowing the
+                shape's paint method to determine whether they have to
+                override the underlying graphical shape
+                representation. XShape attributes must be passed
+                explicitly to animations which need them (e.g. 'by'
+                animations).
+
+                @return the topmost layer
+             */
+            virtual ShapeAttributeLayerSharedPtr getTopmostAttributeLayer() const = 0;
+
+
+            /** Change default shape visibility
+
+                This method hides or unhides a shape. Note that every
+                attribute layer generated for this shape is able to
+                override the setting given here, until it is revoked.
+
+                @param bVisible
+                When true, shape will be visible, when false,
+                invisible (modulo attribute layer overrides).
+             */
+            virtual void setVisibility( bool bVisible ) = 0;
+
+            // Sub-item handling
+
+
+            /** Retrieve interface for DocTreeNode creation.
+
+                This method provides the caller with a reference to
+                the DocTreeNodeSupplier interface, which can be used
+                to request specific tree nodes for this shape.
+             */
+            virtual const DocTreeNodeSupplier& getTreeNodeSupplier() const = 0;
+            virtual DocTreeNodeSupplier&       getTreeNodeSupplier() = 0;
+
+            /** Query the subset this shape displays.
+
+                This method returns a tree node denoting the subset
+                displayed by this shape. If this shape is not a subset
+                shape, an empty tree node should be returned. If this
+                shape is a subset, and itself has subsetted children,
+                this method might return more than the shape is
+                actually displaying (because a single DocTreeNode is
+                not able to model holes in the range).
+             */
+            virtual DocTreeNode getSubsetNode() const = 0;
+
+            /** Query a subset Shape, if already existent at this
+                object
+
+                This method returns a clone of this Shape, which
+                renders only the selected subset of itself, but only
+                if such a subset has been explicitly created before.
+
+                @param rTreeNode
+                A DocTreeNode instance queried from this Shape, which
+                specifies the subset of the Shape to render.
+
+                @return a NULL Shape pointer, if no subset exists for
+                the given DocTreeNode.
+            */
+            virtual AttributableShapeSharedPtr getSubset( const DocTreeNode& rTreeNode ) const = 0;
+
+            /** Create a subset Shape
+
+                This method creates a clone of this Shape, which
+                renders only the selected subset of itself. Multiple
+                createSubset() calls for the same DocTreeNode will all
+                share the same subset shape.
+
+                The original shape (i.e. the one this method is called
+                on) will cease to display the selected subset
+                part. That is, together the shapes will display the
+                original content, but the content of all subset shapes
+                and their original shape will always be mutually
+                disjunct.
+
+                After deregistering the subset shape a matching number
+                of times via revokeSubset(), the original shape will
+                resume displaying the subsetted part.
+
+                @attention To maintain view integrity, this method
+                should only be called from the LayerManager
+
+                @param o_rSubset
+                The requested Shape
+
+                @param rTreeNode
+                A DocTreeNode instance queried from this Shape, which
+                specifies the subset of the Shape to render
+
+                @return true, if the shape was newly created, and
+                false, if an already existing subset is returned.
+            */
+            virtual bool createSubset( AttributableShapeSharedPtr&  o_rSubset,
+                                       const DocTreeNode&           rTreeNode ) = 0;
+
+            /** Revoke a previously generated shape subset.
+
+                After revoking a subset shape, the corresponding
+                subset part will become visible again on the original
+                shape.
+
+                @attention To maintain view integrity, this method
+                should only be called from the LayerManager
+
+                @param rShape
+                The subset to revoke
+
+                @return true, if the last client called
+                revokeSubset().
+             */
+            virtual bool revokeSubset( const AttributableShapeSharedPtr& rShape ) = 0;
+        };
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_ATTRIBUTABLESHAPE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/attributemap.hxx b/slideshow/source/inc/attributemap.hxx
new file mode 100644
index 000000000..6ab9c24e7
--- /dev/null
+++ b/slideshow/source/inc/attributemap.hxx
@@ -0,0 +1,73 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_ATTRIBUTEMAP_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_ATTRIBUTEMAP_HXX
+
+#include <rtl/ustring.hxx>
+
+/* Definition of AttributeMap helper function */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Type of to-be-animated attribute.
+
+            This enum describes the type of an animated
+            attribute.
+        */
+        enum class AttributeType
+        {
+            Invalid,
+            CharColor,
+            CharFontName,
+            CharHeight,
+            CharPosture,
+            CharUnderline,
+            CharWeight,
+            Color,
+            DimColor,
+            FillColor,
+            FillStyle,
+            Height,
+            LineColor,
+            LineStyle,
+            Opacity,
+            Rotate,
+            SkewX,
+            SkewY,
+            Visibility,
+            Width,
+            PosX,
+            PosY
+        };
+
+        /** Map attribute name to AttributeType enum
+
+            @returns AttributeType::Invalid, if name was not found in the
+            mapping table.
+         */
+        AttributeType mapAttributeName( const OUString& rAttrName );
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_ATTRIBUTEMAP_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/basecontainernode.hxx b/slideshow/source/inc/basecontainernode.hxx
new file mode 100644
index 000000000..8be89a27f
--- /dev/null
+++ b/slideshow/source/inc/basecontainernode.hxx
@@ -0,0 +1,102 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_BASECONTAINERNODE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_BASECONTAINERNODE_HXX
+
+#include "basenode.hxx"
+
+namespace slideshow {
+namespace internal {
+
+class BaseContainerNode;
+typedef ::std::shared_ptr< BaseContainerNode > BaseContainerNodeSharedPtr;
+
+
+/** This interface extends BaseNode with child handling methods.
+    Used for XAnimationNode objects which have children
+*/
+class BaseContainerNode : public BaseNode
+{
+public:
+    BaseContainerNode(
+        css::uno::Reference<css::animations::XAnimationNode> const& xNode,
+        BaseContainerNodeSharedPtr const& pParent,
+        NodeContext const& rContext );
+
+    /** Add given child node to this container
+     */
+    void appendChildNode( AnimationNodeSharedPtr const& pNode );
+
+#if defined(DBG_UTIL)
+    virtual void showState() const override;
+    virtual const char* getDescription() const override { return "BaseContainerNode"; }
+#endif
+
+protected:
+    // overrides from BaseNode
+    virtual void dispose() override;
+
+private:
+    virtual bool init_st() override;
+    bool init_children();
+    virtual void deactivate_st( NodeState eDestState ) override;
+    virtual bool hasPendingAnimation() const override;
+    // force to be implemented by derived class:
+    virtual void activate_st() override = 0;
+    virtual void notifyDeactivating(
+        AnimationNodeSharedPtr const& rNotifier ) override = 0;
+
+protected:
+    bool isDurationIndefinite() const { return mbDurationIndefinite; }
+
+    bool isChildNode( AnimationNodeSharedPtr const& pNode ) const;
+
+    /// @return true: if all children have been deactivated
+    bool notifyDeactivatedChild( AnimationNodeSharedPtr const& pChildNode );
+
+    void repeat();
+
+    template <typename FuncT>
+    void forEachChildNode( FuncT func,
+                                  int nodeStateMask ) const
+    {
+        for (AnimationNodeSharedPtr const& pNode : maChildren) {
+            if (nodeStateMask != -1 && (pNode->getState() & nodeStateMask) == 0)
+                continue;
+            func(pNode);
+        }
+    }
+
+    typedef ::std::vector<AnimationNodeSharedPtr> VectorOfNodes;
+    VectorOfNodes       maChildren;
+    ::std::size_t       mnFinishedChildren;
+    double       mnLeftIterations;
+
+private:
+    const bool          mbRepeatIndefinite;
+    const bool          mbRestart;
+    const bool          mbDurationIndefinite;
+};
+
+} // namespace interface
+} // namespace presentation
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/basenode.hxx b/slideshow/source/inc/basenode.hxx
new file mode 100644
index 000000000..27545dc87
--- /dev/null
+++ b/slideshow/source/inc/basenode.hxx
@@ -0,0 +1,213 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_BASENODE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_BASENODE_HXX
+
+#include <basegfx/vector/b2dvector.hxx>
+#include <tools/diagnose_ex.h>
+#include <osl/diagnose.hxx>
+
+#include "event.hxx"
+#include "animationnode.hxx"
+#include "slideshowcontext.hxx"
+#include "shapesubset.hxx"
+
+#include <vector>
+
+namespace slideshow {
+namespace internal {
+
+/** Context for every node.
+
+    Besides the global AnimationNodeFactory::Context data,
+    this struct also contains the current DocTree subset
+    for this node. If start and end index of the
+    DocTreeNode are equal, the node should use the
+    complete shape.
+*/
+struct NodeContext
+{
+    NodeContext( const SlideShowContext&                 rContext,
+                 const ::basegfx::B2DVector&             rSlideSize )
+        : maContext( rContext ),
+          maSlideSize( rSlideSize ),
+          mpMasterShapeSubset(),
+          mnStartDelay(0.0),
+          mbIsIndependentSubset( true )
+        {}
+
+    /// Context as passed to createAnimationNode()
+    SlideShowContext                 maContext;
+
+    /// Size in user coordinate space of the corresponding slide
+    ::basegfx::B2DVector             maSlideSize;
+
+    /// Shape to be used (provided by parent, e.g. for iterations)
+    ShapeSubsetSharedPtr             mpMasterShapeSubset;
+
+    /// Additional delay to node begin (to offset iterate effects)
+    double                           mnStartDelay;
+
+    /// When true, subset must be created during slide initialization
+    bool                             mbIsIndependentSubset;
+};
+
+class BaseContainerNode;
+typedef ::std::shared_ptr< BaseContainerNode > BaseContainerNodeSharedPtr;
+
+class BaseNode;
+typedef ::std::shared_ptr< BaseNode > BaseNodeSharedPtr;
+
+
+/** This interface extends AnimationNode with some
+    file-private accessor methods.
+*/
+class BaseNode : public AnimationNode,
+                 public  ::osl::DebugBase<BaseNode>
+{
+public:
+    BaseNode( css::uno::Reference<css::animations::XAnimationNode> const& xNode,
+              BaseContainerNodeSharedPtr const&                    pParent,
+              NodeContext const&                                   rContext );
+    BaseNode(const BaseNode&) = delete;
+    BaseNode& operator=(const BaseNode&) = delete;
+
+    /** Provide the node with a shared_ptr to itself.
+
+        Since implementation has to create objects which need
+        a shared_ptr to this node, and a pointee cannot
+        retrieve a shared_ptr to itself internally, have to
+        set that from the outside.
+    */
+    void setSelf( const BaseNodeSharedPtr& rSelf );
+
+
+#if defined(DBG_UTIL)
+    virtual void showState() const;
+    virtual const char* getDescription() const;
+#endif
+
+    const ::std::shared_ptr< BaseContainerNode >& getParentNode() const
+        { return mpParent; }
+
+    // Disposable:
+    virtual void dispose() override;
+
+    // AnimationNode:
+    virtual bool init() override;
+    virtual bool resolve() override;
+    virtual void activate() override;
+    virtual void deactivate() override;
+    virtual void end() override;
+    virtual css::uno::Reference<css::animations::XAnimationNode> getXAnimationNode() const override;
+    virtual NodeState getState() const override;
+    virtual bool registerDeactivatingListener(
+        const AnimationNodeSharedPtr& rNotifee ) override;
+    // nop:
+    virtual void notifyDeactivating( const AnimationNodeSharedPtr& rNotifier ) override;
+
+    bool isMainSequenceRootNode() const { return mbIsMainSequenceRootNode; }
+
+    /// Get the node's fill mode
+    sal_Int16 getFillMode();
+
+    virtual void removeEffect() override {}
+protected:
+    void scheduleDeactivationEvent( EventSharedPtr const& pEvent =
+                                    EventSharedPtr() );
+
+    SlideShowContext const&                 getContext() const { return maContext; }
+    ::std::shared_ptr<BaseNode> const&    getSelf() const { return mpSelf; }
+
+    bool checkValidNode() const {
+        ENSURE_OR_THROW( mpSelf, "no self ptr set!" );
+        bool const bRet = (meCurrState != INVALID);
+        OSL_ENSURE( bRet, "### INVALID node!" );
+        return bRet;
+    }
+
+private:
+    // all state affecting methods have "_st" counterparts being called at
+    // derived classes when in state transition: no-ops here at BaseNode...
+    virtual bool init_st();
+    virtual bool resolve_st();
+    virtual void activate_st();
+    virtual void deactivate_st( NodeState eDestState );
+
+private:
+    /// notifies
+    /// - all registered deactivation listeners
+    /// - single animation end (every node)
+    /// - slide animations (if main sequence root node)
+    void notifyEndListeners() const;
+
+    /// Get the node's restart mode
+    sal_Int16 getRestartMode();
+
+    /** Get the default restart mode
+
+        If this node's default mode is
+        AnimationRestart::DEFAULT, this method recursively
+        calls the parent node.
+    */
+    sal_Int16 getRestartDefaultMode() const;
+
+    /** Get the default fill mode.
+
+        If this node's default mode is AnimationFill::DEFAULT,
+        this method recursively calls the parent node.
+    */
+    sal_Int16 getFillDefaultMode() const;
+
+    bool isTransition( NodeState eFromState, NodeState eToState,
+                       bool debugAssert = true ) const {
+        bool const bRet =((mpStateTransitionTable[eFromState] & eToState) != 0);
+        OSL_ENSURE( !debugAssert || bRet, "### state unreachable!" );
+        return bRet;
+    }
+
+    bool inStateOrTransition( int mask ) const {
+        return ((meCurrState & mask) != 0 ||
+                (meCurrentStateTransition & mask) != 0);
+    }
+
+    class StateTransition;
+    friend class StateTransition;
+
+private:
+    SlideShowContext                                   maContext;
+
+    ::std::vector< AnimationNodeSharedPtr >            maDeactivatingListeners;
+    css::uno::Reference< css::animations::XAnimationNode > mxAnimationNode;
+    ::std::shared_ptr< BaseContainerNode >           mpParent;
+    ::std::shared_ptr< BaseNode >                    mpSelf;
+    const int*                                         mpStateTransitionTable;
+    const double                                       mnStartDelay;
+    NodeState                                          meCurrState;
+    int                                                meCurrentStateTransition;
+    EventSharedPtr                                     mpCurrentEvent;
+    const bool                                         mbIsMainSequenceRootNode;
+};
+
+} // namespace internal
+} // namespace slideshow
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/boolanimation.hxx b/slideshow/source/inc/boolanimation.hxx
new file mode 100644
index 000000000..16b9271ea
--- /dev/null
+++ b/slideshow/source/inc/boolanimation.hxx
@@ -0,0 +1,71 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_BOOLANIMATION_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_BOOLANIMATION_HXX
+
+#include "animation.hxx"
+
+
+/* Definition of BoolAnimation interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Interface defining a bool animation.
+
+            This interface is a specialization of the Animation
+            interface, and is used to animate attributes that have
+            only two discrete values (on and off, or true and false,
+            for example).
+         */
+        class BoolAnimation : public Animation
+        {
+        public:
+            typedef bool ValueType;
+
+            /** Set the animation to the given value
+
+                @param bValue
+                Current animation value.
+             */
+            virtual bool operator()( ValueType bValue ) = 0;
+
+            /** Request the underlying value for this animation.
+
+                This is necessary for pure To or By animations, as the
+                Activity cannot determine a sensible start value
+                otherwise.
+
+                @attention Note that you are only permitted to query
+                for the underlying value, if the animation has actually
+                been started (via start() call).
+             */
+            virtual ValueType getUnderlyingValue() const = 0;
+        };
+
+        typedef ::std::shared_ptr< BoolAnimation > BoolAnimationSharedPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_BOOLANIMATION_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/coloranimation.hxx b/slideshow/source/inc/coloranimation.hxx
new file mode 100644
index 000000000..77d394572
--- /dev/null
+++ b/slideshow/source/inc/coloranimation.hxx
@@ -0,0 +1,71 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_COLORANIMATION_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_COLORANIMATION_HXX
+
+#include "animation.hxx"
+#include "rgbcolor.hxx"
+
+
+/* Definition of ColorAnimation interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Interface defining a color animation.
+
+            This interface is a specialization of the Animation
+            interface, and is used to animate attributes representable
+            by a color value.
+         */
+        class ColorAnimation : public Animation
+        {
+        public:
+            typedef RGBColor ValueType;
+
+            /** Set the animation to the given color value
+
+                @param rColor
+                Current animation value.
+             */
+            virtual bool operator()( const ValueType& rColor ) = 0;
+
+            /** Request the underlying value for this animation.
+
+                This is necessary for pure To or By animations, as the
+                Activity cannot determine a sensible start value
+                otherwise.
+
+                @attention Note that you are only permitted to query
+                for the underlying value, if the animation has actually
+                been started (via start() call).
+             */
+            virtual ValueType getUnderlyingValue() const = 0;
+        };
+
+        typedef ::std::shared_ptr< ColorAnimation > ColorAnimationSharedPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_COLORANIMATION_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/cursormanager.hxx b/slideshow/source/inc/cursormanager.hxx
new file mode 100644
index 000000000..b470020ab
--- /dev/null
+++ b/slideshow/source/inc/cursormanager.hxx
@@ -0,0 +1,63 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_CURSORMANAGER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_CURSORMANAGER_HXX
+
+#include <sal/types.h>
+
+
+/* Definition of CursorManager interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+
+        /** Interface for handling the view cursor.
+
+            Classes implementing this interface interact with the
+            View, arbitrating access to the mouse cursor shape.
+         */
+        class CursorManager
+        {
+        public:
+            virtual ~CursorManager() {}
+
+            /** Request different cursor shape.
+
+                @param nCursorShape
+                Shape ID of the new mouse cursor
+             */
+            virtual bool requestCursor( sal_Int16 nCursorShape ) = 0;
+
+            /** Reset cursor to default one.
+
+                This method resets the cursor to whatever default to
+                manager deems appropriate.
+             */
+            virtual void resetCursor() = 0;
+        };
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_CURSORMANAGER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/delayevent.hxx b/slideshow/source/inc/delayevent.hxx
new file mode 100644
index 000000000..9585910bf
--- /dev/null
+++ b/slideshow/source/inc/delayevent.hxx
@@ -0,0 +1,142 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_DELAYEVENT_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_DELAYEVENT_HXX
+
+#include "event.hxx"
+
+#include <functional>
+
+namespace slideshow {
+namespace internal {
+
+/** Event, which delays the functor call the given amount of time
+ */
+class Delay : public Event
+{
+public:
+    typedef ::std::function<void ()> FunctorT;
+
+    template <typename FuncT>
+        Delay( FuncT const& func,
+               double nTimeout
+            ,  const OUString& rsDescription
+            ) : Event(rsDescription),
+            mnTimeout(nTimeout), maFunc(func), mbWasFired(false) {}
+
+    Delay( const std::function<void ()>& func,
+           double nTimeout
+        , const OUString& rsDescription
+        ) : Event(rsDescription),
+        mnTimeout(nTimeout),
+        maFunc(func),
+        mbWasFired(false) {}
+    Delay(const Delay&) = delete;
+    Delay& operator=(const Delay&) = delete;
+
+    // Event:
+    virtual bool fire() override;
+    virtual bool isCharged() const override;
+    virtual double getActivationTime( double nCurrentTime ) const override;
+    // Disposable:
+    virtual void dispose() override;
+
+private:
+    double const mnTimeout;
+    FunctorT maFunc;
+    bool mbWasFired;
+};
+
+#if OSL_DEBUG_LEVEL <= 1
+
+/** Generate delay event
+
+    @param func
+    Functor to call when the event fires.
+
+    @param nTimeout
+    Timeout in seconds, to wait until functor is called.
+
+    @return generated delay event
+*/
+template <typename FuncT>
+inline EventSharedPtr makeDelay_( FuncT const& func, double nTimeout, OUString const& rsDescription )
+{
+    return std::make_shared<Delay>( func, nTimeout, rsDescription );
+}
+
+/** Generate immediate event
+
+    @param func
+    Functor to call when the event fires.
+
+    @return generated immediate event.
+*/
+template <typename FuncT>
+inline EventSharedPtr makeEvent_( FuncT const& func, OUString const& rsDescription)
+{
+    return std::make_shared<Delay>( func, 0.0, rsDescription );
+}
+
+
+#define makeDelay(f, t, d) makeDelay_(f, t, d)
+#define makeEvent(f, d) makeEvent_(f, d)
+
+#else // OSL_DEBUG_LEVEL > 0
+
+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,
+        const OUString& rsDescription)
+        : Delay(func, nTimeout, rsDescription),
+          FROM_FUNCTION(from_function),
+          FROM_FILE(from_file), FROM_LINE(from_line) {}
+
+    char const* const FROM_FUNCTION;
+    char const* const FROM_FILE;
+    int const FROM_LINE;
+};
+
+template <typename FuncT>
+inline EventSharedPtr makeDelay_(
+    FuncT const& func, double nTimeout,
+    char const* from_function, char const* from_file, int from_line,
+    const OUString& rsDescription)
+{
+    return EventSharedPtr( new Delay_( func, nTimeout,
+            from_function, from_file, from_line, rsDescription) );
+}
+
+#define makeDelay(f, t, d) makeDelay_(f, t,                   \
+        OSL_THIS_FUNC, __FILE__, __LINE__,           \
+        d)
+#define makeEvent(f, d) makeDelay_(f, 0.0,                  \
+        OSL_THIS_FUNC, __FILE__, __LINE__,         \
+        d)
+
+#endif // OSL_DEBUG_LEVEL <= 1
+
+} // namespace internal
+} // namespace presentation
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_DELAYEVENT_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/disposable.hxx b/slideshow/source/inc/disposable.hxx
new file mode 100644
index 000000000..c3be8bb40
--- /dev/null
+++ b/slideshow/source/inc/disposable.hxx
@@ -0,0 +1,68 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_DISPOSABLE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_DISPOSABLE_HXX
+
+#include <memory>
+
+
+/* Definition of Disposable interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /**
+         * Base class for being a shared pointer, since quite a few of the downstream classes
+         * want to be stored using std::shared_ptr.
+         */
+        class SharedPtrAble : public std::enable_shared_from_this<SharedPtrAble>
+        {
+        public:
+            virtual ~SharedPtrAble() {}
+        };
+
+        /** Disposable interface
+
+            With ref-counted objects, deleting object networks
+            containing cycles requires a dispose() call, to enforce
+            every object to call dispose on and release local
+            references.
+         */
+        class Disposable
+        {
+        public:
+            virtual ~Disposable() {}
+
+            /** Dispose all object references.
+
+                An implementor of this method must first call
+                dispose() on any of its external references, and
+                release them after that.
+             */
+            virtual void dispose() = 0;
+        };
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_DISPOSABLE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/doctreenode.hxx b/slideshow/source/inc/doctreenode.hxx
new file mode 100644
index 000000000..1bb4beda5
--- /dev/null
+++ b/slideshow/source/inc/doctreenode.hxx
@@ -0,0 +1,113 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_DOCTREENODE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_DOCTREENODE_HXX
+
+#include <sal/types.h>
+#include <vector>
+
+
+/* Definition of DocTreeNode class */
+
+namespace slideshow
+{
+    namespace internal
+    {
+
+        /** This class represents kind of a DOM tree node for shape
+            text
+
+            In order to animate subsets of shape text, we need
+            information about the logical and formatting structure of
+            that text (lines, paragraphs, words etc.). This is
+            represented in a tree structure, with DocTreeNodes as the
+            nodes. Instances of this class can be queried from the
+            DocTreeNodeSupplier interface.
+
+            This class has nothing to do with the Draw document tree.
+         */
+        class DocTreeNode
+        {
+        public:
+            /// Type of shape entity represented by this node
+            enum class NodeType
+            {
+                /// This node represents a paragraph
+                LogicalParagraph=129,
+                /// This node represents a word
+                LogicalWord=131,
+                /// This node represents a character
+                LogicalCharacterCell=132
+            };
+
+            /** Create empty tree node
+             */
+            DocTreeNode() :
+                mnStartIndex(-1),
+                mnEndIndex(-1)
+            {
+            }
+
+            /** Create tree node from start and end index.
+
+                Create a tree node for the given range and type.
+
+                @param nStartIndex
+                Start index
+
+                @param nEndIndex
+                End index (exclusive)
+
+                @param eType
+                Node type
+             */
+            DocTreeNode( sal_Int32 nStartIndex,
+                         sal_Int32 nEndIndex ) :
+                mnStartIndex(nStartIndex),
+                mnEndIndex(nEndIndex)
+            {
+            }
+
+            bool                isEmpty() const { return mnStartIndex == mnEndIndex; }
+
+            sal_Int32           getStartIndex() const { return mnStartIndex; }
+            void                setStartIndex( sal_Int32 nIndex ) { mnStartIndex = nIndex; }
+            sal_Int32           getEndIndex() const { return mnEndIndex; }
+            void                setEndIndex( sal_Int32 nIndex ) { mnEndIndex = nIndex; }
+
+            void                reset()
+            {
+                mnStartIndex = -1;
+                mnEndIndex   = -1;
+            }
+
+        private:
+            sal_Int32   mnStartIndex;
+            sal_Int32   mnEndIndex;
+
+        };
+
+        typedef ::std::vector< DocTreeNode > VectorOfDocTreeNodes;
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_DOCTREENODE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/doctreenodesupplier.hxx b/slideshow/source/inc/doctreenodesupplier.hxx
new file mode 100644
index 000000000..cebf09db4
--- /dev/null
+++ b/slideshow/source/inc/doctreenodesupplier.hxx
@@ -0,0 +1,148 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_DOCTREENODESUPPLIER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_DOCTREENODESUPPLIER_HXX
+
+#include "doctreenode.hxx"
+
+
+/* Definition of DocTreeNodeSupplier interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Interface to retrieve DocTreeNodes from subsettable
+            shapes.
+
+            Shapes which implement the AttributableShape interface
+            also provides this interface, providing methods to
+            retrieve specific DocTreeNode objects from the shape. The
+            methods mainly distinguish various ways on how to specify
+            the actual DocTreeNode to return.
+
+            If a requested DocTreeNode is not available when one of
+            the methods below is called, an empty DocTreeNode will be
+            returned (the predicate DocTreeNode::isEmpty() will return
+            true). If, on the other hand, the shape cannot determine,
+            for internal reasons, the internal tree node structure,
+            all those methods will throw an
+            ShapeLoadFailedException. This is, in fact, a delayed error
+            that could also have been reported during shape
+            construction, but might be postponed until the missing
+            information is actually requested.
+         */
+        class DocTreeNodeSupplier
+        {
+        public:
+            /** Query number of tree nodes of the given type this
+                shape contains.
+
+                The value returned by this method minus one is the
+                maximum value permissible at the getTreeNode()
+                method, for the given node type.
+
+                @throws ShapeLoadFailedException, if tree node structure
+                cannot be determined.
+             */
+            virtual sal_Int32 getNumberOfTreeNodes( DocTreeNode::NodeType eNodeType ) const = 0; // throw ShapeLoadFailedException;
+
+            /** Create DocTreeNode from shape.
+
+                This method creates a DocTreeNode from a shape, a
+                given node type and a running index into the shape's
+                DocTreeNodes of the given type.
+
+                @param nNodeIndex
+                Starting with 0, every DocTreeNode of the shape that
+                has type eNodeType is indexed. The DocTreeNode whose
+                index equals nNodeIndex will be returned.
+
+                @param eNodeType
+                Type of the node to return
+
+                @return the DocTreeNode found, or the empty
+                DocTreeNode, if nothing was found.
+
+                @throws ShapeLoadFailedException, if tree node structure
+                cannot be determined.
+            */
+            virtual DocTreeNode getTreeNode( sal_Int32              nNodeIndex,
+                                             DocTreeNode::NodeType  eNodeType ) const = 0; // throw ShapeLoadFailedException;
+
+            /** Query number of tree nodes of the given type this
+                subset contains.
+
+                The value returned by this method minus one is the
+                maximum value permissible at the
+                getSubsetTreeNode() method, for the given node
+                type.
+
+                @param rParentNode
+                The parent node, below which the number of tree nodes
+                of the given type shall be counted.
+
+                @param eNodeType
+                Node type to count.
+
+                @throws ShapeLoadFailedException, if tree node structure
+                cannot be determined.
+             */
+            virtual sal_Int32 getNumberOfSubsetTreeNodes( const DocTreeNode&    rParentNode,
+                                                          DocTreeNode::NodeType eNodeType ) const = 0; // throw ShapeLoadFailedException;
+
+            /** Create DocTreeNode from shape subset.
+
+                This method creates a DocTreeNode from a shape, a
+                parent tree node, a given node type and a running
+                index into the shape's DocTreeNodes of the given type.
+
+                @param rParentNode
+                Parent node, below which the tree node with the given
+                type shall be selected.
+
+                @param nNodeIndex
+                Starting with 0, every DocTreeNode of the shape that
+                has type eNodeType is indexed. The DocTreeNode whose
+                index equals nNodeIndex will be returned.
+
+                @param eNodeType
+                Type of the node to return
+
+                @return the DocTreeNode found, or the empty
+                DocTreeNode, if nothing was found.
+
+                @throws ShapeLoadFailedException, if tree node structure
+                cannot be determined.
+            */
+            virtual DocTreeNode getSubsetTreeNode( const DocTreeNode&       rParentNode,
+                                                   sal_Int32                nNodeIndex,
+                                                   DocTreeNode::NodeType    eNodeType ) const = 0; // throw ShapeLoadFailedException;
+
+        protected:
+            ~DocTreeNodeSupplier() {}
+        };
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_DOCTREENODESUPPLIER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/enumanimation.hxx b/slideshow/source/inc/enumanimation.hxx
new file mode 100644
index 000000000..bb659b270
--- /dev/null
+++ b/slideshow/source/inc/enumanimation.hxx
@@ -0,0 +1,73 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_ENUMANIMATION_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_ENUMANIMATION_HXX
+
+#include "animation.hxx"
+
+
+/* Definition of EnumAnimation interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Interface defining an enum animation.
+
+            This interface is a specialization of the Animation
+            interface, and is used to animate attributes representable
+            by a set of constant values, such as UNO constants, or enums.
+         */
+        class EnumAnimation : public Animation
+        {
+        public:
+            typedef sal_Int16 ValueType;
+
+            /** Set the animation to value k
+
+                @param k
+                Current animation value (must be in an
+                attribute-specific permissible range). Overflowing
+                values will be clipped to the permissible range
+                internally.
+             */
+            virtual bool operator()( ValueType k ) = 0;
+
+            /** Request the underlying value for this animation.
+
+                This is necessary for pure To or By animations, as the
+                Activity cannot determine a sensible start value
+                otherwise.
+
+                @attention Note that you are only permitted to query
+                for the underlying value, if the animation has actually
+                been started (via start() call).
+             */
+            virtual ValueType getUnderlyingValue() const = 0;
+        };
+
+        typedef ::std::shared_ptr< EnumAnimation > EnumAnimationSharedPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_ENUMANIMATION_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/event.hxx b/slideshow/source/inc/event.hxx
new file mode 100644
index 000000000..15fd0d9d6
--- /dev/null
+++ b/slideshow/source/inc/event.hxx
@@ -0,0 +1,81 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_EVENT_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_EVENT_HXX
+
+#include "disposable.hxx"
+#include <rtl/ustring.hxx>
+#include <memory>
+#include <vector>
+
+namespace slideshow {
+namespace internal {
+
+/** Definition of Event interface
+ */
+class Event : public Disposable
+{
+public:
+    Event (const OUString& rsDescription) : msDescription(rsDescription) {}
+
+    /** Execute the event.
+
+        @return true, if event was successfully executed.
+    */
+    virtual bool fire() = 0;
+
+    /** Query whether this event is still charged, i.e. able
+        to fire.
+
+        Inactive events are ignored by the normal event
+        containers (EventQueue, UserEventQueue etc.), and no
+        explicit fire() is called upon them.
+
+        @return true, if this event has already been fired.
+    */
+    virtual bool isCharged() const = 0;
+
+    /** Query the activation time instant this event shall be
+        fired, if it was inserted at instant nCurrentTime into
+        the queue.
+
+        @param nCurrentTime
+        The time from which the activation time is to be
+        calculated from.
+
+        @return the time instant in seconds, on which this
+        event is to be fired.
+    */
+    virtual double getActivationTime( double nCurrentTime ) const = 0;
+
+    const OUString& GetDescription() const { return msDescription; }
+
+private:
+    const OUString msDescription;
+};
+
+typedef ::std::shared_ptr< Event > EventSharedPtr;
+typedef ::std::vector< EventSharedPtr > VectorOfEvents;
+
+} // namespace internal
+} // namespace presentation
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_EVENT_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/eventhandler.hxx b/slideshow/source/inc/eventhandler.hxx
new file mode 100644
index 000000000..3efc5f0b4
--- /dev/null
+++ b/slideshow/source/inc/eventhandler.hxx
@@ -0,0 +1,61 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_EVENTHANDLER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_EVENTHANDLER_HXX
+
+#include <memory>
+
+
+/* Definition of EventHandler interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+
+        /** Interface for event handling objects.
+
+            Classes implementing this interface can be added to an
+            EventMultiplexer object, and are called from there to
+            handle events.
+         */
+        class EventHandler
+        {
+        public:
+            virtual ~EventHandler() {}
+
+            /** Handle the event.
+
+                @return true, if this handler has successfully
+                processed the event. When this method returns false,
+                possibly other, less prioritized handlers are called,
+                too.
+             */
+            virtual bool handleEvent() = 0;
+        };
+
+        typedef ::std::shared_ptr< EventHandler > EventHandlerSharedPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_EVENTHANDLER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/eventmultiplexer.hxx b/slideshow/source/inc/eventmultiplexer.hxx
new file mode 100644
index 000000000..9d84a97c9
--- /dev/null
+++ b/slideshow/source/inc/eventmultiplexer.hxx
@@ -0,0 +1,661 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_EVENTMULTIPLEXER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_EVENTMULTIPLEXER_HXX
+
+#include "eventhandler.hxx"
+#include "mouseeventhandler.hxx"
+#include "animationeventhandler.hxx"
+#include "pauseeventhandler.hxx"
+#include "shapelistenereventhandler.hxx"
+#include "vieweventhandler.hxx"
+
+#include <memory>
+#include <com/sun/star/uno/Reference.hxx>
+
+#include "unoview.hxx"
+
+namespace com::sun::star::drawing { class XShape; }
+
+namespace slideshow {
+namespace internal {
+
+class EventQueue;
+class UnoViewContainer;
+class AnimationNode;
+
+struct EventMultiplexerImpl;
+
+class RGBColor;
+
+/** Interface for handling view repaint events.
+
+    Classes implementing this interface can be added to an
+    EventMultiplexer object, and are called from there to
+    handle view repaint events.
+*/
+class ViewRepaintHandler
+{
+public:
+    virtual ~ViewRepaintHandler() {}
+
+    /** Notify clobbered view.
+
+      Reasons for a viewChanged notification can be
+      different view size, transformation, or other device
+      properties (color resolution or profile, etc.)
+
+      @param rView
+      The changed view
+     */
+    virtual void viewClobbered( const UnoViewSharedPtr& rView ) = 0;
+};
+
+typedef ::std::shared_ptr< ViewRepaintHandler > ViewRepaintHandlerSharedPtr;
+
+/** Interface for handling hyperlink clicks.
+
+  Classes implementing this interface can be added to an
+  EventMultiplexer object, and are called from there to
+  handle hyperlink events.
+ */
+class HyperlinkHandler
+{
+public:
+    /** Handle the event.
+
+        @param rLink
+        The actual hyperlink URI
+
+        @return true, if this handler has successfully
+        processed the event. When this method returns false,
+        possibly other, less prioritized handlers are called,
+        too.
+    */
+    virtual bool handleHyperlink( OUString const& rLink ) = 0;
+
+protected:
+    ~HyperlinkHandler() {}
+};
+
+typedef ::std::shared_ptr< HyperlinkHandler > HyperlinkHandlerSharedPtr;
+
+/** Interface for handling user paint state changes.
+
+    Classes implementing this interface can be added to an
+    EventMultiplexer object, and are called from there to
+    handle user paint events.
+*/
+class UserPaintEventHandler
+{
+public:
+    virtual ~UserPaintEventHandler() {}
+    virtual bool colorChanged( RGBColor const& rUserColor ) = 0;
+    virtual bool widthChanged( double nUserStrokeWidth ) = 0;
+    virtual bool eraseAllInkChanged(bool bEraseAllInk) =0;
+    virtual bool eraseInkWidthChanged(sal_Int32 rEraseInkSize) =0;
+    virtual bool switchEraserMode() = 0;
+    virtual bool switchPenMode() = 0;
+    virtual bool disable() = 0;
+};
+
+typedef ::std::shared_ptr< UserPaintEventHandler > UserPaintEventHandlerSharedPtr;
+
+/** This class multiplexes user-activated and
+    slide-show global events.
+
+    This class listens at the XSlideShowView and fires events
+    registered for certain user actions. Furthermore, global
+    slide show state changes (such as start or end of a slide)
+    are handled as well. Note that registered events which
+    have a non-zero timeout (i.e. events that return non-zero
+    from getActivationTime()) will not be fired immediately
+    after the user action occurred, but only after the given
+    timeout. Which is actually a feature.
+*/
+class EventMultiplexer
+{
+public:
+    /** Create an event multiplexer
+
+        @param rEventQueue
+        Reference to the main event queue. Since we hold this
+        object by plain reference, it must live longer than we
+        do. On the other hand, that queue must not fire events
+        after this object is destroyed, since we might
+        schedule events there which itself contain plain
+        references to this object. Basically, EventQueue and
+        EventMultiplexer should have the same lifetime, and since
+        this is not possible, both must be destructed in a
+        phased mode: first clear both of any remaining events,
+        then destruct them.
+
+        @param rViewContainer
+        Globally managed list of all registered views. Used to
+        determine event sources, and for registering view listeners
+        at.
+    */
+    EventMultiplexer( EventQueue&             rEventQueue,
+                      UnoViewContainer const& rViewContainer );
+    ~EventMultiplexer();
+    EventMultiplexer(const EventMultiplexer&) = delete;
+    EventMultiplexer& operator=(const EventMultiplexer&) = delete;
+
+    // Management methods
+
+
+    /** Clear all registered handlers.
+     */
+    void clear();
+
+
+    // Automatic mode methods
+
+
+    /** Change automatic mode.
+
+        @param bIsAuto
+        When true, events will be fired automatically, not
+        only triggered by UI events. When false, auto events
+        will quit.
+    */
+    void setAutomaticMode( bool bIsAuto );
+
+    /** Get automatic mode setting.
+     */
+    bool getAutomaticMode() const;
+
+    /** Set the timeout for automatic mode.
+
+        @param nTimeout
+        Timeout, between end of effect until start of next
+        effect.
+    */
+    void setAutomaticTimeout( double nTimeout );
+
+    /** Get automatic mode timeout value.
+     */
+    double getAutomaticTimeout() const;
+
+    // Handler registration methods
+
+
+    /** Register an event handler that will be called when views are
+        changed.
+
+        For each view added, viewAdded() will be called on the
+        handler. For each view removed, viewRemoved() will be
+        called. Each modified view will cause a viewChanged() call on
+        each handler.
+
+        You don't need to deregister the handler, it will be
+        automatically removed, once the pointee becomes stale.
+
+        @param rHandler
+        Handler to call.
+    */
+    void addViewHandler( const ViewEventHandlerWeakPtr& rHandler );
+    void removeViewHandler( const ViewEventHandlerWeakPtr& rHandler );
+
+    /** Register an event handler that will be called when a view gets
+        clobbered.
+
+        Note that <em>all</em> registered handlers will be called when
+        the event. This is in contrast to the mouse events below.
+
+        @param rHandler
+        Handler to call when a view needs a repaint
+    */
+    void addViewRepaintHandler( const ViewRepaintHandlerSharedPtr& rHandler );
+    void removeViewRepaintHandler( const ViewRepaintHandlerSharedPtr& rHandler );
+
+    /** Register an event handler that will be called when
+        XShapeListeners are changed.
+
+        @param rHandler
+        Handler to call when a shape listener changes
+    */
+    void addShapeListenerHandler( const ShapeListenerEventHandlerSharedPtr& rHandler );
+    void removeShapeListenerHandler( const ShapeListenerEventHandlerSharedPtr& rHandler );
+
+    /** Register an event handler that will be called when
+        user paint parameters change.
+
+        @param rHandler
+        Handler to call when a shape listener changes
+    */
+    void addUserPaintHandler( const UserPaintEventHandlerSharedPtr& rHandler );
+
+    /** Register an event handler that will be called when the
+        user requests the next effect.
+
+        For every nextEffect event, only one of the handlers
+        registered here is called. The handlers are considered
+        with decreasing priority, i.e. the handler with the
+        currently highest priority will be called.
+
+        @param rHandler
+        Handler to call when the next effect should start
+
+        @param nPriority
+        Priority with which the handlers are called. The
+        higher the priority, the earlier this handler will be
+        tried.
+    */
+    void addNextEffectHandler( const EventHandlerSharedPtr& rHandler,
+                               double                       nPriority );
+    void removeNextEffectHandler( const EventHandlerSharedPtr& rHandler );
+
+    /** Register an event handler that will be called when the
+        slide is just shown.
+
+        Note that <em>all</em> registered handlers will be called
+        when the slide start occurs. This is in contrast to
+        the mouse events below.
+
+        @param rHandler
+        Handler to call when the next slide starts
+    */
+    void addSlideStartHandler( const EventHandlerSharedPtr& rHandler );
+    void removeSlideStartHandler( const EventHandlerSharedPtr& rHandler );
+
+    /** Register an event handler that will be called when the
+        slide is about to vanish.
+
+        Note that <em>all</em> registered handlers will be
+        called when the slide end occurs. This is in contrast
+        to the mouse events below.
+
+        @param rHandler
+        Handler to call when the current slide ends
+    */
+    void addSlideEndHandler( const EventHandlerSharedPtr& rHandler );
+    void removeSlideEndHandler( const EventHandlerSharedPtr& rHandler );
+
+    /** Register an event handler that will be called when an
+        XAnimationNode starts its active duration.
+
+        Note that <em>all</em> registered handlers will be called
+        when the animation start occurs. This is in contrast to
+        the mouse events below.
+
+        @param rHandler
+        Handler to call when the animation start
+    */
+    void addAnimationStartHandler(
+        const AnimationEventHandlerSharedPtr& rHandler );
+    void removeAnimationStartHandler(
+        const AnimationEventHandlerSharedPtr& rHandler );
+
+    /** Register an event handler that will be called when an
+        XAnimationNode ends its active duration.
+
+        Note that <em>all</em> registered handlers will be called
+        when the animation end occurs. This is in contrast to
+        the mouse events below.
+
+        @param rHandler
+        Handler to call when the animation ends
+    */
+    void addAnimationEndHandler(
+        const AnimationEventHandlerSharedPtr& rHandler );
+    void removeAnimationEndHandler(
+        const AnimationEventHandlerSharedPtr& rHandler );
+
+    /** Register an event handler that will be called when the
+        main animation sequence of a slide ends its active
+        duration.
+
+        Note that <em>all</em> registered handlers will be
+        called when the animation end occurs. This is in
+        contrast to the mouse events below.
+
+        @param rHandler
+        Handler to call when the animation ends
+    */
+    void addSlideAnimationsEndHandler(
+        const EventHandlerSharedPtr& rHandler );
+    void removeSlideAnimationsEndHandler(
+        const EventHandlerSharedPtr& rHandler );
+
+    /** Register an event handler that will be called when an
+        XAudio node's sound stops playing.
+
+        Note that <em>all</em> registered handlers will be
+        called when the audio stops. This is in contrast to
+        the mouse events below.
+
+        @param rHandler
+        Handler to call when the audio stops
+    */
+    void addAudioStoppedHandler(
+        const AnimationEventHandlerSharedPtr& rHandler );
+    void removeAudioStoppedHandler(
+        const AnimationEventHandlerSharedPtr& rHandler );
+
+    /** Register an event handler that will be called when an
+        XCommand node's with the command STOPAUDIO is activated.
+
+        Note that <em>all</em> registered handlers will be
+        called when the audio stops. This is in contrast to
+        the mouse events below.
+
+        @param rHandler
+        Handler to call when command is activated
+    */
+    void addCommandStopAudioHandler(
+        const AnimationEventHandlerSharedPtr& rHandler );
+    void removeCommandStopAudioHandler(
+        const AnimationEventHandlerSharedPtr& rHandler );
+
+    /** Register a handler that is called when the show enters
+        or exits pause mode.
+    */
+    void addPauseHandler( const PauseEventHandlerSharedPtr& rHandler );
+    void removePauseHandler( const PauseEventHandlerSharedPtr& rHandler );
+
+    /** Register a mouse handler that is called on mouse click
+
+        For every mouse click, only one of the handlers
+        registered here is called. The handlers are considered
+        with decreasing priority, i.e. the handler with the
+        currently highest priority will be called.
+
+        Since the handlers can reject down and up events
+        individually, handlers should expect to be called with
+        non-matching down and up-press counts. If your handler
+        cannot cope with that, it must have the highest
+        priority of all added handlers.
+    */
+    void addClickHandler( const MouseEventHandlerSharedPtr& rHandler,
+                          double                            nPriority );
+    void removeClickHandler( const MouseEventHandlerSharedPtr& rHandler );
+
+    /** Register a mouse handler that is called on a double
+        mouse click
+
+        For every mouse double click, only one of the handlers
+        registered here is called. The handlers are considered
+        with decreasing priority, i.e. the handler with the
+        currently highest priority will be called.
+
+        Since the handlers can reject down and up events
+        individually, handlers should expect to be called with
+        non-matching down and up-press counts. If your handler
+        cannot cope with that, it must have the highest
+        priority of all added handlers.
+    */
+    void addDoubleClickHandler( const MouseEventHandlerSharedPtr&   rHandler,
+                                double                              nPriority );
+    void removeDoubleClickHandler( const MouseEventHandlerSharedPtr& rHandler );
+
+    /** Register a mouse handler that is called for mouse moves.
+
+        For every mouse move, only one of the handlers
+        registered here is called. The handlers are considered
+        with decreasing priority, i.e. the handler with the
+        currently highest priority will be called.
+    */
+    void addMouseMoveHandler( const MouseEventHandlerSharedPtr& rHandler,
+                              double                            nPriority );
+    void removeMouseMoveHandler( const MouseEventHandlerSharedPtr& rHandler );
+
+
+    /** Registers a hyperlink click handler.
+
+        For every hyperlink click, only one of the handlers registered
+        here is called. The handlers are considered with decreasing
+        priority, i.e. the handler with the currently highest priority
+        will be called.
+
+        @param rHandler
+        @param nPriority
+    */
+    void addHyperlinkHandler( const HyperlinkHandlerSharedPtr& rHandler,
+                              double                           nPriority );
+    void removeHyperlinkHandler( const HyperlinkHandlerSharedPtr& rHandler );
+
+
+    // External event notifications
+
+
+    /** View added.
+
+        This method adds another view, which the show is
+        displayed on. On every added view, the EventMultiplexer
+        registers mouse and motion event listeners.
+    */
+    void notifyViewAdded( const UnoViewSharedPtr& rView );
+
+    /** View removed
+
+        This method removes a view. Registered mouse and
+        motion event listeners are revoked.
+    */
+    void notifyViewRemoved( const UnoViewSharedPtr& rView );
+
+    /** View changed
+
+        This method announces a changed view to all view
+        listeners. View changes include size and transformation.
+
+        @param rView
+        View that has changed
+    */
+    void notifyViewChanged( const UnoViewSharedPtr& rView );
+
+    /** View changed
+
+        This method announces a changed view to all view
+        listeners. View changes include size and transformation.
+
+        @param xView
+        View that has changed
+    */
+    void notifyViewChanged( const css::uno::Reference<css::presentation::XSlideShowView>& xView );
+
+    /** All Views changed
+
+        This method announces to all view listeners that
+        <em>every</em> known view has changed. View changes include
+        size and transformation.
+    */
+    void notifyViewsChanged();
+
+    /** View clobbered
+
+        This method announces that the given view has been clobbered
+        by something external to the slideshow, and needs an update.
+
+        @param xView
+        View that has been clobbered
+    */
+    void notifyViewClobbered( const css::uno::Reference<css::presentation::XSlideShowView>& xView );
+
+    /** New shape event listener added
+
+        This method announces that the given listener was added for
+        the specified shape.
+     */
+    void notifyShapeListenerAdded( const css::uno::Reference<css::drawing::XShape>& xShape );
+
+    /** A shape event listener was removed
+
+        This method announces that the given listener was removed for
+        the specified shape.
+     */
+    void notifyShapeListenerRemoved( const css::uno::Reference<css::drawing::XShape>& xShape );
+
+    /** Notify a new user paint color
+
+        Sending this notification also implies that user paint is
+        enabled. User paint denotes the feature to draw colored lines
+        on top of the slide content.
+    */
+    void notifyUserPaintColor( RGBColor const& rUserColor );
+
+    /** Notify a new user paint width
+
+         Sending this notification also implies that user paint is
+         enabled. .
+    */
+    void notifyUserPaintStrokeWidth( double rUserStrokeWidth );
+
+
+    /** Notify a new user paint erase all ink mode
+
+     Sending this notification also implies that user paint is
+     enabled. User paint denotes the feature to draw colored lines
+     on top of the slide content.
+     */
+    void notifyEraseAllInk( bool bEraseAllInk );
+    void notifySwitchPenMode();
+    void notifySwitchEraserMode();
+    void notifyEraseInkWidth( sal_Int32 rEraseInkSize );
+
+    /** Notify that user paint is disabled
+
+        User paint denotes the feature to draw colored lines on top of
+        the slide content.
+    */
+    void notifyUserPaintDisabled();
+
+    /** Notify that the user requested the next effect.
+
+        This requests the slideshow to display the next
+        effect, or move to the next slide, if none are left.
+
+        @return true, if this event was processed by
+        anybody. If false is returned, no handler processed
+        this event (and probably, nothing will happen at all)
+    */
+    bool notifyNextEffect();
+
+    /** Notify that a new slide has started
+
+        This method is to be used from the Presentation object
+        to signal that a new slide is starting now. This will
+        invoke all registered slide start handlers.
+    */
+    void notifySlideStartEvent();
+
+    /** Notify that a slide has ended
+
+        This method is to be used from the Presentation object
+        to signal that a slide is ending now. This will invoke
+        all registered slide end handlers.
+
+        @return true, if this event was processed by
+        anybody. If false is returned, no handler processed
+        this event (and probably, nothing will happen at all)
+    */
+    bool notifySlideEndEvent();
+
+    /** Notify that the given node enters its active duration.
+
+        This method is to be used from the AnimationNode
+        objects to signal that the active duration
+        begins. This will invoke all registered animation
+        start handlers.
+
+        @param rNode
+        Node which enters active duration.
+
+        @return true, if this event was processed by
+        anybody. If false is returned, no handler processed
+        this event (and probably, nothing will happen at all)
+    */
+    bool notifyAnimationStart( const AnimationNodeSharedPtr& rNode );
+
+    /** Notify that the given node leaves its active duration.
+
+        This method is to be used from the AnimationNode
+        objects to signal that the active duration
+        ends now. This will invoke all registered animation
+        end handlers.
+
+        @param rNode
+        Node which leaves active duration.
+
+        @return true, if this event was processed by
+        anybody. If false is returned, no handler processed
+        this event (and probably, nothing will happen at all)
+    */
+    bool notifyAnimationEnd( const AnimationNodeSharedPtr& rNode );
+
+    /** Notify that the slide animations sequence leaves its
+        active duration.
+
+        @return true, if this event was processed by
+        anybody. If false is returned, no handler processed
+        this event (and probably, nothing will happen at all)
+    */
+    bool notifySlideAnimationsEnd();
+
+    /** Notify that for the given node, audio output has stopped.
+
+        This method is to be used from the AnimationNode
+        objects to signal that audio playback has just
+        stopped. This will invoke all registered audio
+        stopped handlers.
+
+        @param rNode
+        Node for which audio has stopped.
+
+        @return true, if this event was processed by
+        anybody. If false is returned, no handler processed
+        this event (and probably, nothing will happen at all)
+    */
+    bool notifyAudioStopped( const AnimationNodeSharedPtr& rNode );
+
+    /** Notify that the show has entered or exited pause mode
+
+        This method is to be used from the Presentation object
+        to signal that a slide is entering (bPauseShow=true)
+        or exiting (bPauseShow=false) pause mode. This will
+        invoke all registered slide end handlers.
+    */
+    void notifyPauseMode( bool bPauseShow );
+
+    /** Notify that all audio has to be stopped.
+
+        This method is used by XCommand nodes and all sound
+        playing nodes should listen for this command and
+        stop their sounds when it's fired.
+
+        @return true, if this event was processed by
+        anybody. If false is returned, no handler processed
+        this event (and probably, nothing will happen at all)
+    */
+    bool notifyCommandStopAudio( const AnimationNodeSharedPtr& rNode );
+
+    /** Notifies that a hyperlink has been clicked.
+    */
+    void notifyHyperlinkClicked( OUString const& hyperLink );
+
+private:
+    std::unique_ptr<EventMultiplexerImpl> mpImpl;
+};
+
+} // namespace internal
+} // namespace Presentation
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_EVENTMULTIPLEXER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/eventqueue.hxx b/slideshow/source/inc/eventqueue.hxx
new file mode 100644
index 000000000..76c7eecbd
--- /dev/null
+++ b/slideshow/source/inc/eventqueue.hxx
@@ -0,0 +1,151 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_EVENTQUEUE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_EVENTQUEUE_HXX
+
+#include <canvas/elapsedtime.hxx>
+#include <osl/mutex.hxx>
+
+#include "event.hxx"
+
+#include <queue>
+#include <vector>
+
+
+/* Definition of ActivitiesQueue class */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** This class handles events in a presentation. Events are
+            time instants where e.g. effects start.
+         */
+        class EventQueue
+        {
+        public:
+            EventQueue(
+                std::shared_ptr< ::canvas::tools::ElapsedTime >
+                const & pPresTimer );
+
+            ~EventQueue();
+
+            EventQueue(const EventQueue&) = delete;
+            EventQueue& operator=(const EventQueue&) = delete;
+
+            /** Add the given event to the queue. The event is fired
+                at, or shortly after, its Event::getActivationTime instant.
+             */
+            bool addEvent( const EventSharedPtr& event );
+
+            /** Add the given event to the queue. The event is fired
+                at, or shortly after, its Event::getActivationTime instant.
+                The difference to addEvent() is that events added during
+                process() are postponed to next process().
+             */
+            bool addEventForNextRound( const EventSharedPtr& event );
+
+            /** Another way to control the order of asynchronous event
+                execution.  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
+                expired when calling this method (i.e. all events
+                whose scheduled time is less or equal the current
+                time).
+
+                Check for the next available event's timeout via
+                nextTimeout(), or whether the queue is empty
+                altogether via isEmpty().
+             */
+            void process();
+
+            /** Query state of the queue
+
+                @return false, if queue is empty, true otherwise
+             */
+            bool isEmpty() const;
+
+            /** Query timeout for the topmost event in the queue.
+
+                @return Timeout in seconds, until the next event is
+                ready. The time returned here is relative to the pres
+                timer (i.e. the timer specified at the EventQueue
+                constructor). When the queue is empty (i.e. isEmpty()
+                returns true), the returned value is the highest
+                representable double value
+                (::std::numeric_limits<double>::max()). If the topmost
+                event in the queue is already pending, the timeout
+                returned here will actually be negative.
+            */
+            double nextTimeout() const;
+
+            /** Remove all pending events from the queue.
+             */
+            void clear();
+
+            /** Forces an empty queue, firing all events immediately
+                without minding any times.
+                @attention do only call from event loop, this calls process_()!
+             */
+            void forceEmpty();
+
+            /** Gets the queue's timer object.
+             */
+            std::shared_ptr< ::canvas::tools::ElapsedTime > const &
+            getTimer() const { return mpTimer; }
+
+        private:
+            mutable ::osl::Mutex      maMutex;
+
+            struct EventEntry
+            {
+                EventSharedPtr  pEvent;
+                double          nTime;
+
+                bool operator<( const EventEntry& ) const; // to leverage priority_queue's default compare
+
+                EventEntry( EventSharedPtr const& p, double t )
+                    : pEvent(p), nTime(t) {}
+            };
+
+            typedef ::std::priority_queue< EventEntry > ImplQueueType;
+            ImplQueueType                   maEvents;
+            typedef ::std::vector<EventEntry> EventEntryVector;
+            EventEntryVector                maNextEvents;
+            ImplQueueType                   maNextNextEvents;
+            void process_( bool bFireAllEvents );
+
+            // perform timing of events via relative time
+            // measurements. The world time starts, when the
+            // EventQueue object is created
+            std::shared_ptr< ::canvas::tools::ElapsedTime > mpTimer;
+        };
+
+    }
+}
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_EVENTQUEUE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/expressionnode.hxx b/slideshow/source/inc/expressionnode.hxx
new file mode 100644
index 000000000..fef80fc7c
--- /dev/null
+++ b/slideshow/source/inc/expressionnode.hxx
@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_EXPRESSIONNODE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_EXPRESSIONNODE_HXX
+
+/* Definition of ExpressionNode interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Interface describing an abstract animation function.
+
+            Use this interface to model time-dependent animation
+            functions of one variable.
+         */
+        class AnimationFunction
+        {
+        public:
+            virtual ~AnimationFunction() {}
+
+            /** Operator to calculate function value.
+
+                This method calculates the function value for the
+                given time instant t.
+
+                @param t
+                Current time instant, must be in the range [0,1]
+
+                @return the function value, typically in relative
+                user coordinate space ([0,1] range).
+             */
+            virtual double operator()( double t ) const = 0;
+
+        };
+
+        /** Refinement of AnimationFunction
+
+            This interface is used by the SMIL function parser, to
+            collapse constant values into precalculated, single nodes.
+        */
+        class ExpressionNode : public AnimationFunction
+        {
+        public:
+            /** Predicate whether this node is constant.
+
+                This predicate returns true, if this node is
+                neither time- nor ViewInfo dependent. This allows
+                for certain optimizations, i.e. not the full
+                expression tree needs be represented by
+                ExpressionNodes.
+
+                @returns true, if this node is neither time- nor
+                ViewInfo dependent
+            */
+            virtual bool isConstant() const = 0;
+        };
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_EXPRESSIONNODE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/expressionnodefactory.hxx b/slideshow/source/inc/expressionnodefactory.hxx
new file mode 100644
index 000000000..56244e843
--- /dev/null
+++ b/slideshow/source/inc/expressionnodefactory.hxx
@@ -0,0 +1,72 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_EXPRESSIONNODEFACTORY_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_EXPRESSIONNODEFACTORY_HXX
+
+#include "expressionnode.hxx"
+
+#include <memory>
+
+
+/* Definition of ExpressionNodeFactory class */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** ExpressionNode factory
+
+            This class can be used to generate a wide variety of
+            ExpressionNode objects, e.g. when parsing SMIL function
+            expressions.
+        */
+        class ExpressionNodeFactory
+        {
+        public:
+            static std::shared_ptr<ExpressionNode> createConstantValueExpression( double rConstantValue );
+
+            static std::shared_ptr<ExpressionNode> createValueTExpression    ();
+
+            static std::shared_ptr<ExpressionNode> createPlusExpression      ( const std::shared_ptr<ExpressionNode>&   rLHS,
+                                                                       const std::shared_ptr<ExpressionNode>&   rRHS );
+            static std::shared_ptr<ExpressionNode> createMinusExpression     ( const std::shared_ptr<ExpressionNode>&   rLHS,
+                                                                       const std::shared_ptr<ExpressionNode>&   rRHS );
+            static std::shared_ptr<ExpressionNode> createMultipliesExpression( const std::shared_ptr<ExpressionNode>&   rLHS,
+                                                                       const std::shared_ptr<ExpressionNode>&   rRHS );
+            static std::shared_ptr<ExpressionNode> createDividesExpression   ( const std::shared_ptr<ExpressionNode>&   rLHS,
+                                                                       const std::shared_ptr<ExpressionNode>&   rRHS );
+
+            /** Composes two ExpressionNode function.
+
+                The resulting expression will calculate
+                rOuterFunction( rInnerFunction(t) ).
+             */
+            static std::shared_ptr<ExpressionNode> createMinExpression      ( const std::shared_ptr<ExpressionNode>&    rOuterFunction,
+                                                                      const std::shared_ptr<ExpressionNode>&    rInnerFunction );
+
+            static std::shared_ptr<ExpressionNode> createMaxExpression      ( const std::shared_ptr<ExpressionNode>&    rOuterFunction,
+                                                                      const std::shared_ptr<ExpressionNode>&    rInnerFunction );
+        };
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_EXPRESSIONNODEFACTORY_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/framerate.hxx b/slideshow/source/inc/framerate.hxx
new file mode 100644
index 000000000..af861dce6
--- /dev/null
+++ b/slideshow/source/inc/framerate.hxx
@@ -0,0 +1,47 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_FRAMERATE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_FRAMERATE_HXX
+
+#include <sal/types.h>
+
+namespace slideshow::internal {
+
+/** Some frame rate related data.
+*/
+class FrameRate
+{
+public:
+    /** The minimum number of frames per second is used to calculate the
+        minimum number of frames that is to be shown for active activities.
+    */
+    static const sal_Int32 MinimumFramesPerSecond = 10;
+
+    /** Aim high with the number of preferred number of frames per second.
+        This number is the maximum as well and the true number will be lower.
+    */
+    static const sal_Int32 PreferredFramesPerSecond = 50;
+};
+
+} // end of namespace slideshow::internal
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/hslcolor.hxx b/slideshow/source/inc/hslcolor.hxx
new file mode 100644
index 000000000..74b38995a
--- /dev/null
+++ b/slideshow/source/inc/hslcolor.hxx
@@ -0,0 +1,97 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_HSLCOLOR_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_HSLCOLOR_HXX
+
+
+/* Definition of HSLColor class */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        class RGBColor;
+
+        /** HSL color space class.
+         */
+        class HSLColor
+        {
+        public:
+            HSLColor();
+            HSLColor( double nHue, double nSaturation, double nLuminance );
+            explicit HSLColor( const RGBColor& rColor );
+
+            /** Hue of the color.
+
+                @return hue, is in the range [0,360]
+             */
+            double getHue() const {  return maHSLTriple.mnHue; }
+
+            /** Saturation of the color.
+
+                @return saturation, is in the range [0,1]
+             */
+            double getSaturation() const {  return maHSLTriple.mnSaturation; }
+
+            /** Luminance of the color.
+
+                @return luminance, is in the range [0,1]
+             */
+            double getLuminance() const {  return maHSLTriple.mnLuminance; }
+
+            struct HSLTriple
+            {
+                HSLTriple();
+                HSLTriple( double nHue, double nSaturation, double nLuminance );
+
+                double mnHue;
+                double mnSaturation;
+                double mnLuminance;
+            };
+
+        private:
+            // default copy/assignment are okay
+            // HSLColor(const HSLColor&);
+            // HSLColor& operator=( const HSLColor& );
+
+            HSLTriple   maHSLTriple;
+
+        };
+
+        bool operator==( const HSLColor& rLHS, const HSLColor& rRHS );
+        bool operator!=( const HSLColor& rLHS, const HSLColor& rRHS );
+        HSLColor operator+( const HSLColor& rLHS, const HSLColor& rRHS );
+        HSLColor operator*( double nFactor, const HSLColor& rRHS );
+
+        /** HSL color linear interpolator.
+
+            @param t
+            As usual, t must be in the [0,1] range
+
+            @param bCCW
+            When true, hue interpolation happens counter-clockwise
+        */
+        HSLColor interpolate( const HSLColor& rFrom, const HSLColor& rTo, double t, bool bCCW );
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_HSLCOLOR_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/hslcoloranimation.hxx b/slideshow/source/inc/hslcoloranimation.hxx
new file mode 100644
index 000000000..e20cbc802
--- /dev/null
+++ b/slideshow/source/inc/hslcoloranimation.hxx
@@ -0,0 +1,71 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_HSLCOLORANIMATION_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_HSLCOLORANIMATION_HXX
+
+#include "animation.hxx"
+#include "hslcolor.hxx"
+
+
+/* Definition of HSLColorAnimation interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Interface defining a HSL color animation.
+
+            This interface is a specialization of the Animation
+            interface, and is used to animate attributes representable
+            by a HSL color value.
+         */
+        class HSLColorAnimation : public Animation
+        {
+        public:
+            typedef HSLColor ValueType;
+
+            /** Set the animation to the given color value
+
+                @param rColor
+                Current animation value.
+             */
+            virtual bool operator()( const HSLColor& rColor ) = 0;
+
+            /** Request the underlying value for this animation.
+
+                This is necessary for pure To or By animations, as the
+                Activity cannot determine a sensible start value
+                otherwise.
+
+                @attention Note that you are only permitted to query
+                for the underlying value, if the animation has actually
+                been started (via start() call).
+             */
+            virtual HSLColor getUnderlyingValue() const = 0;
+        };
+
+        typedef ::std::shared_ptr< HSLColorAnimation > HSLColorAnimationSharedPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_HSLCOLORANIMATION_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/hyperlinkarea.hxx b/slideshow/source/inc/hyperlinkarea.hxx
new file mode 100644
index 000000000..631c3f26f
--- /dev/null
+++ b/slideshow/source/inc/hyperlinkarea.hxx
@@ -0,0 +1,100 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_HYPERLINKAREA_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_HYPERLINKAREA_HXX
+
+#include <rtl/ustring.hxx>
+
+#include <memory>
+#include <vector>
+#include <utility>
+
+namespace basegfx {
+    class B2DRange;
+}
+
+/* Definition of HyperlinkArea interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** HyperlinkArea interface
+
+            Implementers of this interface provide information for
+            hyperlink sensitive areas.
+         */
+        class HyperlinkArea
+        {
+        public:
+            typedef std::pair< ::basegfx::B2DRange,
+                               OUString >    HyperlinkRegion;
+
+            typedef std::vector<HyperlinkRegion>    HyperlinkRegions;
+
+            /** Request hyperlink-sensitive areas.
+
+                @return a vector of hyperlink-sensitive areas, plus
+                the URI associated to them.
+             */
+            virtual HyperlinkRegions getHyperlinkRegions() const = 0;
+
+            /** Retrieve priority of link area
+
+                @return the priority of the link area. Link areas with
+                higher priority will receive hyperlink clicks in favor
+                of areas with less priority, if they cover the same
+                place on screen.
+             */
+            virtual double getHyperlinkPriority() const = 0;
+
+            /** Functor struct, for area ordering
+
+                This defines a strict weak ordering of areas, sort key
+                is the object ptr value. Most typical use is for
+                associative containers holding areas.
+             */
+            struct lessThanArea
+            {
+                // make functor adaptable (to boost::bind)
+                typedef bool result_type;
+
+                bool operator()(const std::shared_ptr< HyperlinkArea >& rLHS,
+                                const std::shared_ptr< HyperlinkArea >& rRHS) const
+                {
+                    const double nPrioL( rLHS->getHyperlinkPriority() );
+                    const double nPrioR( rRHS->getHyperlinkPriority() );
+
+                    // if prios are equal, tie-break on ptr value
+                    return nPrioL == nPrioR ? rLHS.get() < rRHS.get() : nPrioL < nPrioR;
+                }
+            };
+
+        protected:
+            ~HyperlinkArea() {}
+       };
+
+        typedef std::shared_ptr< HyperlinkArea > HyperlinkAreaSharedPtr;
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_HYPERLINKAREA_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/iexternalmediashapebase.hxx b/slideshow/source/inc/iexternalmediashapebase.hxx
new file mode 100644
index 000000000..3a174e977
--- /dev/null
+++ b/slideshow/source/inc/iexternalmediashapebase.hxx
@@ -0,0 +1,86 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_IEXTERNALMEDIASHAPEBASE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_IEXTERNALMEDIASHAPEBASE_HXX
+
+#include <memory>
+
+#include "shape.hxx"
+
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Represents a shape containing playable content rendered by
+            external engine (e.g. media or applet).
+
+            This interface adds media handling methods to a shape. It
+            allows starting/stopping and pausing playback.
+        */
+        class IExternalMediaShapeBase : public Shape
+        {
+        public:
+            // Animation methods
+
+
+            /** Notify the Shape that it should start with playback
+
+                This method enters playback mode on all registered
+                views. It makes the media initially visible (for videos).
+             */
+            virtual void play() = 0;
+
+            /** Notify the Shape that it should stop playback
+
+                This method leaves playback mode on all registered
+                views. The media is then rewound to the start, and
+                removed from screen (for videos)
+             */
+            virtual void stop() = 0;
+
+            /** Notify the Shape that it should pause playback
+
+                This method stops playback on all registered
+                views. The media stays visible (for videos)
+             */
+            virtual void pause() = 0;
+
+            /** Query whether the media is currently playing.
+             */
+            virtual bool isPlaying() const = 0;
+
+            /** Set media time in seconds.
+
+            @param fTime
+            Time in seconds of the media time line, that should now be
+            presented
+             */
+            virtual void setMediaTime(double fTime) = 0;
+        };
+
+        typedef ::std::shared_ptr< IExternalMediaShapeBase > IExternalMediaShapeBaseSharedPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_IEXTERNALMEDIASHAPEBASE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/interruptabledelayevent.hxx b/slideshow/source/inc/interruptabledelayevent.hxx
new file mode 100644
index 000000000..388c1db64
--- /dev/null
+++ b/slideshow/source/inc/interruptabledelayevent.hxx
@@ -0,0 +1,142 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_INTERRUPTABLEDELAYEVENT_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_INTERRUPTABLEDELAYEVENT_HXX
+
+#include "delayevent.hxx"
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Event, which delays calling passed Event's fire() method
+            the given amount of time.
+
+            This is actually a facade around the passed event object,
+            that passes on all calls to that object, and the sole
+            contribution of itself is the delay.
+        */
+        class DelayFacade : public Event
+        {
+        public:
+            DelayFacade( const EventSharedPtr&  rEvent,
+                         double                 nTimeout    ) :
+                Event("DelayFacade"),
+                mpEvent( rEvent ),
+                mnTimeout( nTimeout )
+            {
+            }
+
+            virtual bool fire() override
+            {
+                if( mpEvent && isCharged() )
+                {
+                    // pass on directly - we're supposed to be called
+                    // from EventQueue here, anyway - and if not,
+                    // we're only keeping that incorrect transitively.
+                    return mpEvent->fire();
+                }
+
+                return false;
+            }
+
+            virtual bool isCharged() const override
+            {
+                // pass on to wrappee - this ensures that we return
+                // false on isCharged(), even if the other event has
+                // been fired outside our own fire() method
+                return mpEvent && mpEvent->isCharged();
+            }
+
+            virtual double getActivationTime( double nCurrentTime ) const override
+            {
+                // enforce _our_ timeout to our clients (this
+                // overrides any timeout possibly set at the wrappee!)
+                return nCurrentTime + mnTimeout;
+            }
+
+            virtual void dispose() override
+            {
+                mpEvent.reset();
+            }
+
+        private:
+            EventSharedPtr  mpEvent;
+            double          mnTimeout;
+        };
+
+        /// Return value for makeInterruptableDelay()
+        struct InterruptableEventPair
+        {
+            /** This member contains a pointer to the timeout
+                event. When enqueued, this event will fire the
+                requested action only after the specified timeout.
+             */
+            EventSharedPtr  mpTimeoutEvent;
+
+            /** This member contains a pointer to the interruption
+                event. When enqueued, this event will fire
+                immediately, interrupting a potentially waiting
+                timeout event.
+             */
+            EventSharedPtr  mpImmediateEvent;
+        };
+
+        /** Generate an interruptable delay event.
+
+            This function generates a pair of events, that are
+            especially tailored to achieve the following behaviour: By
+            default, the given functor is called after the specified
+            timeout (after insertion of the event into the EventQueue,
+            of course). But optionally, when the interruption event
+            InterruptableEventPair::mpImmediateEvent is fired, the
+            given functor is called <em>at once</em>, and the delay is
+            ignored (that means, the given functor is guaranteed to be
+            called at utmost once, and never twice. Furthermore, it is
+            ensured that both events return false on isCharged(), once
+            anyone of them has been fired already).
+
+            @param rFunctor
+            Functor to call when the event fires.
+
+            @param nTimeout
+            Timeout in seconds, to wait until functor is called.
+
+            @returns a pair of events, where the first one waits the
+            specified amount of time, and the other fires the given
+            functor immediately.
+         */
+        template< typename Functor > InterruptableEventPair makeInterruptableDelay( const Functor&  rFunctor,
+                                                                                    double          nTimeout    )
+        {
+            InterruptableEventPair aRes;
+
+            aRes.mpImmediateEvent = makeEvent( rFunctor, "makeInterruptableDelay");
+            aRes.mpTimeoutEvent = std::make_shared<DelayFacade>( aRes.mpImmediateEvent,
+                                                        nTimeout );
+
+            return aRes;
+        }
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_INTERRUPTABLEDELAYEVENT_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/intrinsicanimationeventhandler.hxx b/slideshow/source/inc/intrinsicanimationeventhandler.hxx
new file mode 100644
index 000000000..6016bb227
--- /dev/null
+++ b/slideshow/source/inc/intrinsicanimationeventhandler.hxx
@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_INTRINSICANIMATIONEVENTHANDLER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_INTRINSICANIMATIONEVENTHANDLER_HXX
+
+#include <memory>
+
+/* Definition of IntrinsicAnimationEventHandler interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+
+        /** Interface for handling intrinsic animation display modes.
+
+            Classes implementing this interface can be added to an
+            EventMultiplexer object, and are called from there to
+            handle intrinsic animation events.
+         */
+        class IntrinsicAnimationEventHandler
+        {
+        public:
+            virtual ~IntrinsicAnimationEventHandler() {}
+
+            virtual bool enableAnimations() = 0;
+            virtual bool disableAnimations() = 0;
+        };
+
+        typedef ::std::shared_ptr< IntrinsicAnimationEventHandler > IntrinsicAnimationEventHandlerSharedPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_INTRINSICANIMATIONEVENTHANDLER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/listenercontainer.hxx b/slideshow/source/inc/listenercontainer.hxx
new file mode 100644
index 000000000..3cdcb10b4
--- /dev/null
+++ b/slideshow/source/inc/listenercontainer.hxx
@@ -0,0 +1,420 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_LISTENERCONTAINER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_LISTENERCONTAINER_HXX
+
+#include <algorithm>
+#include <memory>
+#include <vector>
+#include <iterator>
+
+namespace slideshow {
+namespace internal {
+
+struct EmptyBase
+{
+    struct EmptyGuard{ explicit EmptyGuard(EmptyBase) {} };
+    struct EmptyClearableGuard
+    {
+        explicit EmptyClearableGuard(EmptyBase) {}
+        static void clear() {}
+    };
+
+    typedef EmptyGuard           Guard;
+    typedef EmptyClearableGuard ClearableGuard;
+};
+
+template< typename result_type, typename ListenerTargetT > struct FunctionApply
+{
+    template<typename FuncT> static bool apply(
+        FuncT           func,
+        ListenerTargetT const& rArg )
+    {
+        return func(rArg);
+    }
+};
+
+template<typename ListenerTargetT> struct FunctionApply<void,ListenerTargetT>
+{
+    template<typename FuncT> static bool apply(
+        FuncT                  func,
+        ListenerTargetT const& rArg )
+    {
+        func(rArg);
+        return true;
+    }
+};
+
+template< typename ListenerT > struct ListenerOperations
+{
+    /// Notify a single one of the listeners
+    template< typename ContainerT,
+              typename FuncT >
+    static bool notifySingleListener( ContainerT& rContainer,
+                                      FuncT       func )
+    {
+        // true: a handler in this queue processed the event
+        // false: no handler in this queue finally processed the event
+        return std::any_of( rContainer.begin(),
+                            rContainer.end(),
+                            func );
+    }
+
+    /// Notify all listeners
+    template< typename ContainerT,
+              typename FuncT >
+    static bool notifyAllListeners( ContainerT& rContainer,
+                                    FuncT       func )
+    {
+        bool bRet(false);
+        for( const auto& rCurr : rContainer )
+        {
+            if( FunctionApply< typename ::std::result_of< FuncT( const typename ContainerT::value_type& ) >::type,
+                               typename ContainerT::value_type >::apply(
+                                   func,
+                                   rCurr) )
+            {
+                bRet = true;
+            }
+        }
+
+        // true: at least one handler returned true
+        // false: not a single handler returned true
+        return bRet;
+    }
+
+    /// Prune container from deceased listeners
+    template< typename ContainerT >
+    static void pruneListeners( ContainerT&, size_t )
+    {
+    }
+};
+
+template< typename ListenerTargetT >
+struct ListenerOperations< std::weak_ptr<ListenerTargetT> >
+{
+    template< typename ContainerT,
+              typename FuncT >
+    static bool notifySingleListener( ContainerT& rContainer,
+                                      FuncT       func )
+    {
+        for( const auto& rCurr : rContainer )
+        {
+            std::shared_ptr<ListenerTargetT> pListener( rCurr.lock() );
+
+            if( pListener && func(pListener) )
+                return true;
+        }
+
+        return false;
+    }
+
+    template< typename ContainerT,
+              typename FuncT >
+    static bool notifyAllListeners( ContainerT& rContainer,
+                                    FuncT       func )
+    {
+        bool bRet(false);
+        for( const auto& rCurr : rContainer )
+        {
+            std::shared_ptr<ListenerTargetT> pListener( rCurr.lock() );
+
+            if( pListener.get() &&
+                FunctionApply<typename ::std::result_of<FuncT (std::shared_ptr<ListenerTargetT> const&)>::type,
+                               std::shared_ptr<ListenerTargetT> >::apply(func,pListener) )
+            {
+                bRet = true;
+            }
+        }
+
+        return bRet;
+    }
+    template< typename ContainerT >
+    static void pruneListeners( ContainerT& rContainer,
+                                size_t      nSizeThreshold )
+    {
+        if( rContainer.size() <= nSizeThreshold )
+            return;
+
+        ContainerT aAliveListeners;
+        aAliveListeners.reserve(rContainer.size());
+
+        for( const auto& rCurr : rContainer )
+        {
+            if( !rCurr.expired() )
+                aAliveListeners.push_back( rCurr );
+        }
+
+        std::swap( rContainer, aAliveListeners );
+    }
+};
+
+/** Container for objects that can be notified.
+
+    This templatized container holds listener objects, then can get
+    notified (by calling certain methods on them).
+
+    @tpl Listener
+    Type for the listener objects to be held
+
+    @tpl ContainerT
+    Full type of the container to store the listener objects. Defaults
+    to std::vector<ListenerT>
+
+    @tpl MaxDeceasedListenerUllage
+    Threshold, from which upwards the listener container gets
+    pruned. Avoids frequent copying of nearly empty containers.
+
+    @attention internal class, not to be used. functionality is
+    incomplete, please use the Thread(Un)safeListenerContainer types
+    from below
+*/
+template< typename ListenerT,
+          typename MutexHolderBaseT,
+          typename ContainerT=std::vector<ListenerT>,
+          size_t MaxDeceasedListenerUllage=16 > class ListenerContainerBase : public MutexHolderBaseT
+{
+    typedef typename MutexHolderBaseT::Guard           Guard;
+    typedef typename MutexHolderBaseT::ClearableGuard  ClearableGuard;
+
+public:
+    typedef ListenerT        listener_type;
+    typedef ContainerT       container_type;
+
+    /** Check whether listener container is empty
+
+        @return true, if currently no listeners registered. Note that
+        in a multi-threaded scenario, without external synchronisation
+        to this object, the return value might become wrong at any time.
+     */
+    bool isEmpty() const
+    {
+        Guard aGuard(*this);
+        return maListeners.empty();
+    }
+
+    /** Check whether given listener is already added
+
+        @return true, if given listener is already added.
+     */
+    bool isAdded( listener_type const& rListener ) const
+    {
+        Guard aGuard(*this);
+
+        const typename container_type::const_iterator aEnd( maListeners.end() );
+        if( std::find( maListeners.begin(),
+                       aEnd,
+                       rListener ) != aEnd )
+        {
+            return true; // already added
+        }
+
+        return false;
+    }
+
+    /** Add new listener
+
+        @param rListener
+        Listener to add
+     */
+    void add( listener_type const& rListener )
+    {
+        Guard aGuard(*this);
+
+        // ensure uniqueness
+        if( isAdded(rListener) )
+            return; // already added
+
+        maListeners.push_back( rListener );
+
+        ListenerOperations<ListenerT>::pruneListeners(
+            maListeners,
+            MaxDeceasedListenerUllage);
+    }
+
+    /** Add new listener into sorted container
+
+        The stored listeners are kept sorted (using this method
+        requires listener_type to have operator< defined on it). Make
+        sure to call addSorted() for <em>each</em> listener to add to
+        this container - sorting is performed under the assumption
+        that existing entries are already sorted.
+
+        @param rListener
+        Listener to add
+
+        @return false, if the listener is already added, true
+        otherwise
+     */
+    bool addSorted( listener_type const& rListener )
+    {
+        Guard aGuard(*this);
+
+        // ensure uniqueness
+        if( isAdded(rListener) )
+            return false; // already added
+
+        maListeners.push_back( rListener );
+
+        // a single entry does not need to be sorted
+        if( maListeners.size() > 1 )
+        {
+            std::inplace_merge(
+                maListeners.begin(),
+                std::prev(maListeners.end()),
+                maListeners.end() );
+        }
+
+        ListenerOperations<ListenerT>::pruneListeners(
+            maListeners,
+            MaxDeceasedListenerUllage);
+
+        return true;
+    }
+
+    /** Remove listener from container
+
+        @param rListener
+        The listener to remove
+
+        @return false, if listener not found in container, true
+        otherwise
+     */
+    bool remove( listener_type const& rListener )
+    {
+        Guard aGuard(*this);
+
+        const typename container_type::iterator aEnd( maListeners.end() );
+        typename container_type::iterator       aIter;
+        if( (aIter=std::remove(maListeners.begin(),
+                               aEnd,
+                               rListener)) == aEnd )
+        {
+            return false; // listener not found
+        }
+
+        maListeners.erase( aIter, aEnd );
+
+        return true;
+    }
+
+    /// Removes all listeners in one go
+    void clear()
+    {
+        Guard aGuard(*this);
+
+        maListeners.clear();
+    }
+
+    /** Apply functor to one listener
+
+        This method applies functor to one of the listeners. Starting
+        with the first entry of the container, the functor is called
+        with the listener entries, until it returns true.
+
+        @param func
+        Given functor is called with listeners, until it returns true
+
+        @return true, if functor was successfully applied to a
+        listener
+     */
+    template< typename FuncT > bool apply( FuncT func ) const
+    {
+        ClearableGuard aGuard(*this);
+
+        // generate a local copy of all handlers, to make method
+        // reentrant and thread-safe.
+        container_type const local( maListeners );
+        aGuard.clear();
+
+        const bool bRet(
+            ListenerOperations<ListenerT>::notifySingleListener(
+                local,
+                func ));
+
+        {
+            Guard aGuard2(*this);
+            ListenerOperations<ListenerT>::pruneListeners(
+                const_cast<container_type&>(maListeners),
+                MaxDeceasedListenerUllage);
+        }
+
+        return bRet;
+    }
+
+    /** Apply functor to all listeners
+
+        This method applies functor to all of the listeners. Starting
+        with the first entry of the container, the functor is called
+        with the listener entries.
+
+        @param func
+        Given functor is called with listeners.
+
+        @return true, if functor was successfully applied to at least
+        one listener
+     */
+    template< typename FuncT > bool applyAll( FuncT func ) const
+    {
+        ClearableGuard aGuard(*this);
+
+        // generate a local copy of all handlers, to make method
+        // reentrant and thread-safe.
+        container_type const local( maListeners );
+        aGuard.clear();
+
+        const bool bRet(
+            ListenerOperations<ListenerT>::notifyAllListeners(
+                local,
+                func ));
+
+        {
+            Guard aGuard2(*this);
+            ListenerOperations<ListenerT>::pruneListeners(
+                const_cast<container_type&>(maListeners),
+                MaxDeceasedListenerUllage);
+        }
+
+        return bRet;
+    }
+
+private:
+    ContainerT  maListeners;
+};
+
+
+/** ListenerContainer variant that does not serialize access
+
+    This ListenerContainer version is not safe to use in a
+    multi-threaded scenario, but has less overhead.
+ */
+template< typename ListenerT,
+          typename ContainerT=std::vector<ListenerT> >
+class ThreadUnsafeListenerContainer : public ListenerContainerBase<ListenerT,
+                                                                   EmptyBase,
+                                                                   ContainerT>
+{
+};
+
+} // namespace internal
+} // namespace slideshow
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_LISTENERCONTAINER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/mediafilemanager.hxx b/slideshow/source/inc/mediafilemanager.hxx
new file mode 100644
index 000000000..6588defa8
--- /dev/null
+++ b/slideshow/source/inc/mediafilemanager.hxx
@@ -0,0 +1,37 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_MEDIAFILEMANAGER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_MEDIAFILEMANAGER_HXX
+
+#include <rtl/ustring.hxx>
+
+#include <memory>
+
+namespace avmedia
+{
+struct MediaTempFile;
+}
+
+namespace slideshow
+{
+namespace internal
+{
+class MediaFileManager
+{
+public:
+    virtual ~MediaFileManager(){};
+    virtual std::shared_ptr<avmedia::MediaTempFile> getMediaTempFile(const OUString& aUrl) = 0;
+};
+}
+}
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_MEDIAFILEMANAGER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/mouseeventhandler.hxx b/slideshow/source/inc/mouseeventhandler.hxx
new file mode 100644
index 000000000..926a1acda
--- /dev/null
+++ b/slideshow/source/inc/mouseeventhandler.hxx
@@ -0,0 +1,116 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_MOUSEEVENTHANDLER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_MOUSEEVENTHANDLER_HXX
+
+#include <sal/types.h>
+
+#include <memory>
+
+namespace com::sun::star::awt { struct MouseEvent; }
+
+
+/* Definition of MouseEventHandler interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+
+        /** Interface for handling mouse events.
+
+            Classes implementing this interface can be added to an
+            EventMultiplexer object, and are called from there to
+            handle mouse events.
+         */
+        class MouseEventHandler
+        {
+        public:
+            virtual ~MouseEventHandler() {}
+
+            /** Handle a mouse button pressed event.
+
+                @param e
+                The mouse event that occurred. The x,y coordinates of
+                the event are already transformed back to user
+                coordinate space, taking the inverse transform of the
+                view in which the event occurred.
+
+                @return true, if this handler has successfully
+                processed the mouse event. When this method returns
+                false, possibly other, less prioritized handlers can be
+                called, too.
+             */
+            virtual bool handleMousePressed( const css::awt::MouseEvent& e ) = 0;
+
+            /** Handle a mouse button released event.
+
+                @param e
+                The mouse event that occurred. The x,y coordinates of
+                the event are already transformed back to user
+                coordinate space, taking the inverse transform of the
+                view in which the event occurred.
+
+                @return true, if this handler has successfully
+                processed the pause event. When this method returns
+                false, possibly other, less prioritized handlers are
+                called, too.
+             */
+            virtual bool handleMouseReleased( const css::awt::MouseEvent& e ) = 0;
+
+            /** Handle a mouse was moved with a pressed button event.
+
+                @param e
+                The mouse event that occurred. The x,y coordinates of
+                the event are already transformed back to user
+                coordinate space, taking the inverse transform of the
+                view in which the event occurred.
+
+                @return true, if this handler has successfully
+                processed the pause event. When this method returns
+                false, possibly other, less prioritized handlers are
+                called, too.
+             */
+            virtual bool handleMouseDragged( const css::awt::MouseEvent& e ) = 0;
+
+            /** Handle a mouse was moved event.
+
+                @param e
+                The mouse event that occurred. The x,y coordinates of
+                the event are already transformed back to user
+                coordinate space, taking the inverse transform of the
+                view in which the event occurred.
+
+                @return true, if this handler has successfully
+                processed the pause event. When this method returns
+                false, possibly other, less prioritized handlers are
+                called, too.
+             */
+            virtual bool handleMouseMoved( const css::awt::MouseEvent& e ) = 0;
+        };
+
+        typedef ::std::shared_ptr< MouseEventHandler > MouseEventHandlerSharedPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_MOUSEEVENTHANDLER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/numberanimation.hxx b/slideshow/source/inc/numberanimation.hxx
new file mode 100644
index 000000000..ab9e9a393
--- /dev/null
+++ b/slideshow/source/inc/numberanimation.hxx
@@ -0,0 +1,73 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_NUMBERANIMATION_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_NUMBERANIMATION_HXX
+
+#include "animation.hxx"
+
+
+/* Definition of NumberAnimation interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Interface defining a number animation.
+
+            This interface is a specialization of the Animation
+            interface, and is used to animate attributes representable
+            by a single floating point value.
+         */
+        class NumberAnimation : public Animation
+        {
+        public:
+            typedef double ValueType;
+
+            /** Set the animation to value x
+
+                @param x
+                Current animation value (must be in an
+                attribute-specific permissible range). Overflowing
+                values will be clipped to the permissible range
+                internally.
+             */
+            virtual bool operator()( double x ) = 0;
+
+            /** Request the underlying value for this animation.
+
+                This is necessary for pure To or By animations, as the
+                Activity cannot determine a sensible start value
+                otherwise.
+
+                @attention Note that you are only permitted to query
+                for the underlying value, if the animation has actually
+                been started (via start() call).
+             */
+            virtual double getUnderlyingValue() const = 0;
+        };
+
+        typedef ::std::shared_ptr< NumberAnimation > NumberAnimationSharedPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_NUMBERANIMATION_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/pairanimation.hxx b/slideshow/source/inc/pairanimation.hxx
new file mode 100644
index 000000000..f8609a146
--- /dev/null
+++ b/slideshow/source/inc/pairanimation.hxx
@@ -0,0 +1,72 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_PAIRANIMATION_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_PAIRANIMATION_HXX
+
+#include "animation.hxx"
+#include <basegfx/tuple/b2dtuple.hxx>
+
+
+/* Definition of PairAnimation interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Interface defining a pair of numbers animation.
+
+            This interface is a specialization of the Animation
+            interface, and is used to animate attributes representable
+            by a pair of floating point values (e.g. a position or a
+            size).
+         */
+        class PairAnimation : public Animation
+        {
+        public:
+            typedef ::basegfx::B2DTuple ValueType;
+
+            /** Set the animation to the given value
+
+                @param rValue
+                Current animation value.
+             */
+            virtual bool operator()( const ::basegfx::B2DTuple& rValue ) = 0;
+
+            /** Request the underlying value for this animation.
+
+                This is necessary for pure To or By animations, as the
+                Activity cannot determine a sensible start value
+                otherwise.
+
+                @attention Note that you are only permitted to query
+                for the underlying value, if the animation has actually
+                been started (via start() call).
+             */
+            virtual ::basegfx::B2DTuple getUnderlyingValue() const = 0;
+        };
+
+        typedef ::std::shared_ptr< PairAnimation > PairAnimationSharedPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_PAIRANIMATION_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/pauseeventhandler.hxx b/slideshow/source/inc/pauseeventhandler.hxx
new file mode 100644
index 000000000..6ac8971ae
--- /dev/null
+++ b/slideshow/source/inc/pauseeventhandler.hxx
@@ -0,0 +1,65 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_PAUSEEVENTHANDLER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_PAUSEEVENTHANDLER_HXX
+
+#include <memory>
+
+
+/* Definition of PauseHandler interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+
+        /** Interface for handling pause events.
+
+            Classes implementing this interface can be added to an
+            EventMultiplexer object, and are called from there to
+            handle pause events.
+         */
+        class PauseEventHandler
+        {
+        public:
+            /** Handle the event.
+
+                @param bPauseShow
+                When true, the show is paused. When false, the show is
+                started again
+
+                @return true, if this handler has successfully
+                processed the pause event. When this method returns
+                false, possibly other, less prioritized handlers are
+                called, too.
+             */
+            virtual bool handlePause( bool bPauseShow ) = 0;
+
+        protected:
+            ~PauseEventHandler() {}
+        };
+
+        typedef ::std::shared_ptr< PauseEventHandler > PauseEventHandlerSharedPtr;
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_PAUSEEVENTHANDLER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/rgbcolor.hxx b/slideshow/source/inc/rgbcolor.hxx
new file mode 100644
index 000000000..9e12ec902
--- /dev/null
+++ b/slideshow/source/inc/rgbcolor.hxx
@@ -0,0 +1,96 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_RGBCOLOR_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_RGBCOLOR_HXX
+
+#include <cppcanvas/color.hxx>
+
+
+/* Definition of RGBColor class */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        class HSLColor;
+
+        /** RGB color space class.
+         */
+        class RGBColor
+        {
+        public:
+            RGBColor();
+            explicit RGBColor( ::cppcanvas::IntSRGBA nRGBColor );
+            RGBColor( double nRed, double nGreen, double nBlue );
+            explicit RGBColor( const HSLColor& rColor );
+
+            /** Get the RGB red value.
+             */
+            double getRed() const {  return maRGBTriple.mnRed; }
+
+            /** Get the RGB green value.
+             */
+            double getGreen() const {  return maRGBTriple.mnGreen; }
+
+            /** Get the RGB blue value.
+             */
+            double getBlue() const {  return maRGBTriple.mnBlue; }
+
+            /** Create an integer sRGBA color.
+             */
+            ::cppcanvas::IntSRGBA getIntegerColor() const;
+
+            struct RGBTriple
+            {
+                RGBTriple();
+                RGBTriple( double nRed, double nGreen, double nBlue );
+
+                double mnRed;
+                double mnGreen;
+                double mnBlue;
+            };
+
+        private:
+            // default copy/assignment are okay
+            // RGBColor(const RGBColor&);
+            // RGBColor& operator=( const RGBColor& );
+
+            RGBTriple   maRGBTriple;
+        };
+
+        bool operator==( const RGBColor& rLHS, const RGBColor& rRHS );
+        bool operator!=( const RGBColor& rLHS, const RGBColor& rRHS );
+        RGBColor operator+( const RGBColor& rLHS, const RGBColor& rRHS );
+        RGBColor operator*( const RGBColor& rLHS, const RGBColor& rRHS );
+        RGBColor operator*( double nFactor, const RGBColor& rRHS );
+
+
+        /** RGB color linear interpolator.
+
+            @param t
+            As usual, t must be in the [0,1] range
+        */
+        RGBColor interpolate( const RGBColor& rFrom, const RGBColor& rTo, double t );
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_RGBCOLOR_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/screenupdater.hxx b/slideshow/source/inc/screenupdater.hxx
new file mode 100644
index 000000000..dcf299b18
--- /dev/null
+++ b/slideshow/source/inc/screenupdater.hxx
@@ -0,0 +1,136 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SCREENUPDATER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SCREENUPDATER_HXX
+
+#include "viewupdate.hxx"
+#include "unoviewcontainer.hxx"
+#include <memory>
+
+/* Definition of ScreenUpdater class */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Screen updater
+
+            This class handles and synchronizes screen updates
+            centrally. Therefore, it can hold a number of ViewUpdate
+            objects, which are polled for pending updates on
+            commitUpdates(). Furthermore, external code can request
+            updates via notifyUpdate() calls. If neither such an
+            update was requested, nor any of the registered ViewUpdate
+            objects report any pending update, commitUpdates() does
+            nothing.
+         */
+        class ScreenUpdater
+        {
+        public:
+            explicit ScreenUpdater( UnoViewContainer const& rViewContainer );
+            ~ScreenUpdater();
+            ScreenUpdater(const ScreenUpdater&) = delete;
+            ScreenUpdater& operator=(const ScreenUpdater&) = delete;
+
+            /** Notify screen update
+
+                This method records a screen content update request
+                for all views.
+            */
+            void notifyUpdate();
+
+            /** Notify screen update
+
+                This method records a screen content update request
+                for the given view.
+
+                @param rView
+                The view that needs an update
+
+                @param bViewClobbered
+                When true, notifies update that view content is
+                clobbered by external circumstances (e.g. by another
+                application), and needs update even if the
+                implementation 'thinks' it does not need to render
+                something to screen.
+            */
+            void notifyUpdate( const UnoViewSharedPtr& rView, bool bViewClobbered );
+
+            /** Commits collected update actions
+             */
+            void commitUpdates();
+
+            /** Register ViewUpdate
+
+                @param rViewUpdate
+                Add this ViewUpdate to the list that's asked for
+                pending updates
+             */
+            void addViewUpdate( ViewUpdateSharedPtr const& rViewUpdate );
+
+            /** Unregister ViewUpdate
+
+                @param rViewUpdate
+                Remove this ViewUpdate from the list that's asked for
+                pending updates
+             */
+            void removeViewUpdate( ViewUpdateSharedPtr const& );
+
+            /** A wart.
+
+                Used to fire an immediate screen update. Currently
+                needed for the wait symbol, since switching that on
+                and off does get to commitUpdates()
+             */
+            void requestImmediateUpdate();
+
+            class UpdateLock {
+            public:
+                virtual void Activate() = 0;
+
+            protected:
+                ~UpdateLock() {}
+            };
+
+            /** Call this method to create a lock instead of calling
+                lockUpdates() and unlockUpdates() directly.
+            */
+            ::std::shared_ptr<UpdateLock> createLock();
+
+            /** Lock updates to prevent intermediate repaints.
+            */
+            void lockUpdates();
+
+            /** When called as often as lockUpdates() then commitUpdates()
+                is called.
+            */
+            void unlockUpdates();
+
+        private:
+            struct ImplScreenUpdater;
+            std::unique_ptr<ImplScreenUpdater> mpImpl;
+
+        };
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_SCREENUPDATER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/shape.hxx b/slideshow/source/inc/shape.hxx
new file mode 100644
index 000000000..9b6099462
--- /dev/null
+++ b/slideshow/source/inc/shape.hxx
@@ -0,0 +1,260 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SHAPE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SHAPE_HXX
+
+#include <com/sun/star/uno/Reference.hxx>
+#include <com/sun/star/drawing/XShape.hpp>
+
+#include <basegfx/range/b2drectangle.hxx>
+
+#include "viewlayer.hxx"
+
+#include <memory>
+#include <set>
+
+namespace basegfx {
+    class B2DRange;
+}
+
+namespace slideshow
+{
+    namespace internal
+    {
+        // forward declaration necessary, because methods use ShapeSharedPtr
+        class Shape;
+
+        typedef ::std::shared_ptr< Shape > ShapeSharedPtr;
+
+        /** Represents a slide's shape object.
+
+            This interface represents the view-independent aspects of a
+            slide's shape, providing bound rect, underlying XShape and
+            basic paint methods.
+         */
+        class Shape
+        {
+        public:
+            Shape() = default;
+            virtual ~Shape() {}
+            Shape(const Shape&) = delete;
+            Shape& operator=(const Shape&) = delete;
+
+            /** Get the associated XShape of this shape.
+
+                @return the associated XShape. If this method returns
+                an empty reference, this object might be one of the
+                special-purpose shapes of a slide, which have no
+                direct corresponding XShape (the background comes to
+                mind here).
+             */
+            virtual css::uno::Reference< css::drawing::XShape > getXShape() const = 0;
+
+
+            // View layer methods
+
+
+            /** Add a new view layer.
+
+                This method adds a new view layer, this shape shall
+                show itself on.
+
+                @param rNewLayer
+                New layer to show on
+
+                @param bRedrawLayer
+                Redraw shape on given layer
+             */
+            virtual void addViewLayer( const ViewLayerSharedPtr&    rNewLayer,
+                                       bool                         bRedrawLayer ) = 0;
+
+            /** Withdraw the shape from a view layer
+
+                This method removes the shape from the given view
+                layer.
+
+                @return true, if the shape was successfully removed
+             */
+            virtual bool removeViewLayer( const ViewLayerSharedPtr& rNewLayer ) = 0;
+
+            /** Withdraw all view layers at once
+
+                This method will be faster than repeated
+                removeViewLayer() calls.
+             */
+            virtual void clearAllViewLayers() = 0;
+
+            // render methods
+
+
+            /** Update the shape
+
+                This method updates the Shape on all registered view
+                layers, but only if shape content has actually
+                changed.
+
+                @return whether the update finished successfully.
+            */
+            virtual bool update() const = 0;
+
+            /** Render the shape.
+
+                This method renders the shape on all registered view
+                layers, regardless of whether shape content has
+                changed or not.
+
+                @return whether the rendering finished successfully.
+            */
+            virtual bool render() const = 0;
+
+            /** Query whether shape content changed
+
+                This method returns true, if shape content changed
+                since the last rendering (i.e. the shape needs an
+                update to reflect that changed content on the views).
+             */
+            virtual bool isContentChanged() const = 0;
+
+
+            // Shape attributes
+
+
+            /** Get the current shape position and size.
+
+                This method yields the currently effective shape
+                bounds (which might change over time, for animated
+                shapes). Please note that possibly shape rotations
+                from its original document state must not be taken
+                into account here: if you need the screen bounding
+                box, use getUpdateArea() instead. Note further that
+                shape rotations, which are already contained in the
+                shape as displayed in the original document
+                <em>are</em> included herein (we currently take the
+                shape as-is from the document, assuming a rotation
+                angle of 0).
+             */
+            virtual ::basegfx::B2DRectangle getBounds() const = 0;
+
+            /** Get the DOM position and size of the shape.
+
+                This method yields the underlying DOM shape bounds,
+                i.e. the original shape bounds from the document
+                model. This value is <em>always</em> unaffected by any
+                animation activity. Note that shape rotations, which
+                are already contained in the shape as displayed in the
+                original document are already included herein (we
+                currently take the shape as-is from the document,
+                assuming a rotation angle of 0).
+             */
+            virtual ::basegfx::B2DRectangle getDomBounds() const = 0;
+
+            /** Get the current shape update area.
+
+                This method yields the currently effective update area
+                for the shape, i.e. the area that needs to be updated,
+                should the shape be painted. Normally, this will be
+                the (possibly rotated and sheared) area returned by
+                getBounds().
+             */
+            virtual ::basegfx::B2DRectangle getUpdateArea() const = 0;
+
+            /** Query whether the shape is visible at all.
+
+                @return true, if this shape is visible, false
+                otherwise.
+             */
+            virtual bool isVisible() const = 0;
+
+            /** Get the shape priority.
+
+                The shape priority defines the relative order of the
+                shapes on the slide.
+
+                @return the priority. Will be in the [0,+infty) range.
+             */
+            virtual double getPriority() const = 0;
+
+            /** Query whether the Shape is currently detached from the
+                background.
+
+                This method checks whether the Shape is currently
+                detached from the slide background, i.e. whether shape
+                updates affect the underlying slide background or
+                not. A shape that returns true here must not alter
+                slide content in any way when called render() or
+                update() (this is normally achieved by making this
+                shape a sprite).
+             */
+            virtual bool isBackgroundDetached() const = 0;
+
+            // Misc
+
+
+            /** Functor struct, for shape ordering
+
+                This defines a strict weak ordering of shapes, primary
+                sort key is the shape priority, and secondary sort key
+                the object ptr value. Most typical use is for
+                associative containers holding shapes (and which also
+                have to maintain something like a paint order).
+             */
+            struct lessThanShape
+            {
+                // make functor adaptable (to boost::bind)
+                typedef bool result_type;
+
+                // since the ZOrder property on the XShape has somewhat
+                // peculiar attributes (it's basically the index of the shapes
+                // in the drawing layer's SdrObjList - which means, it starts
+                // from 0 for children of group objects), we cannot use it to determine
+                // drawing order. Thus, we rely on importer-provided order values here,
+                // which is basically a running counter during shape import (i.e. denotes
+                // the order of shape import). This is the correct order, at least for the
+                // current drawing core.
+
+                // If, someday, the above proposition is no longer true, one directly use
+                // the shape's ZOrder property
+
+                static bool compare(const Shape* pLHS, const Shape* pRHS)
+                {
+                    const double nPrioL( pLHS->getPriority() );
+                    const double nPrioR( pRHS->getPriority() );
+
+                    // if prios are equal, tie-break on ptr value
+                    return nPrioL == nPrioR ? pLHS < pRHS : nPrioL < nPrioR;
+                }
+
+                bool operator()(const ShapeSharedPtr& rLHS, const ShapeSharedPtr& rRHS) const
+                {
+                    return compare(rLHS.get(),rRHS.get());
+                }
+
+            };
+        };
+
+        /** A set which contains all shapes in an ordered fashion.
+         */
+        typedef ::std::set< ShapeSharedPtr, Shape::lessThanShape >  ShapeSet;
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_SHAPE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/shapeattributelayer.hxx b/slideshow/source/inc/shapeattributelayer.hxx
new file mode 100644
index 000000000..0614ff285
--- /dev/null
+++ b/slideshow/source/inc/shapeattributelayer.hxx
@@ -0,0 +1,546 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SHAPEATTRIBUTELAYER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SHAPEATTRIBUTELAYER_HXX
+
+#include <com/sun/star/drawing/FillStyle.hpp>
+#include <com/sun/star/drawing/LineStyle.hpp>
+#include <com/sun/star/awt/FontSlant.hpp>
+
+#include <basegfx/vector/b2dsize.hxx>
+#include <basegfx/point/b2dpoint.hxx>
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+
+#include "rgbcolor.hxx"
+
+#include <memory>
+
+
+namespace slideshow
+{
+    namespace internal
+    {
+
+        /** This interface represents a stateful object.
+
+            The state ID returned by the getStateId() method
+            abstractly encodes the object's state. When this ID
+            changes, clients can assume that the object's state has
+            changed.
+         */
+        class State final
+        {
+        public:
+
+            /// Abstract, numerically encoded state ID
+            typedef ::std::size_t StateId;
+        };
+
+        class ShapeAttributeLayer;
+
+        typedef ::std::shared_ptr< ShapeAttributeLayer > ShapeAttributeLayerSharedPtr;
+
+        /** Encapsulates all modifiable attributes of a shape.
+
+            This class holds all modifiable attributes of a shape, and
+            at the same time provides means to layer attributes on top
+            of each other...
+
+            And yes, there's a reason why we even pass bools and ints
+            by const reference. Namely, that makes the set* methods
+            differ only in the value type, which greatly reduces
+            template variability (e.g. in AnimationFactory).
+         */
+        class ShapeAttributeLayer
+        {
+        public:
+            /** Create a ShapeAttributeLayer instance, with all
+                attributes set to default.
+
+                Furthermore, this constructor gets a pointer to a
+                child layer, which is used as the fallback (or the
+                base value) for all attributes
+
+                @param rChildLayer
+                Layer below this one
+
+                @attention
+                This method is only supposed to be called from Shape objects
+             */
+            explicit ShapeAttributeLayer( const ShapeAttributeLayerSharedPtr& rChildLayer );
+
+            // Children management methods
+
+
+            /** Revoke the given layer.
+
+                This method revokes the given layer from this object
+                or one of the children. That is, if this object does
+                have children, and the given layer is no direct child,
+                it is recursively passed to the children for removal.
+
+                @return true, if removal was successful.
+
+                @attention
+                This method is only supposed to be called from Shape objects
+             */
+            bool revokeChildLayer( const ShapeAttributeLayerSharedPtr& rChildLayer );
+
+            /** Query the child layer of this object.
+
+                @attention
+                This method is only supposed to be called from Shape objects
+             */
+            const ShapeAttributeLayerSharedPtr& getChildLayer() const;
+
+            /** Set the additive mode for possible child attributes
+
+                This method sets the additive mode for child
+                attributes. That is the way underlying attribute
+                layers are combined with this one (i.e. to overrule
+                lower layers, or how to combine the values). The
+                default is
+                css::animations::AnimationAdditiveMode::BASE,
+                which means, take the value of the underlying layers,
+                or from the model shape itself.
+
+                @param nMode
+                Must be one of
+                css::animations::AnimationAdditiveMode.
+             */
+            void setAdditiveMode( sal_Int16 nMode );
+
+            // Attribute methods
+
+
+            /** Query whether the width attribute is valid.
+             */
+            bool isWidthValid() const;
+            /** Query the current width of the shape
+             */
+            double getWidth() const;
+            /** Set the new width of the shape
+
+                @param rNewWidth
+                A negative width mirrors the shape.
+             */
+            void setWidth( const double& rNewWidth );
+
+            /** Query whether the height attribute is valid.
+             */
+            bool isHeightValid() const;
+            /** Query the current height of the shape
+             */
+            double getHeight() const;
+            /** Set the new height of the shape
+
+                @param rNewHeight
+                A negative height mirrors the shape.
+             */
+            void setHeight( const double& rNewHeight );
+
+            /** Set the new size of the shape
+
+                @param rNewSize
+                A negative size mirrors the shape.
+             */
+            void setSize( const ::basegfx::B2DSize& rNewSize );
+
+            /** Query whether the x position attribute is valid
+             */
+            bool isPosXValid() const;
+            /** Query the current x position of the shape.
+
+                The current x position of the shape is always relative
+                to the <em>center</em> of the shape (in contrast to
+                the Shape::getBounds() and Shape::getUpdateArea()
+                methods).
+             */
+            double getPosX() const;
+            /** Set the new x position of the shape
+
+                The current x position of the shape is always relative
+                to the <em>center</em> of the shape (in contrast to
+                the Shape::getBounds() and Shape::getUpdateArea()
+                methods).
+             */
+            void setPosX( const double& rNewX );
+
+            /** Query whether the y position attribute is valid
+             */
+            bool isPosYValid() const;
+            /** Query the current y position of the shape
+
+                The current y position of the shape is always relative
+                to the <em>center</em> of the shape (in contrast to
+                the Shape::getBounds() and Shape::getUpdateArea()
+                methods).
+             */
+            double getPosY() const;
+            /** Set the new y position of the shape
+
+                The current y position of the shape is always relative
+                to the <em>center</em> of the shape (in contrast to
+                the Shape::getBounds() and Shape::getUpdateArea()
+                methods).
+             */
+            void setPosY( const double& rNewY );
+
+            /** Set the new position of the shape
+
+                The current position of the shape is always relative
+                to the <em>center</em> of the shape (in contrast to
+                the Shape::getBounds() and Shape::getUpdateArea()
+                methods).
+             */
+            void setPosition( const ::basegfx::B2DPoint& rNewPos );
+
+            /** Query whether the rotation angle attribute is valid
+             */
+            bool isRotationAngleValid() const;
+            /** Query the current rotation angle of the shape
+
+                @return the rotation angle in degrees.
+             */
+            double getRotationAngle() const;
+            /** Set the new rotation angle of the shape
+
+                @param rNewAngle
+                New rotation angle in degrees.
+             */
+            void setRotationAngle( const double& rNewAngle );
+
+            /** Query whether the shear x angle attribute is valid
+             */
+            bool isShearXAngleValid() const;
+            /** Query the current shear angle at the x axis of the shape
+
+                @return the shear angle in degrees.
+             */
+            double getShearXAngle() const;
+            /** Set the new shear angle at the x axis of the shape
+
+                @param rNewAngle
+                New shear angle in radians.
+             */
+            void setShearXAngle( const double& rNewAngle );
+
+            /** Query whether the shear y angle attribute is valid
+             */
+            bool isShearYAngleValid() const;
+            /** Query the current shear angle at the y axis of the shape
+
+                @return the shear angle in degrees.
+             */
+            double getShearYAngle() const;
+            /** Set the new shear angle at the y axis of the shape
+
+                @param rNewAngle
+                New shear angle in radians.
+             */
+            void setShearYAngle( const double& rNewAngle );
+
+            /** Query whether the alpha attribute is valid
+             */
+            bool isAlphaValid() const;
+            /** Query the current alpha value of the shape
+             */
+            double getAlpha() const;
+            /** Set the new alpha value of the shape
+
+                @param rNewValue
+                New alpha value, must be in the [0,1] range
+             */
+            void setAlpha( const double& rNewValue );
+
+            /** Query whether the clip attribute is valid
+             */
+            bool isClipValid() const;
+            /** Query the current clip polygon of the shape
+             */
+            ::basegfx::B2DPolyPolygon getClip() const;
+            /** Set the new clip polygon of the shape
+
+                @param rNewClip
+                New clip polygon, is interpreted in shape view coordinates, but
+                relative to the shape (i.e. the origin of the shape coincides
+                with the origin of the clip polygon).
+             */
+            void setClip( const ::basegfx::B2DPolyPolygon& rNewClip );
+
+            /** Query whether the dim color attribute is valid
+
+                The dim color globally 'dims' the shape towards that
+                color
+             */
+            bool isDimColorValid() const;
+            /** Get the dim color for the whole shape.
+             */
+            RGBColor getDimColor() const;
+            /** Set the dim color globally for the whole shape.
+             */
+            void setDimColor( const RGBColor& nNewColor );
+
+            /** Query whether the fill color attribute is valid
+             */
+            bool isFillColorValid() const;
+            /** Get the fill color for the whole shape.
+
+                If there's no unique fill color, the color from the
+                first filled polygon is returned.
+             */
+            RGBColor getFillColor() const;
+            /** Set the fill color globally for the whole shape.
+             */
+            void setFillColor( const RGBColor& nNewColor );
+
+            /** Query whether the line color attribute is valid
+             */
+            bool isLineColorValid() const;
+            /** Get the line color for the whole shape.
+
+                If there's no unique line color, the color from the
+                first line is returned.
+             */
+            RGBColor  getLineColor() const;
+            /** Set the line color globally for the whole shape.
+             */
+            void setLineColor( const RGBColor& nNewColor );
+
+            /** Query whether the fill mode attribute is valid
+             */
+            bool isFillStyleValid() const;
+            /** Get the current fill mode for polygon fillings.
+
+                @returns the current style
+             */
+            sal_Int16 getFillStyle() const;
+            /** Changes polygon fillings.
+             */
+            void setFillStyle( const sal_Int16& rStyle );
+
+            /** Query whether the line mode attribute is valid
+             */
+            bool isLineStyleValid() const;
+            /** Get the current line mode for line drawing.
+
+                @returns the current line style
+             */
+            sal_Int16 getLineStyle() const;
+            /** Set line style for the whole shape
+             */
+            void setLineStyle( const sal_Int16& rStyle );
+
+            /** Query whether the visibility state attribute is valid
+             */
+            bool isVisibilityValid() const;
+            /** Get the current shape visibility.
+
+                @returns true for visible, false for invisible.
+             */
+            bool getVisibility() const;
+            /** Set the shape visibility
+             */
+            void setVisibility( const bool& bVisible );
+
+            /** Query whether the char color attribute is valid
+             */
+            bool isCharColorValid() const;
+            /** Get the text color for the whole shape.
+
+                If there's no unique text color, the color from the
+                first text drawn is returned.
+             */
+            RGBColor getCharColor() const;
+            /** Set the text color globally for the whole shape.
+             */
+            void setCharColor( const RGBColor& nNewColor );
+
+            /** Query whether the char weight attribute is valid
+             */
+            bool isCharWeightValid() const;
+            /** Get the current char weight value for the whole shape.
+
+                @returns the value for the char weight. The value must
+                be out of the css::awt::FontWeight
+                constant group.
+             */
+            double getCharWeight() const;
+            /** Set the char weight globally for the whole shape.
+
+                The value must be out of the
+                css::awt::FontWeight constant group.
+             */
+            void setCharWeight( const double& rStyle );
+
+            /** Query whether the underline mode attribute is valid
+             */
+            bool isUnderlineModeValid() const;
+            /** Get the current text underline status for the whole shape.
+
+                If there is no unique underline status, false is returned.
+
+                @returns true for underlined text, false for normal.
+             */
+            sal_Int16 getUnderlineMode() const;
+            /** Set the underline status globally for the whole shape
+             */
+            void setUnderlineMode( const sal_Int16& bUnderline );
+
+            /** Query whether the font family attribute is valid
+             */
+            bool isFontFamilyValid() const;
+            /** Get the current text font family for the whole shape.
+
+                If there is no unique font family, the font family of
+                the first text of the shape is returned.
+             */
+            OUString getFontFamily() const;
+            /** Set the text font family name globally for the whole shape
+             */
+            void setFontFamily( const OUString& rName );
+
+            /** Query whether the italic mode attribute is valid
+             */
+            bool isCharPostureValid() const;
+            /** Get the current text italic style for the whole shape.
+
+                @returns the italic style. The value returned is one
+                of the css::awt::FontSlant enums
+             */
+            sal_Int16 getCharPosture() const;
+            /** Set the italic style globally for the whole shape.
+
+                The value must be one of the
+                css::awt::FontSlant enums.
+            */
+            void setCharPosture( const sal_Int16& rStyle );
+
+            /** Query whether the char scaling attribute is valid
+             */
+            bool isCharScaleValid() const;
+            /** Query the current char scaling attribute globally for
+                the shape.
+
+                The char scaling changes the scale of the whole shape
+                text (uniformly, i.e. both in x and in y direction).
+             */
+            double getCharScale() const;
+            /** Set the new char scale globally for the shape
+
+                @param rNewScale
+                New char scale
+             */
+            void setCharScale( const double& rNewScale );
+
+            // State change query methods
+
+
+            State::StateId getTransformationState() const;
+            State::StateId getClipState() const;
+            State::StateId getAlphaState() const;
+            State::StateId getPositionState() const;
+            State::StateId getContentState() const;
+            State::StateId getVisibilityState() const;
+
+        private:
+            // default copy/assignment operator is okay
+            // ShapeAttributeLayer(const ShapeAttributeLayer&);
+            // ShapeAttributeLayer& operator=( const ShapeAttributeLayer& );
+
+            bool haveChild() const { return static_cast< bool >(mpChild); }
+            void updateStateIds();
+
+            template< typename T > T calcValue( const T&                   rCurrValue,
+                                                bool                           bThisInstanceValid,
+                                                bool (ShapeAttributeLayer::*pIsValid)() const,
+                                                T   (ShapeAttributeLayer::*pGetValue)() const ) const;
+
+            ShapeAttributeLayerSharedPtr                mpChild; // may be NULL
+
+            ::basegfx::B2DSize                          maSize;
+            ::basegfx::B2DPoint                         maPosition;
+            ::basegfx::B2DPolyPolygon                   maClip;
+
+            OUString                             maFontFamily;
+
+            double                                      mnRotationAngle;
+            double                                      mnShearXAngle;
+            double                                      mnShearYAngle;
+            double                                      mnAlpha;
+            double                                      mnCharScale;
+            double                                      mnCharWeight;
+
+            css::drawing::FillStyle        meFillStyle;
+            css::drawing::LineStyle        meLineStyle;
+            css::awt::FontSlant            meCharPosture;
+            sal_Int16                                   mnUnderlineMode;
+
+            RGBColor                                    maDimColor;
+            RGBColor                                    maFillColor;
+            RGBColor                                    maLineColor;
+            RGBColor                                    maCharColor;
+
+            State::StateId                              mnTransformationState;
+            State::StateId                              mnClipState;
+            State::StateId                              mnAlphaState;
+            State::StateId                              mnPositionState;
+            State::StateId                              mnContentState;
+            State::StateId                              mnVisibilityState;
+
+            sal_Int16                                   mnAdditiveMode;
+
+            bool                                        mbVisibility            : 1;
+
+            bool                                        mbWidthValid            : 1;
+            bool                                        mbHeightValid           : 1;
+            bool                                        mbPosXValid             : 1;
+            bool                                        mbPosYValid             : 1;
+            bool                                        mbClipValid             : 1;
+
+            bool                                        mbFontFamilyValid       : 1;
+
+            bool                                        mbRotationAngleValid    : 1;
+            bool                                        mbShearXAngleValid      : 1;
+            bool                                        mbShearYAngleValid      : 1;
+
+            bool                                        mbAlphaValid            : 1;
+
+            bool                                        mbCharScaleValid        : 1;
+
+            bool                                        mbDimColorValid         : 1;
+            bool                                        mbFillColorValid        : 1;
+            bool                                        mbLineColorValid        : 1;
+            bool                                        mbCharColorValid        : 1;
+
+            bool                                        mbFillStyleValid        : 1;
+            bool                                        mbLineStyleValid        : 1;
+            bool                                        mbCharWeightValid       : 1;
+            bool                                        mbUnderlineModeValid    : 1;
+            bool                                        mbCharPostureValid      : 1;
+            bool                                        mbVisibilityValid       : 1;
+        };
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_SHAPEATTRIBUTELAYER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/shapeattributelayerholder.hxx b/slideshow/source/inc/shapeattributelayerholder.hxx
new file mode 100644
index 000000000..ba596adcd
--- /dev/null
+++ b/slideshow/source/inc/shapeattributelayerholder.hxx
@@ -0,0 +1,105 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SHAPEATTRIBUTELAYERHOLDER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SHAPEATTRIBUTELAYERHOLDER_HXX
+
+#include "attributableshape.hxx"
+#include "shapeattributelayer.hxx"
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Holds a ShapeAttributeLayer, together with the associated
+            Shape
+
+            Use this class to hold ShapeAttributeLayer objects the
+            RAII way. When this object gets deleted, it will
+            automatically revoke the attribute layer for the given
+            shape (this encapsulates the somewhat clumsy notification
+            process that is required for shape and attribute layer
+            interaction).
+         */
+        class ShapeAttributeLayerHolder
+        {
+        public:
+            /** Create a ShapeAttributeLayerHolder instance.
+
+                This constructor creates an empty attribute holder, to
+                generate an attribute layer, you have to manually call
+                createAttributeLayer().
+             */
+            ShapeAttributeLayerHolder() :
+                mpShape(),
+                mpAttributeLayer()
+            {
+            }
+
+            ~ShapeAttributeLayerHolder()
+            {
+                reset(); // ensures that the last attribute layer is
+                         // correctly deregistered from the shape.
+            }
+
+            ShapeAttributeLayerHolder(const ShapeAttributeLayerHolder&) = delete;
+            ShapeAttributeLayerHolder& operator=(const ShapeAttributeLayerHolder&) = delete;
+
+            void reset()
+            {
+                if( mpShape && mpAttributeLayer )
+                    mpShape->revokeAttributeLayer( mpAttributeLayer );
+            }
+
+            /** This constructor receives a pointer to the Shape, from
+                which attribute layers should be generated. Initially,
+                this object does not create an attribute layer, you
+                have to manually call createAttributeLayer().
+
+                @param rShape
+                Shape for which attribute layers should be generated.
+            */
+            bool createAttributeLayer( const AttributableShapeSharedPtr& rShape )
+            {
+                reset();
+
+                mpShape = rShape;
+
+                if( mpShape )
+                    mpAttributeLayer = mpShape->createAttributeLayer();
+
+                return static_cast< bool >(mpAttributeLayer);
+            }
+
+            const ShapeAttributeLayerSharedPtr& get() const
+            {
+                return mpAttributeLayer;
+            }
+
+        private:
+            AttributableShapeSharedPtr      mpShape;
+            ShapeAttributeLayerSharedPtr    mpAttributeLayer;
+        };
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_SHAPEATTRIBUTELAYERHOLDER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/shapeimporter.hxx b/slideshow/source/inc/shapeimporter.hxx
new file mode 100644
index 000000000..a12fa9618
--- /dev/null
+++ b/slideshow/source/inc/shapeimporter.hxx
@@ -0,0 +1,143 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SHAPEIMPORTER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SHAPEIMPORTER_HXX
+
+#include <com/sun/star/drawing/XDrawPage.hpp>
+#include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
+#include <com/sun/star/drawing/XShapes.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/drawing/XLayer.hpp>
+
+#include <cppcanvas/canvasgraphic.hxx>
+
+#include "unoview.hxx"
+
+#include "shape.hxx"
+
+#include <stack>
+
+namespace slideshow {
+namespace internal {
+
+struct SlideShowContext;
+
+typedef std::vector< ::cppcanvas::PolyPolygonSharedPtr> PolyPolygonVector;
+typedef std::shared_ptr< UnoView >      UnoViewSharedPtr;
+typedef std::vector< UnoViewSharedPtr >   UnoViewVector;
+
+/** This class imports all shapes from a given XShapes object
+ */
+class ShapeImporter
+{
+public:
+    /** Create shape importer.
+
+        @param xPage
+        Page containing the shapes
+
+        @param xActualPage
+        Actual page that's imported - if xPage is a master
+        page, this argument must refer to the using, i.e the
+        page that embeds this specific masterpage. Otherwise,
+        this argument is probably equal to xPage.
+
+        @param nOrdNumStart
+        Each shape receives a z order number, in order of
+        import (which relies on the fact that the API returns
+        the shapes in draw order - which it does,
+        currently). Since we might mix several pages on screen
+        (e.g. master page and foreground page), this value can
+        be used as an offset to distinguish those pages.
+
+        @param bConvertingMasterPage
+        When true, then the master page is imported. Otherwise, this
+        object imports the draw page.
+    */
+    ShapeImporter( const css::uno::Reference< css::drawing::XDrawPage >& xPage,
+                   const css::uno::Reference< css::drawing::XDrawPage >& xActualPage,
+                   const css::uno::Reference< css::drawing::XDrawPagesSupplier>& xPagesSupplier,
+                   const SlideShowContext&                       rContext,
+                   sal_Int32                                     nOrdNumStart,
+                   bool                                          bConvertingMasterPage );
+
+    /** This method imports the presentation background shape
+     */
+    ShapeSharedPtr importBackgroundShape(); // throw (ShapeLoadFailedException)
+
+    /** This method imports presentation-visible shapes (and skips all others).
+
+        @return the generated Shape, or NULL for no more shapes.
+    */
+    ShapeSharedPtr importShape(); // throw (ConversionFailedException)
+
+    /** Test whether import is done.
+
+        @return true, if all shapes are imported via the
+        importShape() call.
+    */
+    bool isImportDone() const;
+    const PolyPolygonVector& getPolygons() const;
+
+    double getImportedShapesCount() const{ return mnAscendingPrio; }
+private:
+    bool isSkip( css::uno::Reference<css::beans::XPropertySet> const& xPropSet,
+                 OUString const& shapeType,
+                 css::uno::Reference<css::drawing::XLayer> const& xLayer);
+
+    ShapeSharedPtr createShape(
+        css::uno::Reference<css::drawing::XShape> const& xCurrShape,
+        css::uno::Reference<css::beans::XPropertySet> const& xPropSet,
+        OUString const& shapeType ) const;
+
+    void importPolygons(css::uno::Reference< css::beans::XPropertySet > const& xPropSet) ;
+
+    struct XShapesEntry
+    {
+        ShapeSharedPtr const mpGroupShape;
+        css::uno::Reference<css::drawing::XShapes> const mxShapes;
+        sal_Int32 const mnCount;
+        sal_Int32 mnPos;
+
+        explicit XShapesEntry( ShapeSharedPtr const& pGroupShape )
+            : mpGroupShape(pGroupShape),
+              mxShapes( pGroupShape->getXShape(),
+                        css::uno::UNO_QUERY_THROW ),
+              mnCount(mxShapes->getCount()), mnPos(0) {}
+        explicit XShapesEntry( css::uno::Reference<
+                      css::drawing::XShapes> const& xShapes )
+            : mpGroupShape(), mxShapes(xShapes),
+              mnCount(xShapes->getCount()), mnPos(0) {}
+    };
+
+    css::uno::Reference<css::drawing::XDrawPage> mxPage;
+    css::uno::Reference<css::drawing::XDrawPagesSupplier> mxPagesSupplier;
+    const SlideShowContext&                   mrContext;
+    PolyPolygonVector                         maPolygons;
+    ::std::stack<XShapesEntry>                maShapesStack;
+    double                                    mnAscendingPrio;
+    bool                                      mbConvertingMasterPage;
+};
+
+} // namespace internal
+} // namespace presentation
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/shapelistenereventhandler.hxx b/slideshow/source/inc/shapelistenereventhandler.hxx
new file mode 100644
index 000000000..386671132
--- /dev/null
+++ b/slideshow/source/inc/shapelistenereventhandler.hxx
@@ -0,0 +1,65 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SHAPELISTENEREVENTHANDLER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SHAPELISTENEREVENTHANDLER_HXX
+
+#include <com/sun/star/uno/Reference.hxx>
+#include <memory>
+
+namespace com::sun::star {
+    namespace drawing {
+        class XShape;
+    }
+    namespace presentation {
+        class XShapeEventListener;
+    }
+}
+
+/* Definition of ShapeListenerEventHandler interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+
+        /** Interface for handling view events.
+
+            Classes implementing this interface can be added to an
+            EventMultiplexer object, and are called from there to
+            handle view events.
+         */
+        class ShapeListenerEventHandler
+        {
+        public:
+            virtual ~ShapeListenerEventHandler() {}
+
+            virtual bool listenerAdded( const css::uno::Reference<css::drawing::XShape>& xShape ) = 0;
+
+            virtual bool listenerRemoved( const css::uno::Reference<css::drawing::XShape>& xShape ) = 0;
+        };
+
+        typedef ::std::shared_ptr< ShapeListenerEventHandler > ShapeListenerEventHandlerSharedPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_SHAPELISTENEREVENTHANDLER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/shapemanager.hxx b/slideshow/source/inc/shapemanager.hxx
new file mode 100644
index 000000000..ef2e40de6
--- /dev/null
+++ b/slideshow/source/inc/shapemanager.hxx
@@ -0,0 +1,111 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SHAPEMANAGER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SHAPEMANAGER_HXX
+
+#include "disposable.hxx"
+#include <com/sun/star/uno/Reference.hxx>
+#include <memory>
+
+namespace com::sun::star::drawing { class XShape; }
+
+/* Definition of ShapeManager interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        class HyperlinkArea;
+        class AnimatableShape;
+        class Shape;
+        typedef ::std::shared_ptr< AnimatableShape > AnimatableShapeSharedPtr;
+        typedef ::std::shared_ptr< Shape > ShapeSharedPtr;
+        typedef std::shared_ptr< HyperlinkArea > HyperlinkAreaSharedPtr;
+
+        /** ShapeManager interface
+
+            Implementers of this interface manage appearance and
+            animation of slideshow shapes.
+         */
+        class ShapeManager : public Disposable
+        {
+        public:
+            /** Notify the ShapeManager that the given Shape starts an
+                animation now.
+
+                This method enters animation mode for the Shape. If
+                the shape is already in animation mode, the call is
+                counted, and the shape only leaves animation mode
+                after a corresponding number of leaveAnimationMode()
+                calls.
+             */
+            virtual void enterAnimationMode( const AnimatableShapeSharedPtr& rShape ) = 0;
+
+            /** Notify the ShapeManager that the given Shape is no
+                longer animated.
+
+                When called a corresponding number of times as
+                enterAnimationMode() for a given shape, this methods
+                ends animation mode for the given Shape. It is illegal
+                to call this method more often than
+                enterAnimationMode().
+             */
+            virtual void leaveAnimationMode( const AnimatableShapeSharedPtr& rShape ) = 0;
+
+            /** Notify that a shape needs an update
+
+                This method notifies the ShapeManager that a shape
+                update is necessary. Use this if e.g. a running
+                animation changed the shape appearance.
+
+                @param rShape
+                Shape which needs an update
+             */
+            virtual void notifyShapeUpdate( const ShapeSharedPtr& rShape ) = 0;
+
+            /** Lookup a Shape from an XShape model object
+
+                This method looks up the internal shape map for one
+                representing the given XShape.
+
+                @param xShape
+                The XShape object, for which the representing Shape
+                should be looked up.
+             */
+            virtual ShapeSharedPtr lookupShape(
+                css::uno::Reference< css::drawing::XShape > const & xShape ) const = 0;
+
+            /** Register given shape as a hyperlink target
+
+                @param rArea
+                Hyperlink sensitive area. Will participate in
+                hyperlink region lookup. Must be in absolute user
+                space coordinates.
+             */
+            virtual void addHyperlinkArea( const HyperlinkAreaSharedPtr& rArea ) = 0;
+        };
+
+        typedef ::std::shared_ptr< ShapeManager > ShapeManagerSharedPtr;
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_SHAPEMANAGER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/shapemaps.hxx b/slideshow/source/inc/shapemaps.hxx
new file mode 100644
index 000000000..43476e05b
--- /dev/null
+++ b/slideshow/source/inc/shapemaps.hxx
@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SHAPEMAPS_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SHAPEMAPS_HXX
+
+#include <comphelper/interfacecontainer2.hxx>
+#include <com/sun/star/uno/Reference.hxx>
+
+#include <memory>
+#include <map>
+
+namespace com::sun::star::drawing { class XShape; }
+
+/* Definition of two shape maps */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /// Maps XShape to shape listener
+        typedef ::std::map< css::uno::Reference< css::drawing::XShape>,
+                            std::shared_ptr< ::comphelper::OInterfaceContainerHelper2 >
+                            >                  ShapeEventListenerMap;
+
+        /// Maps XShape to mouse cursor
+        typedef ::std::map< css::uno::Reference< css::drawing::XShape>,
+                            sal_Int16>         ShapeCursorMap;
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_SHAPEMAPS_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/shapesubset.hxx b/slideshow/source/inc/shapesubset.hxx
new file mode 100644
index 000000000..750fc0f35
--- /dev/null
+++ b/slideshow/source/inc/shapesubset.hxx
@@ -0,0 +1,147 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SHAPESUBSET_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SHAPESUBSET_HXX
+
+#include "subsettableshapemanager.hxx"
+#include "doctreenode.hxx"
+
+#include <memory>
+
+namespace slideshow
+{
+    namespace internal
+    {
+        class ShapeSubset;
+        typedef ::std::shared_ptr< ShapeSubset > ShapeSubsetSharedPtr;
+
+        /* Definition of ShapeSubset class */
+
+        /** Subset RAII wrapper for shapes.
+
+            This class wraps the plain Shape with a wrapper for subset
+            functionality. Subsetting can be turned on and off. Note
+            that the reason to have shape subsetting RAII implemented
+            separately (i.e. not within the DrawShape) was that
+            subsetting (and de-subsetting) needs the
+            SubsettableShapeManager. And holding that at the DrawShape
+            creates one heck of a circular reference.
+         */
+        class ShapeSubset
+        {
+        public:
+            /** Create a subset directly from a Shape.
+
+                @param rOriginalShape
+                Original shape to subset
+
+                @param rTreeNode
+                Subset this object should represent
+
+                @param rShapeManager
+                Manager object, where subsets are
+                registered/unregistered
+             */
+            ShapeSubset( const AttributableShapeSharedPtr&       rOriginalShape,
+                         const DocTreeNode&                      rTreeNode,
+                         const SubsettableShapeManagerSharedPtr& rSubsetManager );
+
+            /** Create a subset from another subset.
+
+                Note: if you want this subset to subtract from the
+                passed subset reference (and not from the original,
+                unsubsetted shape), the passed subset must be enabled
+                (enableSubsetShape() must have been called)
+
+                @param rOriginalSubset
+                Original subset, which to subset again.
+
+                @param rTreeNode
+                Subset of the original subset
+             */
+            ShapeSubset( const ShapeSubsetSharedPtr&        rOriginalSubset,
+                         const DocTreeNode&                 rTreeNode );
+
+            /** Create full set for the given shape.
+
+                @param rOriginalShape
+                Original shape, which will be represented as a whole
+                by this object
+             */
+            ShapeSubset( const AttributableShapeSharedPtr&       rOriginalShape,
+                         const SubsettableShapeManagerSharedPtr& rShapeManager );
+
+            ~ShapeSubset();
+
+            // For a rationale for this hacky combination of user-provided dtor, defaulted copy
+            // ctor, and deleted copy assignment op, see the "TODO(Q1)" comment in
+            // CloningNodeCreator (slideshow/source/engine/animationnodes/animationnodefactory.cxx):
+            ShapeSubset(ShapeSubset const &) = default;
+            void operator =(ShapeSubset const &) = delete;
+
+            /** Get the actual subset shape.
+
+                If the subset is currently revoked, this method
+                returns the original shape.
+             */
+            AttributableShapeSharedPtr const &  getSubsetShape() const;
+
+            /** Enable the subset shape.
+
+                This method enables the subset. That means, on
+                successful completion of this method, the original
+                shape will cease to show the subset range, and
+                getSubsetShape() will return a valid shape.
+             */
+            void            enableSubsetShape();
+
+            /** Disable the subset shape.
+
+                This method revokes the subset from the original
+                shape. That means, the original shape will again show
+                the hidden range.
+             */
+            void            disableSubsetShape();
+
+            /** Query whether this subset actually is none, but
+                contains the whole original shape's content
+             */
+            bool isFullSet() const;
+
+            /** Query subset this object represents
+             */
+            const DocTreeNode& getSubset() const;
+
+        private:
+            // default copy/assignment are okay
+            //ShapeSubset(const ShapeSubset&);
+            //ShapeSubset& operator=( const ShapeSubset& );
+
+            AttributableShapeSharedPtr       mpOriginalShape;
+            AttributableShapeSharedPtr       mpSubsetShape;
+            DocTreeNode                      maTreeNode;
+            SubsettableShapeManagerSharedPtr mpShapeManager;
+        };
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_SHAPESUBSET_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/slide.hxx b/slideshow/source/inc/slide.hxx
new file mode 100644
index 000000000..8350751fa
--- /dev/null
+++ b/slideshow/source/inc/slide.hxx
@@ -0,0 +1,213 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SLIDE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SLIDE_HXX
+
+#include "unoviewcontainer.hxx"
+#include "slidebitmap.hxx"
+#include "shapemaps.hxx"
+
+#include <memory>
+
+namespace com::sun::star {
+    namespace drawing {
+        class XDrawPage;
+        class XDrawPagesSupplier;
+    }
+    namespace uno {
+        class XComponentContext;
+    }
+    namespace animations {
+        class XAnimationNode;
+    }
+}
+
+namespace basegfx
+{
+    class B2IVector;
+}
+
+/* Definition of Slide interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        class RGBColor;
+        class ScreenUpdater;
+        typedef ::std::vector< ::cppcanvas::PolyPolygonSharedPtr> PolyPolygonVector;
+        class Slide
+        {
+        public:
+            // Showing
+
+
+            /** Prepares to show slide.
+
+                Call this method to reduce the timeout show(), and
+                getInitialSlideBitmap() need to complete. If
+                prefetch() is not called explicitly, the named
+                methods will call it implicitly.
+             */
+            virtual void prefetch() = 0;
+
+            /** Shows the slide on all registered views
+
+                After this call, the slide will render itself to the
+                views, and start its animations.
+
+                @param bSlideBackgoundPainted
+                When true, the initial slide content on the background
+                layer is already rendered (e.g. from a previous slide
+                transition). When false, Slide renders initial content of
+                slide.
+             */
+            virtual void show( bool bSlideBackgoundPainted ) = 0;
+
+            /** Force-ends the slide
+
+                After this call, the slide has stopped all animations,
+                and ceased rendering/visualization on all views.
+             */
+            virtual void hide() = 0;
+
+
+            // Queries
+
+
+            /** Query the size of this slide in user coordinates
+
+                This value is retrieved from the XDrawPage properties.
+             */
+            virtual basegfx::B2ISize getSlideSize() const = 0;
+
+            /// Gets the underlying API page
+            virtual css::uno::Reference< css::drawing::XDrawPage > getXDrawPage() const = 0;
+
+            /// Gets the animation node.
+            virtual css::uno::Reference< css::animations::XAnimationNode > getXAnimationNode() const = 0;
+
+            ///Gets the slide Polygons
+            virtual PolyPolygonVector getPolygons() = 0;
+
+            ///Draw the slide Polygons
+            virtual void drawPolygons() const = 0;
+
+            ///Check if paint overlay is already active
+            virtual bool isPaintOverlayActive() const = 0;
+
+            virtual void enablePaintOverlay() = 0;
+
+            virtual void update_settings( bool bUserPaintEnabled, RGBColor const& aUserPaintColor, double dUserPaintStrokeWidth ) = 0;
+
+            // Slide bitmaps
+
+
+            /** Request bitmap for current slide appearance.
+
+                The bitmap returned by this method depends on the
+                current state of the slide and the contained
+                animations. A newly generated slide will return the
+                initial slide content here (e.g. with all 'appear'
+                effect shapes invisible), a slide whose effects are
+                currently running will return a bitmap corresponding
+                to the current position on the animation timeline, and
+                a slide whose effects have all been run will generate
+                a bitmap with the final slide appearance (e.g. with
+                all 'hide' effect shapes invisible).
+
+                @param rView
+                View to retrieve bitmap for (note that the bitmap will
+                have device-pixel equivalence to the content that
+                would have been rendered onto the given view). Note
+                that the view must have been added to this slide
+                before via viewAdded().
+             */
+            virtual SlideBitmapSharedPtr
+                getCurrentSlideBitmap( const UnoViewSharedPtr& rView ) const = 0;
+
+        protected:
+            ~Slide() {}
+        };
+
+        typedef ::std::shared_ptr< Slide > SlideSharedPtr;
+
+        class EventQueue;
+        class CursorManager;
+        class MediaFileManager;
+        class EventMultiplexer;
+        class ActivitiesQueue;
+        class UserEventQueue;
+        class RGBColor;
+
+        /** Construct from XDrawPage
+
+            The Slide object generally works in XDrawPage model
+            coordinates, that is, the page will have the width and
+            height as specified in the XDrawPage's property
+            set. The top, left corner of the page will be rendered
+            at (0,0) in the given canvas' view coordinate system.
+
+            Does not render anything initially
+
+            @param xDrawPage
+            Page to display on this slide
+
+            @param xRootNode
+            Root of the SMIL animation tree. Used to animate the slide.
+
+            @param rEventQueue
+            EventQueue. Used to post events.
+
+            @param rActivitiesQueue
+            ActivitiesQueue. Used to run animations.
+
+            @param rEventMultiplexer
+            Event source
+
+            @param rUserEventQueue
+            UserEeventQueue
+        */
+        SlideSharedPtr createSlide( const css::uno::Reference< css::drawing::XDrawPage >&          xDrawPage,
+                                    const css::uno::Reference< css::drawing::XDrawPagesSupplier >& xDrawPages,
+                                    const css::uno::Reference< css::animations::XAnimationNode >&  xRootNode,
+                                    EventQueue&                                         rEventQueue,
+                                    EventMultiplexer&                                   rEventMultiplexer,
+                                    ScreenUpdater&                                      rScreenUpdater,
+                                    ActivitiesQueue&                                    rActivitiesQueue,
+                                    UserEventQueue&                                     rUserEventQueue,
+                                    CursorManager&                                      rCursorManager,
+                                    MediaFileManager&                                      rMediaFileManager,
+                                    const UnoViewContainer&                             rViewContainer,
+                                    const css::uno::Reference< css::uno::XComponentContext >&      xContext,
+                                    const ShapeEventListenerMap&                        rShapeListenerMap,
+                                    const ShapeCursorMap&                               rShapeCursorMap,
+                                    const PolyPolygonVector&                            rPolyPolygonVector,
+                                    RGBColor const&                                     aUserPaintColor,
+                                    double                                              dUserPaintStrokeWidth,
+                                    bool                                                bUserPaintEnabled,
+                                    bool                                                bIntrinsicAnimationsAllowed,
+                                    bool                                                bDisableAnimationZOrder );
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_SLIDE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/slidebitmap.hxx b/slideshow/source/inc/slidebitmap.hxx
new file mode 100644
index 000000000..f5248a806
--- /dev/null
+++ b/slideshow/source/inc/slidebitmap.hxx
@@ -0,0 +1,84 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SLIDEBITMAP_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SLIDEBITMAP_HXX
+
+#include <com/sun/star/uno/Reference.hxx>
+#include <cppcanvas/canvas.hxx>
+#include <cppcanvas/bitmap.hxx>
+
+#include <basegfx/point/b2dpoint.hxx>
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+
+#include <memory>
+
+namespace com::sun::star::rendering { class XBitmap; }
+
+
+/* Definition of SlideBitmap class */
+
+namespace slideshow
+{
+    namespace internal
+    {
+
+        /** Little wrapper encapsulating an XBitmap
+
+            This is to insulate us from changes to the preferred
+            transport format for bitmaps (using a sole XBitmap here is
+            a hack, since it is not guaranteed to work, or to work
+            without data loss, across different canvases). And since
+            we don't want to revert to a VCL Bitmap here, have to wait
+            until basegfx bitmap tooling is ready.
+
+            TODO(F2): Add support for Canvas-independent bitmaps
+            here. Then, Slide::getInitialSlideBitmap and
+            Slide::getFinalSlideBitmap must also be adapted (they no
+            longer need a Canvas ptr, which is actually a hack now).
+         */
+        class SlideBitmap
+        {
+        public:
+            explicit SlideBitmap( const ::cppcanvas::BitmapSharedPtr& rBitmap );
+            SlideBitmap(const SlideBitmap&) = delete;
+            SlideBitmap& operator=(const SlideBitmap&) = delete;
+
+            bool                draw( const ::cppcanvas::CanvasSharedPtr& rCanvas ) const;
+            ::basegfx::B2ISize  getSize() const;
+            void                move( const ::basegfx::B2DPoint& rNewPos );
+            void                clip( const ::basegfx::B2DPolyPolygon& rClipPoly );
+
+            const css::uno::Reference< css::rendering::XBitmap >&  getXBitmap() const;
+
+        private:
+            ::basegfx::B2DPoint                                     maOutputPos;
+            ::basegfx::B2DPolyPolygon                               maClipPoly;
+
+            // TODO(Q2): Remove UNO bitmap as the transport medium
+            css::uno::Reference< css::rendering::XBitmap >          mxBitmap;
+        };
+
+        typedef ::std::shared_ptr< SlideBitmap > SlideBitmapSharedPtr;
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_SLIDEBITMAP_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/slideshowcontext.hxx b/slideshow/source/inc/slideshowcontext.hxx
new file mode 100644
index 000000000..6d14fb34b
--- /dev/null
+++ b/slideshow/source/inc/slideshowcontext.hxx
@@ -0,0 +1,114 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SLIDESHOWCONTEXT_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SLIDESHOWCONTEXT_HXX
+
+#include <com/sun/star/uno/Reference.hxx>
+#include <memory>
+
+namespace com::sun::star::uno { class XComponentContext; }
+
+
+namespace slideshow
+{
+    namespace internal
+    {
+        class ShapeManager;
+        class EventQueue;
+        class ActivitiesQueue;
+        class UserEventQueue;
+        class EventMultiplexer;
+        class ScreenUpdater;
+        class UnoViewContainer;
+        class CursorManager;
+        class MediaFileManager;
+        class SubsettableShapeManager;
+        typedef ::std::shared_ptr< SubsettableShapeManager > SubsettableShapeManagerSharedPtr;
+
+        /** Common arguments for slideshow objects.
+
+            This struct combines a number of object references
+            ubiquitously needed throughout the slideshow.
+         */
+        struct SlideShowContext
+        {
+            /** Common context for node creation
+
+                @param rShapeManager
+                ShapeManager, which handles all shapes
+
+                @param rEventQueue
+                Event queue, where time-based events are to be
+                scheduled. A node must not schedule events there
+                before it's not resolved.
+
+                @param rEventMultiplexer
+                Event multiplexer. Clients can register there for
+                about any event that happens in the slideshow
+
+                @param rScreenUpdater
+                Screen updater. Gets notified of necessary screen
+                updates.
+
+                @param rActivitiesQueue
+                Activities queue, where repeating activities are
+                to be scheduled.
+
+                @param rMediaFileManager
+                To handle media file with package urls.
+
+                @param rUserEventQueue
+                User event queue
+
+                @param rViewContainer
+                Holds all views added to slideshow
+
+                @param rComponentContext
+                To create UNO services from
+            */
+            SlideShowContext( SubsettableShapeManagerSharedPtr&                 rSubsettableShapeManager,
+                              EventQueue&                                       rEventQueue,
+                              EventMultiplexer&                                 rEventMultiplexer,
+                              ScreenUpdater&                                    rScreenUpdater,
+                              ActivitiesQueue&                                  rActivitiesQueue,
+                              UserEventQueue&                                   rUserEventQueue,
+                              CursorManager&                                    rCursorManager,
+                              MediaFileManager&                                 rMediaFileManager,
+                              const UnoViewContainer&                           rViewContainer,
+                              const css::uno::Reference< css::uno::XComponentContext>&    rComponentContext );
+            void dispose();
+
+            std::shared_ptr<SubsettableShapeManager>&     mpSubsettableShapeManager;
+            EventQueue&                                     mrEventQueue;
+            EventMultiplexer&                               mrEventMultiplexer;
+            ScreenUpdater&                                  mrScreenUpdater;
+            ActivitiesQueue&                                mrActivitiesQueue;
+            UserEventQueue&                                 mrUserEventQueue;
+            CursorManager&                                  mrCursorManager;
+            MediaFileManager&                               mrMediaFileManager;
+            const UnoViewContainer&                         mrViewContainer;
+            css::uno::Reference< css::uno::XComponentContext>   mxComponentContext;
+        };
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_SLIDESHOWCONTEXT_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/slideshowexceptions.hxx b/slideshow/source/inc/slideshowexceptions.hxx
new file mode 100644
index 000000000..58ce41bf6
--- /dev/null
+++ b/slideshow/source/inc/slideshowexceptions.hxx
@@ -0,0 +1,47 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SLIDESHOWEXCEPTIONS_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SLIDESHOWEXCEPTIONS_HXX
+
+
+namespace slideshow
+{
+    class SlideShowException {};
+
+    /** This exception is thrown, when the Shape class was not
+        able to convert an API object into our internal
+        representation.
+     */
+    struct ShapeLoadFailedException : public SlideShowException {};
+
+    /** This exception is thrown, when the SMIL arithmetic expression
+        parser failed to parse a string.
+     */
+    struct ParseError : public SlideShowException
+    {
+        ParseError() {}
+        explicit ParseError( const char* ) {}
+    };
+
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_SLIDESHOWEXCEPTIONS_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/slideview.hxx b/slideshow/source/inc/slideview.hxx
new file mode 100644
index 000000000..6296faebe
--- /dev/null
+++ b/slideshow/source/inc/slideview.hxx
@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SLIDEVIEW_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SLIDEVIEW_HXX
+
+#include "unoview.hxx"
+
+/* Definition of SlideView factory method */
+namespace slideshow
+{
+    namespace internal
+    {
+        class EventQueue;
+        class EventMultiplexer;
+
+        /** Factory for SlideView
+
+            @param xView
+            UNO slide view this object should encapsulate
+
+            @param rEventQueue
+            Global event queue, to be used for notification
+            messages.
+
+            @param rViewChangeFunc
+            Functor to call, when the UNO view signals a repaint.
+        */
+        UnoViewSharedPtr createSlideView(
+            css::uno::Reference< css::presentation::XSlideShowView> const& xView,
+            EventQueue&                                                rEventQueue,
+            EventMultiplexer&                                          rEventMultiplexer );
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_SLIDEVIEW_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/smilfunctionparser.hxx b/slideshow/source/inc/smilfunctionparser.hxx
new file mode 100644
index 000000000..4842e39a9
--- /dev/null
+++ b/slideshow/source/inc/smilfunctionparser.hxx
@@ -0,0 +1,156 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SMILFUNCTIONPARSER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SMILFUNCTIONPARSER_HXX
+
+#include "expressionnode.hxx"
+
+#include <basegfx/range/b2drectangle.hxx>
+
+#include <memory>
+
+
+/* Definition of SmilFunctionParser class */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        class SmilFunctionParser
+        {
+        public:
+            SmilFunctionParser() = delete;
+            SmilFunctionParser(const SmilFunctionParser&) = delete;
+            SmilFunctionParser& operator=(const SmilFunctionParser&) = delete;
+
+            /** Parse a string containing a SMIL value.
+
+                This method parses a string representing
+                a fixed value (i.e. a value that does not
+                change by time). Due to the dynamic view
+                capabilities of the presentation engine,
+                this value can sometimes only be determined
+                during runtime of the animation (because
+                e.g. mixed screen/view coordinates are
+                involved), and is thus still returned as an
+                ExpressionNode object. An example for
+                such a case is the "Width+1.0" string, which
+                contains the width of the shape in user
+                coordinate space, and the screen width
+                in device coordinate space.
+
+                The following grammar is accepted by this method:
+                <code>
+               identifier = 'pi'|'e'|'X'|'Y'|'Width'|'Height'
+
+               function = 'abs'|'sqrt'|'sin'|'cos'|'tan'|'atan'|'acos'|'asin'|'exp'|'log'
+
+               basic_expression =
+                                number |
+                                identifier |
+                                function '(' additive_expression ')' |
+                                '(' additive_expression ')'
+
+               unary_expression =
+                                   '-' basic_expression |
+                                basic_expression
+
+               multiplicative_expression =
+                                   unary_expression ( ( '*' unary_expression )* |
+                                                   ( '/' unary_expression )* )
+
+               additive_expression =
+                                   multiplicative_expression ( ( '+' multiplicative_expression )* |
+                                                               ( '-' multiplicative_expression )* )
+
+                </code>
+
+                @param rSmilValue
+                The string to parse
+
+                @param rRelativeShapeBounds
+                The bounds of the shape this SMIL value is to be
+                evaluated for. The bounds must be <em>relative</em> to
+                the page the shape is part of, i.e. within the [0,1]
+                range. This is necessary, since the string might
+                contain symbolic references to the shape bounding box.
+
+                @throws ParseError if an invalid expression is given.
+
+                @return the generated function object.
+             */
+            static std::shared_ptr<ExpressionNode> const & parseSmilValue( const OUString&           rSmilValue,
+                                                           const ::basegfx::B2DRectangle&   rRelativeShapeBounds ); // throw ParseError
+
+            /** Parse a string containing a SMIL function.
+
+                This method parses a string representing
+                a possibly time-varying SMIL function.
+
+                The following grammar is accepted by this method:
+                <code>
+               identifier = 't'|'pi'|'e'|'X'|'Y'|'Width'|'Height'
+
+               function = 'abs'|'sqrt'|'sin'|'cos'|'tan'|'atan'|'acos'|'asin'|'exp'|'log'
+
+               basic_expression =
+                                number |
+                                identifier |
+                                function '(' additive_expression ')' |
+                                '(' additive_expression ')'
+
+               unary_expression =
+                                   '-' basic_expression |
+                                basic_expression
+
+               multiplicative_expression =
+                                   unary_expression ( ( '*' unary_expression )* |
+                                                   ( '/' unary_expression )* )
+
+               additive_expression =
+                                   multiplicative_expression ( ( '+' multiplicative_expression )* |
+                                                               ( '-' multiplicative_expression )* )
+
+                </code>
+
+                @param rSmilFunction
+                The string to parse
+
+                @param rRelativeShapeBounds
+                The bounds of the shape this SMIL value is to be
+                evaluated for. The bounds must be <em>relative</em> to
+                the page the shape is part of, i.e. within the [0,1]
+                range. This is necessary, since the string might
+                contain symbolic references to the shape bounding box.
+
+                @throws ParseError if an invalid expression is given.
+
+                @return the generated function object.
+             */
+            static std::shared_ptr<ExpressionNode> const & parseSmilFunction( const OUString&            rSmilFunction,
+                                                              const ::basegfx::B2DRectangle&    rRelativeShapeBounds ); // throw ParseError
+
+        };
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_SMILFUNCTIONPARSER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/soundplayer.hxx b/slideshow/source/inc/soundplayer.hxx
new file mode 100644
index 000000000..e571a694a
--- /dev/null
+++ b/slideshow/source/inc/soundplayer.hxx
@@ -0,0 +1,117 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SOUNDPLAYER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SOUNDPLAYER_HXX
+
+#include <rtl/ustring.hxx>
+
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <com/sun/star/media/XPlayer.hpp>
+#include <avmedia/mediaitem.hxx>
+
+#include <memory>
+
+#include "pauseeventhandler.hxx"
+#include "disposable.hxx"
+#include "eventmultiplexer.hxx"
+
+
+/* Definition of SoundPlayer class */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        class MediaFileManager;
+
+        /** Little class that plays a sound from a URL.
+            TODO:
+            Must be explicitly disposed (as long as enable_shared_ptr_from_this
+            isn't available)!
+         */
+        class SoundPlayer : public PauseEventHandler,
+                            public Disposable
+        {
+        public:
+            /** Create a sound player object.
+
+                @param rSoundURL
+                URL to a sound file.
+
+                @param rComponentContext
+                Reference to a component context, used to create the
+                needed services
+
+                @throws css::lang::NoSupportException, if
+                the sound file is invalid, or not supported by the
+                player service.
+             */
+            static ::std::shared_ptr<SoundPlayer> create(
+                EventMultiplexer & rEventMultiplexer,
+                const OUString& rSoundURL,
+                const css::uno::Reference< css::uno::XComponentContext>& rComponentContext,
+                MediaFileManager& rMediaFileManager);
+
+            virtual ~SoundPlayer() override;
+
+            /** Query duration of sound playback.
+
+                If the sound is already playing, this method
+                returns the remaining playback time.
+
+                @return the playback duration in seconds.
+             */
+            double getDuration() const;
+
+            bool startPlayback();
+            bool stopPlayback();
+            bool isPlaying() const;
+
+            void setPlaybackLoop( bool bLoop );
+
+            // PauseEventHandler:
+            virtual bool handlePause( bool bPauseShow ) override;
+
+            // Disposable
+            virtual void dispose() override;
+
+        private:
+            SoundPlayer(
+                EventMultiplexer & rEventMultiplexer,
+                const OUString& rSoundURL,
+                const css::uno::Reference< css::uno::XComponentContext>& rComponentContext,
+                MediaFileManager & rMediaFileManager);
+
+            EventMultiplexer & mrEventMultiplexer;
+            // TODO(Q3): obsolete when boost::enable_shared_ptr_from_this
+            //           is available
+            ::std::shared_ptr<SoundPlayer> mThis;
+            // Temp file for package url.
+            ::std::shared_ptr<::avmedia::MediaTempFile> mpMediaTempFile;
+            css::uno::Reference< css::media::XPlayer > mxPlayer;
+        };
+
+        typedef ::std::shared_ptr< SoundPlayer > SoundPlayerSharedPtr;
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_SOUNDPLAYER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/stringanimation.hxx b/slideshow/source/inc/stringanimation.hxx
new file mode 100644
index 000000000..2cb26c0a9
--- /dev/null
+++ b/slideshow/source/inc/stringanimation.hxx
@@ -0,0 +1,71 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_STRINGANIMATION_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_STRINGANIMATION_HXX
+
+#include "animation.hxx"
+#include <rtl/ustring.hxx>
+
+
+/* Definition of StringAnimation interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Interface defining a string animation.
+
+            This interface is a specialization of the Animation
+            interface, and is used to animate attributes representable
+            by a discrete character string (e.g. font names)
+         */
+        class StringAnimation : public Animation
+        {
+        public:
+            typedef OUString ValueType;
+
+            /** Set the animation to value rStr
+
+                @param rStr
+                Current animation value.
+             */
+            virtual bool operator()( const ValueType& rStr ) = 0;
+
+            /** Request the underlying value for this animation.
+
+                This is necessary for pure To or By animations, as the
+                Activity cannot determine a sensible start value
+                otherwise.
+
+                @attention Note that you are only permitted to query
+                for the underlying value, if the animation has actually
+                been started (via start() call).
+             */
+            virtual ValueType getUnderlyingValue() const = 0;
+        };
+
+        typedef ::std::shared_ptr< StringAnimation > StringAnimationSharedPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_STRINGANIMATION_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/subsettableshapemanager.hxx b/slideshow/source/inc/subsettableshapemanager.hxx
new file mode 100644
index 000000000..f66639b6a
--- /dev/null
+++ b/slideshow/source/inc/subsettableshapemanager.hxx
@@ -0,0 +1,113 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SUBSETTABLESHAPEMANAGER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SUBSETTABLESHAPEMANAGER_HXX
+
+#include "shapemanager.hxx"
+#include "intrinsicanimationeventhandler.hxx"
+#include <memory>
+
+/* Definition of SubsettableShapeManager interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        class DocTreeNode;
+        class AttributableShape;
+        typedef ::std::shared_ptr< AttributableShape > AttributableShapeSharedPtr;
+
+        /** SubsettableShapeManager interface
+
+            Implementers of this interface manage creation and
+            revocation of shape subsets. Shape subsets are shapes that
+            represent (and animate) only parts of an original's shape
+            content.
+         */
+        class SubsettableShapeManager : public ShapeManager
+        {
+        public:
+            /** Query a subset of the given original shape
+
+                This method queries a new (but not necessarily unique)
+                shape, which displays only the given subset of the
+                original one. Calling this method multiple times with
+                the same original shape and DocTreeNode content always
+                returns the same shape.
+
+                Requesting a subset from an original shape leads to
+                the original shape ceasing to display the subsetted
+                content. In other words, shape content is always
+                displayed in exactly one shape.
+
+                @param rOrigShape
+                The shape the subset is to be created for
+
+                @param rSubsetShape
+                The subset to display in the generated shape.
+             */
+            virtual AttributableShapeSharedPtr getSubsetShape(
+                const AttributableShapeSharedPtr& rOrigShape,
+                const DocTreeNode&                rTreeNode ) = 0;
+
+            /** Revoke a previously queried subset shape.
+
+                With this method, a previously requested subset shape
+                is revoked again. If the last client revokes a given
+                subset, it will cease to be displayed, and the
+                original shape will again show the subset data.
+
+                @param rOrigShape
+                The shape the subset was created from
+
+                @param rSubsetShape
+                The subset created from rOrigShape
+             */
+            virtual void revokeSubset(
+                const AttributableShapeSharedPtr& rOrigShape,
+                const AttributableShapeSharedPtr& rSubsetShape ) = 0;
+
+            // Evil hackish way of getting intrinsic animation slide-wise
+
+            /** Register an event handler that will be called when
+                user paint parameters change.
+
+                @param rHandler
+                Handler to call when a shape listener changes
+            */
+            virtual void addIntrinsicAnimationHandler( const IntrinsicAnimationEventHandlerSharedPtr& rHandler ) = 0;
+            virtual void removeIntrinsicAnimationHandler( const IntrinsicAnimationEventHandlerSharedPtr& rHandler ) = 0;
+
+            /** Notify that shape-intrinsic animations are now enabled.
+            */
+            virtual void notifyIntrinsicAnimationsEnabled() = 0;
+
+            /** Notify that shape-intrinsic animations are now disabled.
+            */
+            virtual void notifyIntrinsicAnimationsDisabled() = 0;
+        };
+
+        typedef ::std::shared_ptr< SubsettableShapeManager > SubsettableShapeManagerSharedPtr;
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_SUBSETTABLESHAPEMANAGER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/tools.hxx b/slideshow/source/inc/tools.hxx
new file mode 100644
index 000000000..632933fee
--- /dev/null
+++ b/slideshow/source/inc/tools.hxx
@@ -0,0 +1,398 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_TOOLS_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_TOOLS_HXX
+
+#include <com/sun/star/uno/Sequence.hxx>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/uno/Reference.hxx>
+#include <com/sun/star/animations/XAnimationNode.hpp>
+#include <com/sun/star/container/XEnumerationAccess.hpp>
+#include <com/sun/star/container/XEnumeration.hpp>
+#include <comphelper/random.hxx>
+#include <osl/diagnose.h>
+#include <sal/log.hxx>
+
+#include <cppcanvas/color.hxx>
+
+#include "shapeattributelayer.hxx"
+#include "shape.hxx"
+#include "rgbcolor.hxx"
+#include "hslcolor.hxx"
+
+#include <memory>
+
+namespace com::sun::star::beans { struct NamedValue; }
+namespace basegfx
+{
+    class B2DRange;
+    class B2DVector;
+    class B2IVector;
+    class B2DHomMatrix;
+    typedef B2IVector B2ISize;
+}
+namespace cppcanvas{ class Canvas; }
+
+class GDIMetaFile;
+
+/* Definition of some animation tools */
+namespace slideshow
+{
+    namespace internal
+    {
+        class UnoView;
+        class Shape;
+        class ShapeAttributeLayer;
+        typedef std::shared_ptr< UnoView > UnoViewSharedPtr;
+        typedef std::shared_ptr< GDIMetaFile > GDIMetaFileSharedPtr;
+
+        template <typename T>
+        inline ::std::size_t hash_value( T const * p )
+        {
+            ::std::size_t d = static_cast< ::std::size_t >(
+                reinterpret_cast< ::std::ptrdiff_t >(p) );
+            return d + (d >> 3);
+        }
+
+        // xxx todo: remove with boost::hash when 1.33 is available
+        template <typename T>
+        struct hash
+        {
+            ::std::size_t operator()( T const& val ) const {
+                return hash_value(val);
+            }
+        };
+    }
+}
+
+namespace com::sun::star::uno {
+
+        template <typename T>
+        inline ::std::size_t hash_value(
+            css::uno::Reference<T> const& x )
+        {
+            // normalize to object root, because _only_ XInterface is defined
+            // to be stable during object lifetime:
+            css::uno::Reference< css::uno::XInterface> const xRoot( x, css::uno::UNO_QUERY );
+            return slideshow::internal::hash<void *>()(xRoot.get());
+        }
+
+}
+
+namespace slideshow
+{
+    namespace internal
+    {
+        // Value extraction from Any
+        // =========================
+
+        /// extract unary double value from Any
+        bool extractValue( double&                              o_rValue,
+                           const css::uno::Any&                rSourceAny,
+                           const ShapeSharedPtr&                rShape,
+                           const basegfx::B2DVector&            rSlideBounds );
+
+        /// extract int from Any
+        bool extractValue( sal_Int32&                           o_rValue,
+                           const css::uno::Any&                 rSourceAny,
+                           const ShapeSharedPtr&                rShape,
+                           const basegfx::B2DVector&            rSlideBounds );
+
+        /// extract enum/constant group value from Any
+        bool extractValue( sal_Int16&                           o_rValue,
+                           const css::uno::Any&                 rSourceAny,
+                           const ShapeSharedPtr&                rShape,
+                           const basegfx::B2DVector&            rSlideBounds );
+
+        /// extract color value from Any
+        bool extractValue( RGBColor&                            o_rValue,
+                           const css::uno::Any&                 rSourceAny,
+                           const ShapeSharedPtr&                rShape,
+                           const basegfx::B2DVector&            rSlideBounds );
+
+        /// extract color value from Any
+        bool extractValue( HSLColor&                            o_rValue,
+                           const css::uno::Any&                 rSourceAny,
+                           const ShapeSharedPtr&                rShape,
+                           const basegfx::B2DVector&            rSlideBounds );
+
+        /// extract plain string from Any
+        bool extractValue( OUString&                            o_rValue,
+                           const css::uno::Any&                 rSourceAny,
+                           const ShapeSharedPtr&                rShape,
+                           const basegfx::B2DVector&            rSlideBounds );
+
+        /// extract bool value from Any
+        bool extractValue( bool&                                o_rValue,
+                           const css::uno::Any&    rSourceAny,
+                           const ShapeSharedPtr&                rShape,
+                           const basegfx::B2DVector&            rSlideBounds );
+
+        /// extract double 2-tuple from Any
+        bool extractValue( basegfx::B2DTuple&                   o_rPair,
+                           const css::uno::Any&                 rSourceAny,
+                           const ShapeSharedPtr&                rShape,
+                           const basegfx::B2DVector&            rSlideBounds );
+
+        /** Search a sequence of NamedValues for a given element.
+
+            @return true, if the sequence contains the specified
+            element.
+         */
+        bool findNamedValue( css::uno::Sequence< css::beans::NamedValue > const& rSequence,
+                             const css::beans::NamedValue& rSearchKey );
+
+        basegfx::B2DRange calcRelativeShapeBounds( const basegfx::B2DVector& rPageSize,
+                                                   const basegfx::B2DRange&  rShapeBounds );
+
+        /** Get the shape transformation from the attribute set
+
+            @param rBounds
+            Original shape bound rect (to substitute default attribute
+            layer values)
+
+            @param pAttr
+            Attribute set. Might be NULL (then, rBounds is used to set
+            a simple scale and translate of the unit rect to rBounds).
+        */
+        basegfx::B2DHomMatrix getShapeTransformation(
+            const basegfx::B2DRectangle&         rBounds,
+            const ShapeAttributeLayerSharedPtr&  pAttr );
+
+        /** Get a shape's sprite transformation from the attribute set
+
+            @param rPixelSize
+            Pixel size of the sprite
+
+            @param rOrigSize
+            Original shape size (i.e. the size of the actual sprite
+            content, in the user coordinate system)
+
+            @param pAttr
+            Attribute set. Might be NULL (then, rBounds is used to set
+            a simple scale and translate of the unit rect to rBounds).
+
+            @return the transformation to be applied to the sprite.
+        */
+        basegfx::B2DHomMatrix getSpriteTransformation(
+            const basegfx::B2DVector&           rPixelSize,
+            const basegfx::B2DVector&           rOrigSize,
+            const ShapeAttributeLayerSharedPtr& pAttr );
+
+        /** Calc update area for a shape.
+
+            This method calculates the 'covered' area for the shape,
+            i.e. the rectangle that is affected when rendering the
+            shape. Apart from applying the given transformation to the
+            shape rectangle, this method also takes attributes into
+            account, which further scale the output (e.g. character
+            sizes).
+
+            @param rUnitBounds
+            Shape bounds, in the unit rect coordinate space
+
+            @param rShapeTransform
+            Transformation matrix the shape should undergo.
+
+            @param pAttr
+            Current shape attributes
+         */
+        basegfx::B2DRectangle getShapeUpdateArea(
+            const basegfx::B2DRectangle&          rUnitBounds,
+            const basegfx::B2DHomMatrix&          rShapeTransform,
+            const ShapeAttributeLayerSharedPtr&   pAttr );
+
+        /** Calc update area for a shape.
+
+            This method calculates the 'covered' area for the shape,
+            i.e. the rectangle that is affected when rendering the
+            shape. The difference from the other getShapeUpdateArea()
+            method is the fact that this one works without
+            ShapeAttributeLayer, and only scales up the given shape
+            user coordinate bound rect. The method is typically used
+            to retrieve user coordinate system bound rects for shapes
+            which are smaller than the default unit bound rect
+            (because e.g. of subsetting)
+
+            @param rUnitBounds
+            Shape bounds, in the unit rect coordinate space
+
+            @param rShapeBounds
+            Current shape bounding box in user coordinate space.
+         */
+        basegfx::B2DRange getShapeUpdateArea( const basegfx::B2DRange& rUnitBounds,
+                                              const basegfx::B2DRange& rShapeBounds );
+
+        /** Calc output position and size of shape, according to given
+            attribute layer.
+
+            Rotations, shears etc. and not taken into account,
+            i.e. the returned rectangle is NOT the bounding box. Use
+            it as if aBounds.getMinimum() is the output position and
+            aBounds.getRange() the scaling of the shape.
+         */
+        basegfx::B2DRectangle getShapePosSize(
+            const basegfx::B2DRectangle&        rOrigBounds,
+            const ShapeAttributeLayerSharedPtr& pAttr );
+
+        /** Convert a plain UNO API 32 bit int to RGBColor
+         */
+        RGBColor unoColor2RGBColor( sal_Int32 );
+        /** Convert an IntSRGBA to plain UNO API 32 bit int
+         */
+        sal_Int32 RGBAColor2UnoColor( cppcanvas::IntSRGBA );
+
+        /** Fill a plain rectangle on the given canvas with the given color
+         */
+        void fillRect( const cppcanvas::CanvasSharedPtr&       rCanvas,
+                       const basegfx::B2DRectangle& rRect,
+                       cppcanvas::IntSRGBA          aFillColor );
+
+        /** Init canvas with default background (white)
+         */
+        void initSlideBackground( const cppcanvas::CanvasSharedPtr&    rCanvas,
+                                  const basegfx::B2ISize&   rSize );
+
+        /// Gets a random ordinal [0,n)
+        inline ::std::size_t getRandomOrdinal( const ::std::size_t n )
+        {
+            return comphelper::rng::uniform_size_distribution(0, n-1);
+        }
+
+        template <typename ValueType>
+        inline bool getPropertyValue(
+            ValueType & rValue,
+            css::uno::Reference<
+            css::beans::XPropertySet> const & xPropSet,
+            OUString const & propName )
+        {
+            try {
+                const css::uno::Any& a(
+                    xPropSet->getPropertyValue( propName ) );
+                bool const bRet = css::uno::fromAny(a, &rValue);
+#if OSL_DEBUG_LEVEL > 0
+                if( !bRet )
+                    SAL_INFO("slideshow", OSL_THIS_FUNC << ": while retrieving property " << propName << ", cannot extract Any of type "
+                               << a.getValueTypeRef()->pTypeName);
+#endif
+                return bRet;
+            }
+            catch (css::uno::RuntimeException &)
+            {
+                throw;
+            }
+            catch (css::uno::Exception &)
+            {
+                return false;
+            }
+        }
+
+        template <typename ValueType>
+        inline bool getPropertyValue(
+            css::uno::Reference< ValueType >& rIfc,
+            css::uno::Reference< css::beans::XPropertySet> const & xPropSet,
+            OUString const & propName )
+        {
+            try
+            {
+                const css::uno::Any& a(xPropSet->getPropertyValue( propName ));
+                rIfc.set( a, css::uno::UNO_QUERY );
+
+                bool const bRet = rIfc.is();
+#if OSL_DEBUG_LEVEL > 0
+                if( !bRet )
+                    SAL_INFO("slideshow", OSL_THIS_FUNC << ": while retrieving property " << propName << ", cannot extract Any of type "
+                               << a.getValueTypeRef()->pTypeName << " to interface");
+#endif
+                return bRet;
+            }
+            catch (css::uno::RuntimeException &)
+            {
+                throw;
+            }
+            catch (css::uno::Exception &)
+            {
+                return false;
+            }
+        }
+
+        /// Get the content of the BoundRect shape property
+        basegfx::B2DRectangle getAPIShapeBounds( const css::uno::Reference< css::drawing::XShape >& xShape );
+
+/*
+        TODO(F1): When ZOrder someday becomes usable enable this
+
+        /// Get the content of the ZOrder shape property
+        double getAPIShapePrio( const css::uno::Reference< css::drawing::XShape >& xShape );
+*/
+
+        basegfx::B2IVector getSlideSizePixel( const basegfx::B2DVector&  rSize,
+                                              const UnoViewSharedPtr&    pView );
+    }
+
+    // TODO(Q1): this could possibly be implemented with a somewhat
+    // more lightweight template, by having the actual worker receive
+    // only a function pointer, and a thin templated wrapper around
+    // that which converts member functions into that.
+
+    /** Apply given functor to every animation node child.
+
+        @param xNode
+        Parent node
+
+        @param rFunctor
+        Functor to apply. The functor must have an appropriate
+        operator()( const css::uno::Reference< css::animations::XAnimationNode >& ) member.
+
+        @return true, if the functor was successfully applied to
+        all children, false otherwise.
+    */
+    template< typename Functor > inline bool for_each_childNode( const css::uno::Reference< css::animations::XAnimationNode >&    xNode,
+                                                                 Functor&                                                                                  rFunctor )
+    {
+        try
+        {
+            // get an XEnumerationAccess to the children
+            css::uno::Reference< css::container::XEnumerationAccess >
+                   xEnumerationAccess( xNode,
+                                       css::uno::UNO_QUERY_THROW );
+            css::uno::Reference< css::container::XEnumeration >
+                   xEnumeration( xEnumerationAccess->createEnumeration(),
+                                 css::uno::UNO_SET_THROW );
+
+            while( xEnumeration->hasMoreElements() )
+            {
+                css::uno::Reference< css::animations::XAnimationNode >
+                           xChildNode( xEnumeration->nextElement(),
+                                      css::uno::UNO_QUERY_THROW );
+                rFunctor( xChildNode );
+            }
+            return true;
+        }
+        catch( css::uno::Exception& )
+        {
+            return false;
+        }
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_TOOLS_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/transitionfactory.hxx b/slideshow/source/inc/transitionfactory.hxx
new file mode 100644
index 000000000..f863bca3b
--- /dev/null
+++ b/slideshow/source/inc/transitionfactory.hxx
@@ -0,0 +1,117 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_TRANSITIONFACTORY_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_TRANSITIONFACTORY_HXX
+
+#include <com/sun/star/animations/XTransitionFilter.hpp>
+#include <com/sun/star/presentation/XTransitionFactory.hpp>
+
+#include "rgbcolor.hxx"
+#include "slide.hxx"
+#include "screenupdater.hxx"
+#include "animationactivity.hxx"
+#include "activitiesfactory.hxx"
+#include "numberanimation.hxx"
+#include "soundplayer.hxx"
+#include "shapemanager.hxx"
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /* Definition of Transitionfactory class */
+        namespace TransitionFactory
+        {
+            /** Create a transition effect for shapes.
+
+                This method creates an AnimationActivity, which, when
+                run, performs the requested transition effect on the
+                given shape.
+
+                @param rParms
+                Collection of activity parameters, see ActivitiesFactory
+
+                @param rShape
+                Shape to animate
+
+                @param rShapeManager
+                ShapeManager, to manage shape animation
+
+                @param xTransition
+                The transition effect
+
+                @return the created activity, or NULL for no
+                transition effect
+             */
+            AnimationActivitySharedPtr createShapeTransition(
+                const ActivitiesFactory::CommonParameters&              rParms,
+                const AnimatableShapeSharedPtr&                         rShape,
+                const ShapeManagerSharedPtr&                            rShapeManager,
+                const ::basegfx::B2DVector&                             rSlideSize,
+                css::uno::Reference< css::animations::XTransitionFilter > const&  xTransition );
+
+
+            /** Create a transition effect for slides.
+
+                This method creates a NumberAnimation, which,
+                when run, performs the requested transition effect
+                with the slide bitmaps.
+
+                @param rEnteringBitmap
+                Bitmap of the slide which 'enters' the screen.
+
+                @param rLeavingBitmap
+                Bitmap of the slide which 'leaves' the screen.
+
+                @param nTransitionType
+                Type of the transition (see XTransitionFilter)
+
+                @param nTransitionSubType
+                Subtype of the transition (see XTransitionFilter)
+
+                @param bTransitionDirection
+                Direction of the transition (see XTransitionFilter)
+
+                @param rTransitionFadeColor
+                Optional fade color for the transition
+
+                @return the created animation, or NULL for no
+                transition effect
+             */
+            NumberAnimationSharedPtr createSlideTransition(
+                const SlideSharedPtr&                          rLeavingSlide,
+                const SlideSharedPtr&                          rEnteringSlide,
+                const UnoViewContainer&                        rViewContainer,
+                ScreenUpdater&                                 rScreenUpdater,
+                EventMultiplexer&                              rEventMultiplexer,
+                const css::uno::Reference< css::presentation::XTransitionFactory>&
+                                                               xOptionalFactory,
+                sal_Int16                                      nTransitionType,
+                sal_Int16                                      nTransitionSubType,
+                bool                                           bTransitionDirection,
+                const RGBColor&                                rTransitionFadeColor,
+                const SoundPlayerSharedPtr&                    rSoundPlayer );
+        }
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_TRANSITIONFACTORY_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/transitioninfo.hxx b/slideshow/source/inc/transitioninfo.hxx
new file mode 100644
index 000000000..241771bec
--- /dev/null
+++ b/slideshow/source/inc/transitioninfo.hxx
@@ -0,0 +1,144 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_TRANSITIONINFO_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_TRANSITIONINFO_HXX
+
+#include <sal/types.h>
+
+
+namespace slideshow {
+namespace internal {
+
+struct TransitionInfo
+{
+    // the following two member serve as the search key
+    // for an incoming XTransitionFilter node
+
+    // {
+
+    sal_Int16       mnTransitionType;
+    sal_Int16       mnTransitionSubType;
+
+    // }
+
+
+    /** This enum classifies a transition type
+     */
+    enum TransitionClass
+    {
+        /// Invalid type
+        TRANSITION_INVALID,
+
+        /// Transition expressed by parametric clip polygon
+        TRANSITION_CLIP_POLYPOLYGON,
+
+        /// Transition expressed by hand-crafted function
+        TRANSITION_SPECIAL
+    };
+
+    /// class of effect handling
+    TransitionClass meTransitionClass;
+
+    /// Rotation angle of clip polygon
+    double          mnRotationAngle;
+
+    /// X scaling of clip polygon (negative values mirror)
+    double          mnScaleX;
+
+    /// Y scaling of clip polygon (negative values mirror)
+    double          mnScaleY;
+
+    /** This enum determines the method how to reverse
+        a parametric clip polygon transition.
+
+        A reversed transition runs in the geometrically
+        opposite direction. For a left-to-right bar wipe, the
+        reversed transition is a right-to-left wipe, whereas
+        for an iris transition, the reversed mode will show
+        the target in the outer area (instead of in the inner
+        area, as in normal mode).
+    */
+    enum class ReverseMethod
+    {
+        /** Ignore direction attribute altogether
+            (if it has no sensible meaning for this transition)
+        */
+        Ignore,
+
+        /** Combination of ReverseMethod::InvertSweep and
+            ReverseMethod::SubtractPolygon.
+        */
+        SubtractAndInvert,
+
+        /// Reverse by rotating polygon 180 degrees
+        Rotate180,
+
+        /// Reverse by flipping polygon at the y (!) axis
+        FlipX,
+
+        /// Reverse by flipping polygon at the x (!) axis
+        FlipY
+    };
+
+    /** Indicating the method to use when transition
+        should be 'reversed'.
+
+        @see ReverseMethod
+    */
+    ReverseMethod   meReverseMethod;
+
+    /** When true, transition 'out' effects are realized
+        by inverting the parameter sweep direction (1->0
+        instead of 0->1). Otherwise, 'out' effects are
+        realized by changing inside and outside areas of
+        the parametric poly-polygon.
+    */
+    bool            mbOutInvertsSweep;
+
+    /** when true, scale clip polygon isotropically to
+        target size.  when false, scale is
+        anisotropically.
+    */
+    bool            mbScaleIsotrophically;
+
+
+    /// Compare against type and subtype
+    class Comparator
+    {
+        sal_Int16 mnTransitionType;
+        sal_Int16 mnTransitionSubType;
+    public:
+        Comparator( sal_Int16 nTransitionType,
+                    sal_Int16 nTransitionSubType )
+            : mnTransitionType( nTransitionType ),
+              mnTransitionSubType( nTransitionSubType ) {}
+        bool operator()( const TransitionInfo& rEntry ) const {
+            return rEntry.mnTransitionType == mnTransitionType &&
+                rEntry.mnTransitionSubType == mnTransitionSubType;
+        }
+    };
+};
+
+} // namespace internal
+} // namespace presentation
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_TRANSITIONINFO_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/unoview.hxx b/slideshow/source/inc/unoview.hxx
new file mode 100644
index 000000000..e1ec82549
--- /dev/null
+++ b/slideshow/source/inc/unoview.hxx
@@ -0,0 +1,76 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_UNOVIEW_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_UNOVIEW_HXX
+
+#include "view.hxx"
+#include <com/sun/star/uno/Reference.hxx>
+
+#include <vector>
+
+namespace com::sun::star::presentation { class XSlideShowView; }
+
+
+/* Definition of UnoView interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Extend View with UNO interface retrieval.
+
+            This interface extends View with a UNO interface
+            retrieval, to be used for Views which are set from
+            external API.
+         */
+        class UnoView : public View
+        {
+        public:
+            /** Retrieve the underlying UNO slide view.
+             */
+            virtual css::uno::Reference< css::presentation::XSlideShowView > getUnoView() const = 0;
+
+            /** Dispose view
+
+                This needs to be different from Disposable interface,
+                as the UNO XComponent also provides a dispose() (only
+                with a different calling convention under Windows).
+             */
+            virtual void _dispose() = 0;
+
+            /** Return whether the sound play back is enabled.
+            */
+            virtual bool isSoundEnabled() 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 std::shared_ptr< UnoView >      UnoViewSharedPtr;
+        typedef std::vector< UnoViewSharedPtr >   UnoViewVector;
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_UNOVIEW_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/unoviewcontainer.hxx b/slideshow/source/inc/unoviewcontainer.hxx
new file mode 100644
index 000000000..90c081904
--- /dev/null
+++ b/slideshow/source/inc/unoviewcontainer.hxx
@@ -0,0 +1,84 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_UNOVIEWCONTAINER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_UNOVIEWCONTAINER_HXX
+
+#include <com/sun/star/uno/Reference.hxx>
+
+#include "unoview.hxx"
+
+
+namespace com::sun::star::presentation { class XSlideShowView; }
+
+/* Definition of UnoViewContainer class */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Contains UnoViews
+         */
+        class UnoViewContainer
+        {
+        public:
+            UnoViewContainer();
+            UnoViewContainer(const UnoViewContainer&) = delete;
+            UnoViewContainer& operator=(const UnoViewContainer&) = delete;
+
+            /** Add a view to this container
+
+                @return true, if the view was successfully added
+                (false is e.g. returned, if the view was already
+                added)
+             */
+            bool addView( const UnoViewSharedPtr& rView );
+
+            /** Remove a previously added a view from this container
+
+                @return the View object, if this view was successfully
+                removed, and an empty shared_ptr otherwise (e.g. if
+                this view wasn't added in the first place)
+            */
+            UnoViewSharedPtr removeView( const css::uno::Reference<css::presentation::XSlideShowView >& xView );
+
+            /// Dispose all stored views. Implies clear().
+            void dispose();
+
+            // the following parrots STL container concept methods
+            // ===================================================
+
+            bool empty() const { return maViews.empty(); }
+
+            UnoViewVector::iterator         begin() { return maViews.begin(); }
+            UnoViewVector::const_iterator   begin() const { return maViews.begin(); }
+            UnoViewVector::iterator         end() { return maViews.end(); }
+            UnoViewVector::const_iterator   end() const { return maViews.end(); }
+
+        private:
+            /// All added views
+            UnoViewVector   maViews;
+        };
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_UNOVIEWCONTAINER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/usereventqueue.hxx b/slideshow/source/inc/usereventqueue.hxx
new file mode 100644
index 000000000..13b4d3adf
--- /dev/null
+++ b/slideshow/source/inc/usereventqueue.hxx
@@ -0,0 +1,271 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_USEREVENTQUEUE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_USEREVENTQUEUE_HXX
+
+#include <com/sun/star/animations/XAnimationNode.hpp>
+
+#include "eventmultiplexer.hxx"
+#include "eventqueue.hxx"
+#include "shape.hxx"
+
+/* Definition of UserEventQueue class */
+
+namespace slideshow {
+namespace internal {
+
+class AllAnimationEventHandler;
+class ShapeClickEventHandler;
+class ClickEventHandler;
+class CursorManager;
+class SkipEffectEventHandler;
+class RewindEffectEventHandler;
+class MouseEnterHandler;
+class MouseLeaveHandler;
+
+/** This class schedules user-activated events.
+
+    This class registers at the EventMultiplexer and fires
+    events registered for certain user actions. Note that all
+    events will not be fired immediately after the user action
+    occurred, but always added to the EventQueue (and fired the
+    next time that queue is processed). Which is actually a
+    feature.
+
+    Conceptually, an event is an object that typically is
+    fired only once. After that, the event is exhausted, and
+    should be discarded. Therefore, all events registered on
+    this object are fired and then all references to them are
+    removed.
+*/
+class UserEventQueue
+{
+public:
+    /** Create a user event queue
+
+        @param rEventMultiplexer
+        The slideshow-global event source, where this class
+        registers its event handlers.
+
+        @param rEventQueue
+        Reference to the main event queue. Since we hold this
+        object by plain reference, it must live longer than we
+        do. On the other hand, that queue must not fire events
+        after this object is destroyed, since we might
+        schedule events there which itself contain plain
+        references to this object. Basically, EventQueue and
+        UserEventQueue should have the same lifetime, and since
+        this is not possible, both must be destructed in a
+        phased mode: first clear both of any remaining events,
+        then destruct them.
+    */
+    UserEventQueue( EventMultiplexer&   rMultiplexer,
+                    EventQueue&         rEventQueue,
+                    CursorManager&      rCursorManager );
+    ~UserEventQueue();
+    UserEventQueue(const UserEventQueue&) = delete;
+    UserEventQueue& operator=(const UserEventQueue&) = delete;
+
+    /** Clear all registered events.
+
+        This method clears all registered, but
+        not-yet-executed events. This comes in handy when
+        force-ending a slide, to avoid interference with the
+        next slide's event registration.
+    */
+    void clear();
+
+    /** Set advance on click behaviour.
+
+        @param bAdvanceOnClick
+        When true, a click somewhere on the slide will also
+        generate next effect event.  In this case, it is
+        irrelevant where on the slide the mouse is clicked,
+        i.e. the shape need not be hit by the mouse.
+    */
+    void setAdvanceOnClick( bool bAdvanceOnClick );
+
+    /** Register an event that will be fired when the given
+        animation node starts.
+
+        Note that <em>all</em> registered events will be fired
+        when the animation start occurs. This is in contrast to
+        the mouse events below.
+    */
+    void registerAnimationStartEvent(
+        const EventSharedPtr&                             rEvent,
+        const css::uno::Reference<css::animations::XAnimationNode>&    xNode );
+
+    /** Register an event that will be fired when the given
+        animation node ends its active duration.
+
+        Note that <em>all</em> registered events will be fired
+        when the animation end occurs. This is in contrast to
+        the mouse events below.
+    */
+    void registerAnimationEndEvent(
+        const EventSharedPtr&                               rEvent,
+        const css::uno::Reference<css::animations::XAnimationNode>&      xNode );
+
+    /** Register an event that will be fired when audio output
+        stopped for the given animation node.
+
+        Note that <em>all</em> registered events will be fired
+        when the audio stopping occurs. This is in contrast to
+        the mouse events below.
+    */
+    void registerAudioStoppedEvent(
+        const EventSharedPtr&                               rEvent,
+        const css::uno::Reference<css::animations::XAnimationNode>&      xNode );
+
+    /** Register an event that is fired when a shape is clicked
+
+        For every mouse click, only one of the events
+        registered here is fired. The order of fired events is
+        the order of registration, i.e. the first event
+        registered will be the one fired for the first mouse
+        click on the given shape.
+    */
+    void registerShapeClickEvent( const EventSharedPtr& rEvent,
+                                  const ShapeSharedPtr& rShape );
+
+    /** Registers an event that is fired when the current effects(s)
+        are skipped, .e.g. when the left mouse button is pressed.
+        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,
+        const bool bSkipTriggersNextEffect);
+
+    /** Register an event that is fired to show the next event
+
+        For every next effect event, only one of the events
+        registered here is fired. The order of fired events is
+        the order of registration, i.e. the first event
+        registered will be the one fired for the first mouse
+        click. When advance-on-click (see method
+        setAdvanceOnClick()) is enabled, a mouse click
+        somewhere on the slide will also generate a next
+        effect event. In this case, it is irrelevant where on
+        the slide the mouse is clicked, i.e. the shape need
+        not be hit by the mouse.
+    */
+    void registerNextEffectEvent( const EventSharedPtr& rEvent );
+
+    /** Register an event that is fired on a double mouse
+        click on a shape
+
+        For every mouse double click, only one of the events
+        registered here is fired. The order of fired events is
+        the order of registration, i.e. the first event
+        registered will be the one fired for the first mouse
+        double click. It is irrelevant where on the slide the
+        mouse is clicked, i.e. the shape need not be hit by
+        the mouse.
+    */
+    void registerShapeDoubleClickEvent( const EventSharedPtr& rEvent,
+                                        const ShapeSharedPtr& rShape );
+
+    /** Register an event that is fired when the mouse enters
+        the area of the given shape
+
+        For every enter, only one of the events registered
+        here is fired. The order of fired events is the order
+        of registration, i.e. the first event registered will
+        be the one fired for the first time the mouse enters
+        the given shape.
+    */
+    void registerMouseEnterEvent( const EventSharedPtr& rEvent,
+                                  const ShapeSharedPtr& rShape );
+
+    /** Register an event that is fired when the mouse leaves
+        the area of the given shape
+
+        For every leave, only one of the events registered
+        here is fired. The order of fired events is the order
+        of registration, i.e. the first event registered will
+        be the one fired for the first time the mouse leaves
+        the given shape area.
+    */
+    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 programmatically.
+    */
+    void callSkipEffectEventHandler();
+
+private:
+    /** Generically register an event on one of the handlers.
+
+        If the handler is not yet created, do that and
+        register it via the Functor
+    */
+    template< typename Handler, typename Functor >
+    void registerEvent( ::std::shared_ptr< Handler >& rHandler,
+                        const EventSharedPtr&           rEvent,
+                        const Functor&                  rRegistrationFunctor );
+
+    /** Generically register an event on one of the handlers.
+
+        If the handler is not yet created, do that and
+        register it via the Functor. This version of the
+        registerEvent method takes an additional parameter
+        rArg, which is passed as the second argument to
+        rHandler's addEvent() method.
+    */
+    template< typename Handler, typename Arg, typename Functor >
+    void registerEvent( ::std::shared_ptr< Handler >& rHandler,
+                        const EventSharedPtr&           rEvent,
+                        const Arg&                      rArg,
+                        const Functor&                  rRegistrationFunctor );
+
+    EventMultiplexer&                               mrMultiplexer;
+    EventQueue&                                     mrEventQueue;
+    CursorManager&                                  mrCursorManager;
+
+    ::std::shared_ptr<AllAnimationEventHandler>   mpAnimationStartEventHandler;
+    ::std::shared_ptr<AllAnimationEventHandler>   mpAnimationEndEventHandler;
+    ::std::shared_ptr<AllAnimationEventHandler>   mpAudioStoppedEventHandler;
+    ::std::shared_ptr<ShapeClickEventHandler>     mpShapeClickEventHandler;
+    ::std::shared_ptr<ClickEventHandler>          mpClickEventHandler;
+    ::std::shared_ptr<SkipEffectEventHandler>     mpSkipEffectEventHandler;
+    ::std::shared_ptr<ShapeClickEventHandler>     mpShapeDoubleClickEventHandler;
+    ::std::shared_ptr<MouseEnterHandler>          mpMouseEnterHandler;
+    ::std::shared_ptr<MouseLeaveHandler>          mpMouseLeaveHandler;
+
+    bool                                            mbAdvanceOnClick;
+};
+
+} // namespace internal
+} // namespace presentation
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_USEREVENTQUEUE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/view.hxx b/slideshow/source/inc/view.hxx
new file mode 100644
index 000000000..4298fa1b2
--- /dev/null
+++ b/slideshow/source/inc/view.hxx
@@ -0,0 +1,89 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_VIEW_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_VIEW_HXX
+
+#include "viewlayer.hxx"
+
+#include <memory>
+#include <vector>
+
+
+namespace basegfx { class B2DRange; class B2DVector; }
+
+
+/* Definition of View interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        class View : public ViewLayer
+        {
+        public:
+            /** Create a new view layer for this view
+
+                @param rLayerBounds
+                Specifies the bound rect of the layer relative to the
+                user view coordinate system.
+
+                This method sets the bounds of the view layer in
+                document coordinates (i.e. 'logical' coordinates). The
+                resulting transformation is then concatenated with the
+                underlying view transformation, returned by the
+                getTransformation() method.
+             */
+            virtual ViewLayerSharedPtr createViewLayer( const basegfx::B2DRange& rLayerBounds ) const = 0;
+
+            /** Update screen representation from backbuffer
+             */
+            virtual bool updateScreen() const = 0;
+
+            /** Paint screen content unconditionally from backbuffer
+             */
+            virtual bool paintScreen() const = 0;
+
+            /** Set the size of the user view coordinate system.
+
+                This method sets the width and height of the view in
+                document coordinates (i.e. 'logical' coordinates). The
+                resulting transformation is then concatenated with the
+                underlying view transformation, returned by the
+                getTransformation() method.
+            */
+            virtual void setViewSize( const ::basegfx::B2DSize& ) = 0;
+
+            /** Change the view's mouse cursor.
+
+                @param nPointerShape
+                One of the css::awt::SystemPointer
+                constant group members.
+             */
+            virtual void setCursorShape( sal_Int16 nPointerShape ) = 0;
+        };
+
+        typedef std::shared_ptr< View >     ViewSharedPtr;
+        typedef std::vector< ViewSharedPtr >  ViewVector;
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_VIEW_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/vieweventhandler.hxx b/slideshow/source/inc/vieweventhandler.hxx
new file mode 100644
index 000000000..aa75acaf9
--- /dev/null
+++ b/slideshow/source/inc/vieweventhandler.hxx
@@ -0,0 +1,90 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_VIEWEVENTHANDLER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_VIEWEVENTHANDLER_HXX
+
+#include <memory>
+
+#include "unoview.hxx"
+#include "disposable.hxx"
+
+
+/* Definition of ViewEventHandler interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+
+        /** Interface for handling view events.
+
+            Classes implementing this interface can be added to an
+            EventMultiplexer object, and are called from there to
+            handle view events.
+         */
+        class ViewEventHandler : public virtual SharedPtrAble
+        {
+        public:
+            /** Notify new view.
+
+                @param rView
+                The newly added view
+             */
+            virtual void viewAdded( const UnoViewSharedPtr& rView ) = 0;
+
+            /** Notify removed view.
+
+                @param rView
+                The removed view
+             */
+            virtual void viewRemoved( const UnoViewSharedPtr& rView ) = 0;
+
+            /** Notify changed view.
+
+                Reasons for a viewChanged notification can be
+                different view size, transformation, or other device
+                properties (color resolution or profile, etc.)
+
+                @param rView
+                The changed view
+             */
+            virtual void viewChanged( const UnoViewSharedPtr& rView ) = 0;
+
+            /** Notify that all views changed.
+
+                Reasons for a viewChanged notification can be
+                different view size, transformation, or other device
+                properties (color resolution or profile, etc.)
+
+                Note that this method avoids hidden inefficiencies
+                (O(n^2) behaviour when viewChanged() needs to perform
+                linear searches)
+             */
+            virtual void viewsChanged() = 0;
+        };
+
+        typedef ::std::weak_ptr< ViewEventHandler >   ViewEventHandlerWeakPtr;
+
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_VIEWEVENTHANDLER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/viewlayer.hxx b/slideshow/source/inc/viewlayer.hxx
new file mode 100644
index 000000000..a3a331a16
--- /dev/null
+++ b/slideshow/source/inc/viewlayer.hxx
@@ -0,0 +1,176 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_VIEWLAYER_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_VIEWLAYER_HXX
+
+#include <sal/config.h>
+#include <memory>
+#include <com/sun/star/geometry/IntegerSize2D.hpp>
+
+namespace basegfx
+{
+    class B1DRange;
+    class B2DRange;
+    class B2DVector;
+    class B2DHomMatrix;
+    class B2DPolyPolygon;
+    typedef B2DVector B2DSize;
+}
+namespace cppcanvas
+{
+    class Canvas;
+    class CustomSprite;
+    typedef std::shared_ptr< Canvas > CanvasSharedPtr;
+    typedef std::shared_ptr< ::cppcanvas::CustomSprite > CustomSpriteSharedPtr;
+}
+
+
+/* Definition of ViewLayer interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        class View;
+        typedef std::shared_ptr< View > ViewSharedPtr;
+
+        class ViewLayer
+        {
+        public:
+            virtual ~ViewLayer() {}
+
+            /** Query whether layer displays on given view.
+
+                @return true, if this layer displays on the given
+                view.
+            */
+            virtual bool isOnView(ViewSharedPtr const& rView) const = 0;
+
+            /** Get the associated canvas of this layer.
+
+                The canvas returned by this method must not change, as
+                long as this object is alive.
+            */
+            virtual cppcanvas::CanvasSharedPtr getCanvas() const = 0;
+
+            /** Clear the clipped view layer area
+
+                This method clears the area inside the clip polygon,
+                if none is set, the transformed unit rectangle of the
+                view.
+             */
+            virtual void clear() const = 0;
+
+            /** Clear the complete view
+
+                This method clears the full view area (not only the
+                transformed unit rectangle, or within the clip). If
+                this ViewLayer represents the background layer, the
+                whole XSlideShowView is cleared. If this ViewLayer is
+                implemented using sprites (i.e. one of the upper
+                layers), the sprite is cleared to fully transparent.
+             */
+            virtual void clearAll() const = 0;
+
+            /** Create a sprite for this layer
+
+                @param rSpriteSizePixel
+                Sprite size in device pixel
+
+                @param nPriority
+                Sprite priority. This value determines the priority of
+                this sprite, relative to all other sprites of this
+                ViewLayer. The higher the priority, the closer to the
+                foreground the sprite will be.
+
+                @return the sprite, or NULL on failure (or if this
+                canvas does not support sprites).
+            */
+            virtual cppcanvas::CustomSpriteSharedPtr
+            createSprite( const basegfx::B2DSize& rSpriteSizePixel,
+                          double                  nPriority ) const = 0;
+
+            /** Set the layer priority range
+
+                This method influences the relative priority of this
+                layer, i.e. the z position in relation to other layers
+                on the parent view. The higher the priority range, the
+                further in front the layer resides.
+
+                @param rRange
+                Priority range, must be in the range [0,1]
+            */
+            virtual void setPriority( const basegfx::B1DRange& rRange ) = 0;
+
+            /** Get the overall view transformation.
+
+                This method should <em>not</em> simply return the
+                underlying canvas' transformation, but rather provide
+                a layer above that. This enables clients of the
+                slideshow to set their own user space transformation
+                at the canvas, whilst the slideshow adds their
+                transformation on top of that. Concretely, this method
+                returns the user transform (implicitly calculated
+                from the setViewSize() method), combined with the view
+                transformation.
+            */
+            virtual basegfx::B2DHomMatrix getTransformation() const = 0;
+
+            virtual css::geometry::IntegerSize2D getTranslationOffset() const = 0;
+
+            /** Get the overall view transformation.
+
+                Same transformation as with getTransformation(), only
+                that you can safely use this one to position sprites
+                on screen (no ViewLayer offsets included whatsoever).
+            */
+            virtual basegfx::B2DHomMatrix getSpriteTransformation() const = 0;
+
+            /** Set clipping on this view layer.
+
+                @param rClip
+                Clip poly-polygon to set. The polygon is interpreted
+                in the user coordinate system, i.e. the view layer has
+                the size as given by setViewSize() on its
+                corresponding View.
+             */
+            virtual void setClip( const basegfx::B2DPolyPolygon& rClip ) = 0;
+
+            /** Resize this view layer.
+
+                @param rArea
+                New area to cover. The area is interpreted in the user
+                coordinate system, i.e. relative to the size as given
+                by setViewSize() on the corresponding View.
+
+                @return true, if layer was actually resized (which
+                invalidates its content)
+             */
+            virtual bool resize( const basegfx::B2DRange& rArea ) = 0;
+
+        };
+
+        typedef std::shared_ptr< ViewLayer > ViewLayerSharedPtr;
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_VIEWLAYER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/viewupdate.hxx b/slideshow/source/inc/viewupdate.hxx
new file mode 100644
index 000000000..f083347ce
--- /dev/null
+++ b/slideshow/source/inc/viewupdate.hxx
@@ -0,0 +1,62 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_VIEWUPDATE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_VIEWUPDATE_HXX
+
+#include "disposable.hxx"
+#include <memory>
+
+/* Definition of ViewUpdate interface */
+
+namespace slideshow
+{
+    namespace internal
+    {
+        /** Interface for something that can perform view updates.
+
+            Use this interface for objects that perform view updates
+            from time to time, e.g. slide content. Availability of
+            updates can be queried, and subsequently performed.
+         */
+        class ViewUpdate : public Disposable
+        {
+        public:
+            /** Perform the update action on all views
+
+                @return true, if the update was performed
+                successfully, false otherwise.
+             */
+            virtual bool update() = 0;
+
+            /** Query whether updates are pending
+
+                @return true, if updates are pending. Calling update()
+                subsequently will perform the pending update then.
+             */
+            virtual bool needsUpdate() const = 0;
+        };
+
+        typedef ::std::shared_ptr< ViewUpdate > ViewUpdateSharedPtr;
+    }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_VIEWUPDATE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/slideshow/source/inc/wakeupevent.hxx b/slideshow/source/inc/wakeupevent.hxx
new file mode 100644
index 000000000..6992be9e7
--- /dev/null
+++ b/slideshow/source/inc/wakeupevent.hxx
@@ -0,0 +1,85 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_WAKEUPEVENT_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_WAKEUPEVENT_HXX
+
+#include <canvas/elapsedtime.hxx>
+
+#include "event.hxx"
+#include "activitiesqueue.hxx"
+
+namespace slideshow {
+namespace internal {
+
+/** Little helper class, used to set Activities active again
+    after some sleep period.
+
+    Clients can use this class to schedule wakeup events at
+    the EventQueue, to avoid busy-waiting for the next
+    discrete time instant.
+*/
+class WakeupEvent : public Event
+{
+public:
+    WakeupEvent(
+        std::shared_ptr< ::canvas::tools::ElapsedTime > const& pTimeBase,
+        ActivitiesQueue & rActivityQueue );
+    WakeupEvent(const WakeupEvent&) = delete;
+    WakeupEvent& operator=(const WakeupEvent&) = delete;
+
+    virtual void dispose() override;
+    virtual bool fire() override;
+    virtual bool isCharged() const override;
+    virtual double getActivationTime( double nCurrentTime ) const override;
+
+    /// Start the internal timer
+    void start();
+
+    /** Set the next timeout this object should generate.
+
+        @param nextTime
+        Absolute time, measured from the last start() call,
+        when this event should wakeup the Activity again. If
+        your time is relative, simply call start() just before
+        every setNextTimeout() call.
+    */
+    void setNextTimeout( double nextTime );
+
+    /** Set activity to wakeup.
+
+        The activity given here will be reinserted into the
+        ActivitiesQueue, once the timeout is reached.
+    */
+    void setActivity( const ActivitySharedPtr& rActivity );
+
+private:
+    ::canvas::tools::ElapsedTime    maTimer;
+    double                          mnNextTime;
+    ActivitySharedPtr               mpActivity;
+    ActivitiesQueue&                mrActivityQueue;
+};
+
+typedef ::std::shared_ptr< WakeupEvent > WakeupEventSharedPtr;
+
+} // namespace internal
+} // namespace presentation
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_WAKEUPEVENT_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */