slideshow/source/engine/animatedsprite.cxx

   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
  21 #include <tools/diagnose_ex.h>
  22
  23 #include <animatedsprite.hxx>
  24
  25 #include <cppcanvas/canvas.hxx>
  26 #include <cppcanvas/customsprite.hxx>
  27 #include <canvas/canvastools.hxx>
  28
  29 #include <basegfx/vector/b2dvector.hxx>
  30 #include <basegfx/point/b2dpoint.hxx>
  31 #include <basegfx/matrix/b2dhommatrix.hxx>
  32 #include <basegfx/numeric/ftools.hxx>
  33
  34
  35 using namespace ::com::sun::star;
  36
  37 namespace slideshow::internal
  38 {
  39         AnimatedSprite::AnimatedSprite( const ViewLayerSharedPtr&   rViewLayer,
  40                                         const ::basegfx::B2DSize&   rSpriteSizePixel,
  41                                         double                      nSpritePrio ) :
  42             mpViewLayer( rViewLayer ),
  43             mpSprite(),
  44             maEffectiveSpriteSizePixel( rSpriteSizePixel ),
  45             maContentPixelOffset(),
  46             mnSpritePrio(nSpritePrio),
  47             mnAlpha(0.0),
  48             maPosPixel(),
  49             maClip(),
  50             mbSpriteVisible( false )
  51         {
  52             ENSURE_OR_THROW( mpViewLayer, "AnimatedSprite::AnimatedSprite(): Invalid view layer" );
  53
  54             // Add half a pixel tolerance to sprite size, since we later on compare
  55             // against it in resize(). And view transformations will almost never yield
  56             // the same data bits when transforming to device coordinates
  57             maEffectiveSpriteSizePixel += ::basegfx::B2DSize(0.5, 0.5);
  58
  59             mpSprite = mpViewLayer->createSprite( maEffectiveSpriteSizePixel,
  60                                                   mnSpritePrio );
  61
  62             ENSURE_OR_THROW( mpSprite, "AnimatedSprite::AnimatedSprite(): Could not create sprite" );
  63         }
  64
  65         ::cppcanvas::CanvasSharedPtr AnimatedSprite::getContentCanvas() const
  66         {
  67             ENSURE_OR_THROW( mpViewLayer->getCanvas(), "AnimatedSprite::getContentCanvas(): No view layer canvas" );
  68
  69             const ::cppcanvas::CanvasSharedPtr pContentCanvas( mpSprite->getContentCanvas() );
  70             pContentCanvas->clear();
  71
  72             // extract linear part of canvas view transformation
  73             // (linear means: without translational components). The
  74             // only translation that is imposed at the view transform
  75             // is the local content pixel offset.
  76
  77             // We can apply that directly here, no need to call
  78             // aLinearTransform.translate(), since, as said above, the
  79             // last column of aLinearTransform is assumed [0 0 1]
  80             ::basegfx::B2DHomMatrix aLinearTransform( mpViewLayer->getTransformation() );
  81             aLinearTransform.set( 0, 2, maContentPixelOffset.getX() );
  82             aLinearTransform.set( 1, 2, maContentPixelOffset.getY() );
  83
  84             // apply linear part of canvas view transformation to sprite canvas
  85             pContentCanvas->setTransformation( aLinearTransform );
  86
  87             return pContentCanvas;
  88         }
  89
  90         void AnimatedSprite::resize( const ::basegfx::B2DSize& rSpriteSizePixel )
  91         {
  92             // Enlarge or reduce the sprite size, if necessary.  This
  93             // method employs a strategy similar to container, when
  94             // allocating memory: size is doubled or halved every time
  95             // the limit is reached. This makes for amortized constant
  96             // time in runtime complexity. Note that we take exact
  97             // powers of two here, since several HW-accelerated canvas
  98             // implementations are limited to such sprite sizes
  99             // (otherwise, those implementations would internally
 100             // round up, too, wasting precious mem).
 101             ::basegfx::B2DSize  aNewSize( maEffectiveSpriteSizePixel );
 102             bool                bNeedResize( false );
 103
 104             if( rSpriteSizePixel.getX() > maEffectiveSpriteSizePixel.getX() ||
 105                 rSpriteSizePixel.getX() < 0.5*maEffectiveSpriteSizePixel.getX() )
 106             {
 107                 // enlarge or shrink width
 108                 aNewSize.setX( ::canvas::tools::nextPow2( ::basegfx::fround(rSpriteSizePixel.getX()) ) );
 109                 bNeedResize = true;
 110             }
 111
 112             if( rSpriteSizePixel.getY() > maEffectiveSpriteSizePixel.getY() ||
 113                 rSpriteSizePixel.getY() < 0.5*maEffectiveSpriteSizePixel.getY() )
 114             {
 115                 // enlarge or shrink height, by doubling it
 116                 aNewSize.setY( ::canvas::tools::nextPow2( ::basegfx::fround(rSpriteSizePixel.getY()) ) );
 117                 bNeedResize = true;
 118             }
 119
 120             if( !bNeedResize )
 121                 return;
 122
 123             // as the old sprite might have already been altered
 124             // (and therefore been placed in the update list of
 125             // the spritecanvas for this frame), must hide it
 126             // here, to ensure it's not visible on screen any
 127             // longer.
 128             mpSprite->hide();
 129
 130             maEffectiveSpriteSizePixel = aNewSize;
 131             mpSprite = mpViewLayer->createSprite( maEffectiveSpriteSizePixel,
 132                                                   mnSpritePrio );
 133
 134             ENSURE_OR_THROW( mpSprite,
 135                               "AnimatedSprite::resize(): Could not create new sprite" );
 136
 137             // set attributes similar to previous sprite
 138             if (mbSpriteVisible)
 139             {
 140                 mpSprite->show();
 141                 mpSprite->setAlpha( mnAlpha );
 142
 143                 if( maPosPixel )
 144                     mpSprite->movePixel( *maPosPixel );
 145
 146                 if( maClip )
 147                     mpSprite->setClip( *maClip );
 148             }
 149         }
 150
 151         void AnimatedSprite::setPixelOffset( const ::basegfx::B2DSize& rPixelOffset )
 152         {
 153             maContentPixelOffset = rPixelOffset;
 154         }
 155
 156         void AnimatedSprite::movePixel( const ::basegfx::B2DPoint& rNewPos )
 157         {
 158             maPosPixel = rNewPos;
 159             mpSprite->movePixel( rNewPos );
 160         }
 161
 162         void AnimatedSprite::setAlpha( double nAlpha )
 163         {
 164             mnAlpha = nAlpha;
 165             mpSprite->setAlpha( nAlpha );
 166         }
 167
 168         void AnimatedSprite::clip( const ::basegfx::B2DPolyPolygon& rClip )
 169         {
 170             maClip = rClip;
 171             mpSprite->setClipPixel( rClip );
 172         }
 173
 174         void AnimatedSprite::clip()
 175         {
 176             maClip.reset();
 177             mpSprite->setClip();
 178         }
 179
 180         void AnimatedSprite::transform( const ::basegfx::B2DHomMatrix& rTransform )
 181         {
 182             mpSprite->transform( rTransform );
 183         }
 184
 185         void AnimatedSprite::hide()
 186         {
 187             mpSprite->hide();
 188             mbSpriteVisible = false;
 189         }
 190
 191         void AnimatedSprite::show()
 192         {
 193             mbSpriteVisible = true;
 194             mpSprite->show();
 195         }
 196
 197 }
 198
 199 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */