slideshow/source/engine/transitions/slidechangebase.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_SLIDESHOW_SOURCE_ENGINE_TRANSITIONS_SLIDECHANGEBASE_HXX
  21 #define INCLUDED_SLIDESHOW_SOURCE_ENGINE_TRANSITIONS_SLIDECHANGEBASE_HXX
  22
  23 #include <osl/mutex.hxx>
  24
  25 #include "unoview.hxx"
  26 #include "vieweventhandler.hxx"
  27 #include "numberanimation.hxx"
  28 #include "slide.hxx"
  29 #include "screenupdater.hxx"
  30 #include "soundplayer.hxx"
  31
  32 #include <memory>
  33 #include <boost/optional.hpp>
  34
  35 namespace cppcanvas
  36 {
  37     class Canvas;
  38     class CustomSprite;
  39 }
  40
  41 namespace slideshow {
  42 namespace internal {
  43
  44 /** Base class for all slide change effects.
  45
  46     This class provides the basic sprite and view handling
  47     functionality.  Derived classes should normally only need to
  48     implement the perform() method.
  49 */
  50 class SlideChangeBase : public ViewEventHandler,
  51                         public NumberAnimation
  52 {
  53 public:
  54     SlideChangeBase(const SlideChangeBase&) = delete;
  55     SlideChangeBase& operator=(const SlideChangeBase&) = delete;
  56
  57     // NumberAnimation
  58     virtual bool operator()( double x ) override;
  59     virtual double getUnderlyingValue() const override;
  60
  61     // Animation
  62     virtual void prefetch( const AnimatableShapeSharedPtr&,
  63                            const ShapeAttributeLayerSharedPtr& ) override;
  64     virtual void start( const AnimatableShapeSharedPtr&,
  65                         const ShapeAttributeLayerSharedPtr& ) override;
  66     virtual void end() override;
  67
  68     // ViewEventHandler
  69     virtual void viewAdded( const UnoViewSharedPtr& rView ) override;
  70     virtual void viewRemoved( const UnoViewSharedPtr& rView ) override;
  71     virtual void viewChanged( const UnoViewSharedPtr& rView ) override;
  72     virtual void viewsChanged() override;
  73
  74 protected:
  75     /** Create a new SlideChanger, for the given leaving and
  76         entering slides.
  77     */
  78     SlideChangeBase(
  79         ::boost::optional<SlideSharedPtr> const & leavingSlide,
  80         const SlideSharedPtr&                     pEnteringSlide,
  81         const SoundPlayerSharedPtr&               pSoundPlayer,
  82         const UnoViewContainer&                   rViewContainer,
  83         ScreenUpdater&                            rScreenUpdater,
  84         EventMultiplexer&                         rEventMultiplexer,
  85         bool                                      bCreateLeavingSprites = true,
  86         bool                                      bCreateEnteringSprites = true );
  87
  88     /// Info on a per-view basis
  89     struct ViewEntry
  90     {
  91         explicit ViewEntry( const UnoViewSharedPtr& rView ) :
  92             mpView( rView )
  93         {
  94         }
  95
  96         /// The view this entry is for
  97         UnoViewSharedPtr                              mpView;
  98         /// outgoing slide sprite
  99         std::shared_ptr<cppcanvas::CustomSprite>    mpOutSprite;
 100         /// incoming slide sprite
 101         std::shared_ptr<cppcanvas::CustomSprite>    mpInSprite;
 102         /// outgoing slide bitmap
 103         mutable SlideBitmapSharedPtr                  mpLeavingBitmap;
 104         /// incoming slide bitmap
 105         mutable SlideBitmapSharedPtr                  mpEnteringBitmap;
 106
 107         // for algo access
 108         const UnoViewSharedPtr& getView() const { return mpView; }
 109     };
 110
 111     typedef ::std::vector<ViewEntry> ViewsVecT;
 112
 113     ViewsVecT::const_iterator beginViews() { return maViewData.begin(); }
 114     ViewsVecT::const_iterator endViews() { return maViewData.end(); }
 115
 116     SlideBitmapSharedPtr getLeavingBitmap( const ViewEntry& rViewEntry ) const;
 117     SlideBitmapSharedPtr getEnteringBitmap( const ViewEntry& rViewEntry ) const;
 118
 119     SlideBitmapSharedPtr createBitmap( const UnoViewSharedPtr&                pView,
 120                                        const boost::optional<SlideSharedPtr>& rSlide_ ) const;
 121
 122     ::basegfx::B2ISize getEnteringSlideSizePixel( const UnoViewSharedPtr& pView ) const;
 123
 124     static void renderBitmap( SlideBitmapSharedPtr const&                 pSlideBitmap,
 125                        std::shared_ptr<cppcanvas::Canvas> const& pCanvas );
 126
 127     /** Called on derived classes to perform actions before first run.
 128
 129         This typically involves rendering of the initial slide content.
 130
 131         @param rViewEntry the view entry
 132
 133         @param rDestinationCanvas the canvas to render on
 134      */
 135     virtual void prepareForRun(
 136             const ViewEntry& rViewEntry,
 137             const cppcanvas::CanvasSharedPtr& rDestinationCanvas );
 138
 139     /** Called on derived classes to implement actual slide change.
 140
 141         This method is called with the sprite of the slide coming 'in'
 142
 143         @param rSprite
 144         Current sprite to operate on. This is the sprite of the
 145         'entering' slide
 146
 147         @param t
 148         Current parameter value
 149     */
 150     virtual void performIn(
 151         const std::shared_ptr<cppcanvas::CustomSprite>&   rSprite,
 152         const ViewEntry&                                    rViewEntry,
 153         const std::shared_ptr<cppcanvas::Canvas>&         rDestinationCanvas,
 154         double                                              t );
 155
 156     /** Called on derived classes to implement actual slide change.
 157
 158         This method is called with the sprite of the slide moving 'out'
 159
 160         @param rSprite
 161         Current sprite to operate on. This is the sprite of the
 162         'leaving' slide
 163
 164         @param t
 165         Current parameter value
 166     */
 167     virtual void performOut(
 168         const std::shared_ptr<cppcanvas::CustomSprite>& rSprite,
 169         const ViewEntry&                                  rViewEntry,
 170         const std::shared_ptr<cppcanvas::Canvas>&       rDestinationCanvas,
 171         double                                            t );
 172
 173     ScreenUpdater& getScreenUpdater() const { return mrScreenUpdater; }
 174
 175 private:
 176
 177     std::shared_ptr<cppcanvas::CustomSprite> createSprite(
 178         UnoViewSharedPtr const &   pView,
 179         ::basegfx::B2DSize const & rSpriteSize,
 180         double                     nPrio ) const;
 181
 182     void addSprites( ViewEntry& rEntry );
 183     static void clearViewEntry( ViewEntry& rEntry );
 184
 185     SoundPlayerSharedPtr                mpSoundPlayer;
 186
 187     EventMultiplexer&                   mrEventMultiplexer;
 188     ScreenUpdater&                      mrScreenUpdater;
 189
 190     ::boost::optional<SlideSharedPtr>   maLeavingSlide;
 191     SlideSharedPtr                      mpEnteringSlide;
 192
 193     ViewsVecT                           maViewData;
 194     const UnoViewContainer&             mrViewContainer;
 195
 196     const bool                          mbCreateLeavingSprites;
 197     const bool                          mbCreateEnteringSprites;
 198     bool                                mbSpritesVisible;
 199     bool                                mbFinished;
 200     bool                                mbPrefetched;
 201 };
 202
 203 } // namespace internal
 204 } // namespace presentation
 205
 206 #endif // INCLUDED_SLIDESHOW_SOURCE_ENGINE_TRANSITIONS_SLIDECHANGEBASE_HXX
 207
 208 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */