LCOV - code coverage report
Current view: top level - canvas/source/tools - spriteredrawmanager.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 1 129 0.8 %
Date: 2014-11-03 Functions: 2 21 9.5 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <canvas/debug.hxx>
      22             : #include <tools/diagnose_ex.h>
      23             : #include <canvas/spriteredrawmanager.hxx>
      24             : 
      25             : #include <basegfx/range/b2drectangle.hxx>
      26             : #include <basegfx/tools/canvastools.hxx>
      27             : #include <basegfx/vector/b2dsize.hxx>
      28             : 
      29             : #include <algorithm>
      30             : #include <o3tl/compat_functional.hxx>
      31             : #include <boost/bind.hpp>
      32             : 
      33             : 
      34             : namespace canvas
      35             : {
      36             :     namespace
      37             :     {
      38             :         /** Helper class to condense sprite updates into a single action
      39             : 
      40             :             This class tracks the sprite changes over the recorded
      41             :             change list, and generates a single update action from
      42             :             that (note that per screen update, several moves,
      43             :             visibility changes and content updates might happen)
      44             :          */
      45           0 :         class SpriteTracer
      46             :         {
      47             :         public:
      48           0 :             SpriteTracer( const Sprite::Reference& rAffectedSprite ) :
      49             :                 mpAffectedSprite(rAffectedSprite),
      50             :                 maMoveStartArea(),
      51             :                 maMoveEndArea(),
      52             :                 mbIsMove( false ),
      53           0 :                 mbIsGenericUpdate( false )
      54             :             {
      55           0 :             }
      56             : 
      57           0 :             void operator()( const SpriteRedrawManager::SpriteChangeRecord& rSpriteRecord )
      58             :             {
      59             :                 // only deal with change events from the currently
      60             :                 // affected sprite
      61           0 :                 if( rSpriteRecord.mpAffectedSprite == mpAffectedSprite )
      62             :                 {
      63           0 :                     switch( rSpriteRecord.meChangeType )
      64             :                     {
      65             :                         case SpriteRedrawManager::SpriteChangeRecord::move:
      66           0 :                             if( !mbIsMove )
      67             :                             {
      68             :                                 // no move yet - this must be the first one
      69             :                                 maMoveStartArea = ::basegfx::B2DRectangle(
      70             :                                     rSpriteRecord.maOldPos,
      71           0 :                                     rSpriteRecord.maOldPos + rSpriteRecord.maUpdateArea.getRange() );
      72           0 :                                 mbIsMove        = true;
      73             :                             }
      74             : 
      75           0 :                             maMoveEndArea   = rSpriteRecord.maUpdateArea;
      76           0 :                             break;
      77             : 
      78             :                         case SpriteRedrawManager::SpriteChangeRecord::update:
      79             :                             // update end update area of the
      80             :                             // sprite. Thus, every update() action
      81             :                             // _after_ the last move will correctly
      82             :                             // update the final repaint area. And this
      83             :                             // does not interfere with subsequent
      84             :                             // moves, because moves always perform a
      85             :                             // hard set of maMoveEndArea to their
      86             :                             // stored value
      87           0 :                             maMoveEndArea.expand( rSpriteRecord.maUpdateArea );
      88           0 :                             mbIsGenericUpdate = true;
      89           0 :                             break;
      90             : 
      91             :                         default:
      92           0 :                             ENSURE_OR_THROW( false,
      93             :                                               "Unexpected case in SpriteUpdater::operator()" );
      94             :                             break;
      95             :                     }
      96             :                 }
      97           0 :             }
      98             : 
      99           0 :             void commit( SpriteRedrawManager::SpriteConnectedRanges& rUpdateCollector ) const
     100             :             {
     101           0 :                 if( mbIsMove )
     102             :                 {
     103           0 :                     if( !maMoveStartArea.isEmpty() ||
     104           0 :                         !maMoveEndArea.isEmpty() )
     105             :                     {
     106             :                         // if mbIsGenericUpdate is false, this is a
     107             :                         // pure move (i.e. no other update
     108             :                         // operations). Pass that information on to
     109             :                         // the SpriteInfo
     110           0 :                         const bool bIsPureMove( !mbIsGenericUpdate );
     111             : 
     112             :                         // ignore the case that start and end update
     113             :                         // area overlap - the b2dconnectedranges
     114             :                         // handle that, anyway. doing it this way
     115             :                         // ensures that we have both old and new area
     116             :                         // stored
     117             : 
     118             :                         // round all given range up to enclosing
     119             :                         // integer rectangle - since the whole thing
     120             :                         // here is about
     121             : 
     122             :                         // first, draw the new sprite position
     123             :                         rUpdateCollector.addRange(
     124           0 :                             ::basegfx::unotools::b2DSurroundingIntegerRangeFromB2DRange( maMoveEndArea ),
     125             :                             SpriteRedrawManager::SpriteInfo(
     126             :                                 mpAffectedSprite,
     127             :                                 maMoveEndArea,
     128             :                                 true,
     129           0 :                                 bIsPureMove ) );
     130             : 
     131             :                         // then, clear the old place (looks smoother
     132             :                         // this way)
     133             :                         rUpdateCollector.addRange(
     134           0 :                             ::basegfx::unotools::b2DSurroundingIntegerRangeFromB2DRange( maMoveStartArea ),
     135             :                             SpriteRedrawManager::SpriteInfo(
     136             :                                 Sprite::Reference(),
     137             :                                 maMoveStartArea,
     138             :                                 true,
     139           0 :                                 bIsPureMove ) );
     140             :                     }
     141             :                 }
     142           0 :                 else if( mbIsGenericUpdate &&
     143           0 :                          !maMoveEndArea.isEmpty() )
     144             :                 {
     145             :                     rUpdateCollector.addRange(
     146           0 :                         ::basegfx::unotools::b2DSurroundingIntegerRangeFromB2DRange( maMoveEndArea ),
     147             :                         SpriteRedrawManager::SpriteInfo(
     148             :                             mpAffectedSprite,
     149             :                             maMoveEndArea,
     150           0 :                             true ) );
     151             :                 }
     152           0 :             }
     153             : 
     154             :         private:
     155             :             Sprite::Reference       mpAffectedSprite;
     156             :             ::basegfx::B2DRectangle maMoveStartArea;
     157             :             ::basegfx::B2DRectangle maMoveEndArea;
     158             : 
     159             :             /// True, if at least one move was encountered
     160             :             bool                    mbIsMove;
     161             : 
     162             :             /// True, if at least one generic update was encountered
     163             :             bool                    mbIsGenericUpdate;
     164             :         };
     165             : 
     166             : 
     167             :         /** SpriteChecker functor, which for every sprite checks the
     168             :             given update vector for necessary screen updates
     169             :          */
     170             :         class SpriteUpdater
     171             :         {
     172             :         public:
     173             :             /** Generate update area list
     174             : 
     175             :                 @param rUpdater
     176             :                 Reference to an updater object, which will receive the
     177             :                 update areas.
     178             : 
     179             :                 @param rChangeContainer
     180             :                 Container with all sprite change requests
     181             : 
     182             :              */
     183           0 :             SpriteUpdater( SpriteRedrawManager::SpriteConnectedRanges&          rUpdater,
     184             :                            const SpriteRedrawManager::VectorOfChangeRecords&    rChangeContainer ) :
     185             :                 mrUpdater( rUpdater ),
     186           0 :                 mrChangeContainer( rChangeContainer )
     187             :             {
     188           0 :             }
     189             : 
     190             :             /** Call this method for every sprite on your screen
     191             : 
     192             :                 This method scans the change container, collecting all
     193             :                 update info for the given sprite into one or two
     194             :                 update operations, which in turn are inserted into the
     195             :                 connected ranges processor.
     196             : 
     197             :                 @param rSprite
     198             :                 Current sprite to collect update info for.
     199             :              */
     200           0 :             void operator()( const Sprite::Reference& rSprite )
     201             :             {
     202             :                 const SpriteTracer aSpriteTracer(
     203             :                     ::std::for_each( mrChangeContainer.begin(),
     204             :                                      mrChangeContainer.end(),
     205           0 :                                      SpriteTracer( rSprite ) ) );
     206             : 
     207           0 :                 aSpriteTracer.commit( mrUpdater );
     208           0 :             }
     209             : 
     210             :         private:
     211             :             SpriteRedrawManager::SpriteConnectedRanges&         mrUpdater;
     212             :             const SpriteRedrawManager::VectorOfChangeRecords&   mrChangeContainer;
     213             :         };
     214             :     }
     215             : 
     216           0 :     void SpriteRedrawManager::setupUpdateAreas( SpriteConnectedRanges& rUpdateAreas ) const
     217             :     {
     218             :         // TODO(T3): This is NOT thread safe at all. This only works
     219             :         // under the assumption that NOBODY changes ANYTHING
     220             :         // concurrently, while this method is on the stack. We should
     221             :         // really rework the canvas::Sprite interface, in such a way
     222             :         // that it dumps ALL its state with a single, atomic
     223             :         // call. Then, we store that state locally. This prolly goes
     224             :         // in line with the problem of having sprite state available
     225             :         // for the frame before the last frame; plus, it avoids
     226             :         // frequent locks of the object mutices
     227             :         SpriteWeakOrder aSpriteComparator;
     228             : 
     229             :         // put all sprites that have changed content into update areas
     230           0 :         ListOfSprites::const_iterator       aCurrSprite( maSprites.begin() );
     231           0 :         const ListOfSprites::const_iterator aEndSprite ( maSprites.end() );
     232           0 :         while( aCurrSprite != aEndSprite )
     233             :         {
     234           0 :             if( (*aCurrSprite)->isContentChanged() )
     235           0 :                 const_cast<SpriteRedrawManager*>(this)->updateSprite( *aCurrSprite,
     236           0 :                                                                       (*aCurrSprite)->getPosPixel(),
     237           0 :                                                                       (*aCurrSprite)->getUpdateArea() );
     238           0 :             ++aCurrSprite;
     239             :         }
     240             : 
     241             :         // sort sprites after prio
     242           0 :         VectorOfSprites aSortedSpriteVector;
     243             :         ::std::copy( maSprites.begin(),
     244             :                      maSprites.end(),
     245           0 :                      ::std::back_insert_iterator< VectorOfSprites >(aSortedSpriteVector) );
     246             :         ::std::sort( aSortedSpriteVector.begin(),
     247             :                      aSortedSpriteVector.end(),
     248           0 :                      aSpriteComparator );
     249             : 
     250             :         // extract all referenced sprites from the maChangeRecords
     251             :         // (copy sprites, make the list unique, regarding the
     252             :         // sprite pointer). This assumes that, until this scope
     253             :         // ends, nobody changes the maChangeRecords vector!
     254           0 :         VectorOfSprites aUpdatableSprites;
     255           0 :         VectorOfChangeRecords::const_iterator       aCurrRecord( maChangeRecords.begin() );
     256           0 :         const VectorOfChangeRecords::const_iterator aEndRecords( maChangeRecords.end() );
     257           0 :         while( aCurrRecord != aEndRecords )
     258             :         {
     259           0 :             const Sprite::Reference& rSprite( aCurrRecord->getSprite() );
     260           0 :             if( rSprite.is() )
     261           0 :                 aUpdatableSprites.push_back( rSprite );
     262           0 :             ++aCurrRecord;
     263           0 :         }
     264             : 
     265             :         ::std::sort( aUpdatableSprites.begin(),
     266             :                      aUpdatableSprites.end(),
     267           0 :                      aSpriteComparator );
     268             : 
     269             :         VectorOfSprites::iterator aEnd=
     270             :             ::std::unique( aUpdatableSprites.begin(),
     271           0 :                            aUpdatableSprites.end() );
     272             : 
     273             :         // for each unique sprite, check the change event vector,
     274             :         // calculate the update operation from that, and add the
     275             :         // result to the aUpdateArea.
     276             :         ::std::for_each( aUpdatableSprites.begin(),
     277             :                          aEnd,
     278             :                          SpriteUpdater( rUpdateAreas,
     279           0 :                                         maChangeRecords) );
     280             : 
     281             :         // TODO(P2): Implement your own output iterator adapter, to
     282             :         // avoid that totally superfluous temp aUnchangedSprites
     283             :         // vector.
     284             : 
     285             :         // add all sprites to rUpdateAreas, that are _not_ already
     286             :         // contained in the uniquified vector of changed ones
     287             :         // (i.e. the difference between aSortedSpriteVector and
     288             :         // aUpdatableSprites).
     289           0 :         VectorOfSprites aUnchangedSprites;
     290             :         ::std::set_difference( aSortedSpriteVector.begin(),
     291             :                                aSortedSpriteVector.end(),
     292             :                                aUpdatableSprites.begin(),
     293             :                                aEnd,
     294             :                                ::std::back_insert_iterator< VectorOfSprites >(aUnchangedSprites),
     295           0 :                                aSpriteComparator );
     296             : 
     297             :         // add each remaining unchanged sprite to connected ranges,
     298             :         // marked as "don't need update"
     299           0 :         VectorOfSprites::const_iterator         aCurr( aUnchangedSprites.begin() );
     300           0 :         const VectorOfSprites::const_iterator   aEnd2( aUnchangedSprites.end() );
     301           0 :         while( aCurr != aEnd2 )
     302             :         {
     303           0 :             const ::basegfx::B2DRange& rUpdateArea( (*aCurr)->getUpdateArea() );
     304             :             rUpdateAreas.addRange(
     305             :                 ::basegfx::unotools::b2DSurroundingIntegerRangeFromB2DRange( rUpdateArea ),
     306           0 :                 SpriteInfo(*aCurr,
     307             :                            rUpdateArea,
     308           0 :                            false) );
     309           0 :             ++aCurr;
     310           0 :         }
     311           0 :     }
     312             : 
     313             : #if OSL_DEBUG_LEVEL > 0
     314             :     bool impIsEqualB2DRange(const basegfx::B2DRange& rRangeA, const basegfx::B2DRange& rRangeB, double fSmallValue)
     315             :     {
     316             :         return fabs(rRangeB.getMinX() - rRangeA.getMinX()) <= fSmallValue
     317             :             && fabs(rRangeB.getMinY() - rRangeA.getMinY()) <= fSmallValue
     318             :             && fabs(rRangeB.getMaxX() - rRangeA.getMaxX()) <= fSmallValue
     319             :             && fabs(rRangeB.getMaxY() - rRangeA.getMaxY()) <= fSmallValue;
     320             :     }
     321             : 
     322             :     bool impIsEqualB2DVector(const basegfx::B2DVector& rVecA, const basegfx::B2DVector& rVecB, double fSmallValue)
     323             :     {
     324             :         return fabs(rVecB.getX() - rVecA.getX()) <= fSmallValue
     325             :             && fabs(rVecB.getY() - rVecA.getY()) <= fSmallValue;
     326             :     }
     327             : #endif
     328             : 
     329           0 :     bool SpriteRedrawManager::isAreaUpdateScroll( ::basegfx::B2DRectangle&  o_rMoveStart,
     330             :                                                   ::basegfx::B2DRectangle&  o_rMoveEnd,
     331             :                                                   const UpdateArea&         rUpdateArea,
     332             :                                                   ::std::size_t             nNumSprites ) const
     333             :     {
     334             :         // check for a solitary move, which consists of exactly two
     335             :         // pure-move entries, the first with valid, the second with
     336             :         // invalid sprite (see SpriteTracer::commit()).  Note that we
     337             :         // cannot simply store some flag in SpriteTracer::commit()
     338             :         // above and just check that here, since during the connected
     339             :         // range calculations, other sprites might get merged into the
     340             :         // same region (thus spoiling the scrolling move
     341             :         // optimization).
     342           0 :         if( nNumSprites != 2 )
     343           0 :             return false;
     344             : 
     345             :         const SpriteConnectedRanges::ComponentListType::const_iterator aFirst(
     346           0 :             rUpdateArea.maComponentList.begin() );
     347             :         SpriteConnectedRanges::ComponentListType::const_iterator aSecond(
     348           0 :             aFirst ); ++aSecond;
     349             : 
     350           0 :         if( !aFirst->second.isPureMove() ||
     351           0 :             !aSecond->second.isPureMove() ||
     352           0 :             !aFirst->second.getSprite().is() ||
     353             :             // use _true_ update area, not the rounded version
     354           0 :             !aFirst->second.getSprite()->isAreaUpdateOpaque( aFirst->second.getUpdateArea() ) ||
     355           0 :             aSecond->second.getSprite().is() )
     356             :         {
     357             :             // either no move update, or incorrect sprite, or sprite
     358             :             // content not fully opaque over update region.
     359           0 :             return false;
     360             :         }
     361             : 
     362           0 :         o_rMoveStart      = aSecond->second.getUpdateArea();
     363           0 :         o_rMoveEnd        = aFirst->second.getUpdateArea();
     364             : 
     365             : #if OSL_DEBUG_LEVEL > 0
     366             :         ::basegfx::B2DRectangle aTotalBounds( o_rMoveStart );
     367             :         aTotalBounds.expand( o_rMoveEnd );
     368             : 
     369             :         SAL_WARN_IF(!impIsEqualB2DRange(rUpdateArea.maTotalBounds, basegfx::unotools::b2DSurroundingIntegerRangeFromB2DRange(aTotalBounds), 0.5),
     370             :             "canvas",
     371             :             "SpriteRedrawManager::isAreaUpdateScroll(): sprite area and total area mismatch");
     372             :         SAL_WARN_IF(!impIsEqualB2DVector(o_rMoveStart.getRange(), o_rMoveEnd.getRange(), 0.5),
     373             :             "canvas",
     374             :             "SpriteRedrawManager::isAreaUpdateScroll(): scroll start and end area have mismatching size");
     375             : #endif
     376             : 
     377           0 :         return true;
     378             :     }
     379             : 
     380           0 :     bool SpriteRedrawManager::isAreaUpdateNotOpaque( const ::basegfx::B2DRectangle& rUpdateRect,
     381             :                                                      const AreaComponent&           rComponent ) const
     382             :     {
     383           0 :         const Sprite::Reference& pAffectedSprite( rComponent.second.getSprite() );
     384             : 
     385           0 :         if( !pAffectedSprite.is() )
     386           0 :             return true; // no sprite, no opaque update!
     387             : 
     388           0 :         return !pAffectedSprite->isAreaUpdateOpaque( rUpdateRect );
     389             :     }
     390             : 
     391           0 :     bool SpriteRedrawManager::isAreaUpdateOpaque( const UpdateArea& rUpdateArea,
     392             :                                                   ::std::size_t     nNumSprites ) const
     393             :     {
     394             :         // check whether the sprites in the update area's list will
     395             :         // fully cover the given area _and_ do that in an opaque way
     396             :         // (i.e. no alpha, no non-rectangular sprite content).
     397             : 
     398             :         // TODO(P1): Come up with a smarter early-exit criterion here
     399             :         // (though, I think, the case that _lots_ of sprites _fully_
     400             :         // cover a rectangular area _without_ any holes is extremely
     401             :         // improbable)
     402             : 
     403             :         // avoid checking large number of sprites (and probably fail,
     404             :         // anyway). Note: the case nNumSprites < 1 should normally not
     405             :         // happen, as handleArea() calls backgroundPaint() then.
     406           0 :         if( nNumSprites > 3 || nNumSprites < 1 )
     407           0 :             return false;
     408             : 
     409             :         // now, calc the _true_ update area, by merging all sprite's
     410             :         // true update areas into one rectangle
     411           0 :         ::basegfx::B2DRange aTrueArea( rUpdateArea.maComponentList.begin()->second.getUpdateArea() );
     412             :         ::std::for_each( rUpdateArea.maComponentList.begin(),
     413             :                          rUpdateArea.maComponentList.end(),
     414             :                          ::boost::bind( (void (basegfx::B2DRange::*)(const basegfx::B2DRange&))(
     415             :                                             &basegfx::B2DRange::expand),
     416             :                                         aTrueArea,
     417             :                                         ::boost::bind( &SpriteInfo::getUpdateArea,
     418             :                                                        ::boost::bind( ::o3tl::select2nd<AreaComponent>(),
     419           0 :                                                                       _1 ) ) ) );
     420             : 
     421             :         const SpriteConnectedRanges::ComponentListType::const_iterator aEnd(
     422           0 :             rUpdateArea.maComponentList.end() );
     423             : 
     424             :         // and check whether _any_ of the sprites tells that its area
     425             :         // update will not be opaque.
     426             :         return (::std::find_if( rUpdateArea.maComponentList.begin(),
     427             :                                 aEnd,
     428             :                                 ::boost::bind( &SpriteRedrawManager::isAreaUpdateNotOpaque,
     429             :                                                this,
     430             :                                                ::boost::cref(aTrueArea),
     431           0 :                                                _1 ) ) == aEnd );
     432             :     }
     433             : 
     434           0 :     bool SpriteRedrawManager::areSpritesChanged( const UpdateArea& rUpdateArea ) const
     435             :     {
     436             :         // check whether SpriteInfo::needsUpdate returns false for
     437             :         // all elements of this area's contained sprites
     438             : 
     439             :         // if not a single changed sprite found - just ignore this
     440             :         // component (return false)
     441             :         const SpriteConnectedRanges::ComponentListType::const_iterator aEnd(
     442           0 :             rUpdateArea.maComponentList.end() );
     443             :         return (::std::find_if( rUpdateArea.maComponentList.begin(),
     444             :                                 aEnd,
     445             :                                 ::boost::bind( &SpriteInfo::needsUpdate,
     446             :                                                ::boost::bind(
     447             :                                                    ::o3tl::select2nd<SpriteConnectedRanges::ComponentType>(),
     448           0 :                                                    _1 ) ) ) != aEnd );
     449             :     }
     450             : 
     451           0 :     SpriteRedrawManager::SpriteRedrawManager() :
     452             :         maSprites(),
     453           0 :         maChangeRecords()
     454             :     {
     455           0 :     }
     456             : 
     457           0 :     void SpriteRedrawManager::disposing()
     458             :     {
     459             :         // drop all references
     460           0 :         maChangeRecords.clear();
     461             : 
     462             :         // dispose all sprites - the spritecanvas, and by delegation,
     463             :         // this object, is the owner of the sprites. After all, a
     464             :         // sprite without a canvas to render into makes not terribly
     465             :         // much sense.
     466             : 
     467             :         // TODO(Q3): Once boost 1.33 is in, change back to for_each
     468             :         // with ::boost::mem_fn. For the time being, explicit loop due
     469             :         // to cdecl declaration of all UNO methods.
     470           0 :         ListOfSprites::reverse_iterator aCurr( maSprites.rbegin() );
     471           0 :         ListOfSprites::reverse_iterator aEnd( maSprites.rend() );
     472           0 :         while( aCurr != aEnd )
     473           0 :             (*aCurr++)->dispose();
     474             : 
     475           0 :         maSprites.clear();
     476           0 :     }
     477             : 
     478           0 :     void SpriteRedrawManager::clearChangeRecords()
     479             :     {
     480           0 :         maChangeRecords.clear();
     481           0 :     }
     482             : 
     483           0 :     void SpriteRedrawManager::showSprite( const Sprite::Reference& rSprite )
     484             :     {
     485           0 :         maSprites.push_back( rSprite );
     486           0 :     }
     487             : 
     488           0 :     void SpriteRedrawManager::hideSprite( const Sprite::Reference& rSprite )
     489             :     {
     490           0 :         maSprites.remove( rSprite );
     491           0 :     }
     492             : 
     493           0 :     void SpriteRedrawManager::moveSprite( const Sprite::Reference&      rSprite,
     494             :                                           const ::basegfx::B2DPoint&    rOldPos,
     495             :                                           const ::basegfx::B2DPoint&    rNewPos,
     496             :                                           const ::basegfx::B2DVector&   rSpriteSize )
     497             :     {
     498             :         maChangeRecords.push_back( SpriteChangeRecord( rSprite,
     499             :                                                        rOldPos,
     500             :                                                        rNewPos,
     501           0 :                                                        rSpriteSize ) );
     502           0 :     }
     503             : 
     504           0 :     void SpriteRedrawManager::updateSprite( const Sprite::Reference&    rSprite,
     505             :                                             const ::basegfx::B2DPoint&  rPos,
     506             :                                             const ::basegfx::B2DRange&  rUpdateArea )
     507             :     {
     508             :         maChangeRecords.push_back( SpriteChangeRecord( rSprite,
     509             :                                                        rPos,
     510           0 :                                                        rUpdateArea ) );
     511           0 :     }
     512             : 
     513        1143 : }
     514             : 
     515             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10