LCOV - code coverage report
Current view: top level - usr/local/src/libreoffice/include/svtools - grfmgr.hxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 46 59 78.0 %
Date: 2013-07-09 Functions: 39 52 75.0 %
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             : #ifndef _GRFMGR_HXX
      21             : #define _GRFMGR_HXX
      22             : 
      23             : #include <vcl/graph.hxx>
      24             : #include <svtools/svtdllapi.h>
      25             : 
      26             : #define GRFMGR_DRAW_NOTCACHED               0x00000000UL
      27             : #define GRFMGR_DRAW_CACHED                  0x00000001UL
      28             : #define GRFMGR_DRAW_SMOOTHSCALE             0x00000002UL
      29             : #define GRFMGR_DRAW_USE_DRAWMODE_SETTINGS   0x00000004UL
      30             : #define GRFMGR_DRAW_SUBSTITUTE              0x00000008UL
      31             : #define GRFMGR_DRAW_NO_SUBSTITUTE           0x00000010UL
      32             : #define GRFMGR_DRAW_STANDARD                (GRFMGR_DRAW_CACHED|GRFMGR_DRAW_SMOOTHSCALE)
      33             : 
      34             : // AutoSwap defines
      35             : 
      36             : #define GRFMGR_AUTOSWAPSTREAM_LINK      ((SvStream*)0x00000000UL)
      37             : #define GRFMGR_AUTOSWAPSTREAM_LOADED    ((SvStream*)0xfffffffdUL)
      38             : #define GRFMGR_AUTOSWAPSTREAM_TEMP      ((SvStream*)0xfffffffeUL)
      39             : #define GRFMGR_AUTOSWAPSTREAM_NONE      ((SvStream*)0xffffffffUL)
      40             : 
      41             : // Adjustment defines
      42             : 
      43             : #define ADJUSTMENT_NONE                 0x00000000UL
      44             : #define ADJUSTMENT_DRAWMODE             0x00000001UL
      45             : #define ADJUSTMENT_COLORS               0x00000002UL
      46             : #define ADJUSTMENT_MIRROR               0x00000004UL
      47             : #define ADJUSTMENT_ROTATE               0x00000008UL
      48             : #define ADJUSTMENT_TRANSPARENCY         0x00000010UL
      49             : #define ADJUSTMENT_ALL                  0xFFFFFFFFUL
      50             : 
      51             : enum GraphicDrawMode
      52             : {
      53             :     GRAPHICDRAWMODE_STANDARD = 0,
      54             :     GRAPHICDRAWMODE_GREYS = 1,
      55             :     GRAPHICDRAWMODE_MONO = 2,
      56             :     GRAPHICDRAWMODE_WATERMARK = 3
      57             : };
      58             : 
      59             : class GraphicManager;
      60             : class SvStream;
      61             : class BitmapWriteAccess;
      62             : class GraphicCache;
      63             : class VirtualDevice;
      64             : struct GrfSimpleCacheObj;
      65             : struct ImplTileInfo;
      66             : 
      67             : class SVT_DLLPUBLIC GraphicAttr
      68             : {
      69             : private:
      70             : 
      71             :     double          mfGamma;
      72             :     sal_uInt32      mnMirrFlags;
      73             :     long            mnLeftCrop;
      74             :     long            mnTopCrop;
      75             :     long            mnRightCrop;
      76             :     long            mnBottomCrop;
      77             :     sal_uInt16      mnRotate10;
      78             :     short           mnContPercent;
      79             :     short           mnLumPercent;
      80             :     short           mnRPercent;
      81             :     short           mnGPercent;
      82             :     short           mnBPercent;
      83             :     sal_Bool        mbInvert;
      84             :     sal_uInt8       mcTransparency;
      85             :     GraphicDrawMode meDrawMode;
      86             : 
      87             : public:
      88             : 
      89             :                     GraphicAttr();
      90             :                     ~GraphicAttr();
      91             : 
      92             :     sal_Bool        operator==( const GraphicAttr& rAttr ) const;
      93           0 :     sal_Bool        operator!=( const GraphicAttr& rAttr ) const { return !( *this == rAttr ); }
      94             : 
      95         480 :     void            SetDrawMode( GraphicDrawMode eDrawMode ) { meDrawMode = eDrawMode; }
      96           0 :     GraphicDrawMode GetDrawMode() const { return meDrawMode; }
      97             : 
      98          57 :     void            SetMirrorFlags( sal_uLong nMirrFlags ) { mnMirrFlags = nMirrFlags; }
      99           4 :     sal_uLong       GetMirrorFlags() const { return mnMirrFlags; }
     100             : 
     101         498 :     void            SetCrop( long nLeft_100TH_MM, long nTop_100TH_MM, long nRight_100TH_MM, long nBottom_100TH_MM )
     102             :                     {
     103         498 :                         mnLeftCrop = nLeft_100TH_MM; mnTopCrop = nTop_100TH_MM;
     104         498 :                         mnRightCrop = nRight_100TH_MM; mnBottomCrop = nBottom_100TH_MM;
     105         498 :                     }
     106           2 :     long            GetLeftCrop() const { return mnLeftCrop; }
     107           2 :     long            GetTopCrop() const { return mnTopCrop; }
     108           2 :     long            GetRightCrop() const { return mnRightCrop; }
     109           2 :     long            GetBottomCrop() const { return mnBottomCrop; }
     110             : 
     111         133 :     void            SetRotation( sal_uInt16 nRotate10 ) { mnRotate10 = nRotate10; }
     112           3 :     sal_uInt16      GetRotation() const { return mnRotate10; }
     113             : 
     114         480 :     void            SetLuminance( short nLuminancePercent ) { mnLumPercent = nLuminancePercent; }
     115           0 :     short           GetLuminance() const { return mnLumPercent; }
     116             : 
     117         480 :     void            SetContrast( short nContrastPercent ) { mnContPercent = nContrastPercent; }
     118           0 :     short           GetContrast() const { return mnContPercent; }
     119             : 
     120         480 :     void            SetChannelR( short nChannelRPercent ) { mnRPercent = nChannelRPercent; }
     121           0 :     short           GetChannelR() const { return mnRPercent; }
     122             : 
     123         480 :     void            SetChannelG( short nChannelGPercent ) { mnGPercent = nChannelGPercent; }
     124           0 :     short           GetChannelG() const { return mnGPercent; }
     125             : 
     126         480 :     void            SetChannelB( short nChannelBPercent ) { mnBPercent = nChannelBPercent; }
     127           0 :     short           GetChannelB() const { return mnBPercent; }
     128             : 
     129         480 :     void            SetGamma( double fGamma ) { mfGamma = fGamma; }
     130           0 :     double          GetGamma() const { return mfGamma; }
     131             : 
     132         480 :     void            SetInvert( sal_Bool bInvert ) { mbInvert = bInvert; }
     133           0 :     sal_Bool        IsInvert() const { return mbInvert; }
     134             : 
     135         491 :     void            SetTransparency( sal_uInt8 cTransparency ) { mcTransparency = cTransparency; }
     136         152 :     sal_uInt8       GetTransparency() const { return mcTransparency; }
     137             : 
     138          32 :     sal_Bool        IsSpecialDrawMode() const { return( meDrawMode != GRAPHICDRAWMODE_STANDARD ); }
     139          49 :     sal_Bool        IsMirrored() const { return( mnMirrFlags != 0UL ); }
     140          33 :     sal_Bool        IsCropped() const
     141             :                     {
     142          95 :                         return( mnLeftCrop != 0 || mnTopCrop != 0 ||
     143          95 :                                 mnRightCrop != 0 || mnBottomCrop != 0 );
     144             :                     }
     145          31 :     sal_Bool        IsRotated() const { return( ( mnRotate10 % 3600 ) != 0 ); }
     146          33 :     sal_Bool        IsTransparent() const { return( mcTransparency > 0 ); }
     147          32 :     sal_Bool        IsAdjusted() const
     148             :                     {
     149          96 :                         return( mnLumPercent != 0 || mnContPercent != 0 || mnRPercent != 0 ||
     150          96 :                                 mnGPercent != 0 || mnBPercent != 0 || mfGamma != 1.0 || mbInvert );
     151             :                     }
     152             : 
     153             :     friend SvStream& operator<<( SvStream& rOStm, const GraphicAttr& rAttr );
     154             :     friend SvStream& operator>>( SvStream& rIStm, GraphicAttr& rAttr );
     155             : };
     156             : 
     157             : class SVT_DLLPUBLIC GraphicObject : public SvDataCopyStream
     158             : {
     159             :     friend class GraphicManager;
     160             : 
     161             : private:
     162             : 
     163             :     static GraphicManager*  mpGlobalMgr;
     164             : 
     165             :     Graphic                 maGraphic;
     166             :     GraphicAttr             maAttr;
     167             :     Size                    maPrefSize;
     168             :     MapMode                 maPrefMapMode;
     169             :     sal_uLong               mnSizeBytes;
     170             :     GraphicType             meType;
     171             :     GraphicManager*         mpMgr;
     172             :     String*                 mpLink;
     173             :     Link*                   mpSwapStreamHdl;
     174             :     String*                 mpUserData;
     175             :     Timer*                  mpSwapOutTimer;
     176             :     GrfSimpleCacheObj*      mpSimpleCache;
     177             :     sal_uLong               mnAnimationLoopCount;
     178             :     sal_Bool                mbAutoSwapped   : 1;
     179             :     sal_Bool                mbTransparent   : 1;
     180             :     sal_Bool                mbAnimated      : 1;
     181             :     sal_Bool                mbEPS           : 1;
     182             :     sal_Bool                mbIsInSwapIn    : 1;
     183             :     sal_Bool                mbIsInSwapOut   : 1;
     184             :     sal_Bool                mbAlpha         : 1;
     185             : 
     186             :     void                    SVT_DLLPRIVATE ImplConstruct();
     187             :     void                    SVT_DLLPRIVATE ImplAssignGraphicData();
     188             :     void                    SVT_DLLPRIVATE ImplSetGraphicManager(
     189             :                                 const GraphicManager* pMgr,
     190             :                                 const OString* pID = NULL,
     191             :                                 const GraphicObject* pCopyObj = NULL
     192             :                             );
     193             :     void                    SVT_DLLPRIVATE ImplAutoSwapIn();
     194             :     sal_Bool                SVT_DLLPRIVATE ImplIsAutoSwapped() const { return mbAutoSwapped; }
     195             :     sal_Bool                SVT_DLLPRIVATE ImplGetCropParams(
     196             :                                 OutputDevice* pOut,
     197             :                                 Point& rPt,
     198             :                                 Size& rSz,
     199             :                                 const GraphicAttr* pAttr,
     200             :                                 PolyPolygon& rClipPolyPoly,
     201             :                                 sal_Bool& bRectClipRegion
     202             :                             ) const;
     203             : 
     204             :     /** Render a given number of tiles in an optimized way
     205             : 
     206             :         This method recursively subdivides the tile rendering problem
     207             :         in smaller parts, i.e. rendering output size x with few tiles
     208             :         of size y, which in turn are generated from the original
     209             :         bitmap in a recursive fashion. The subdivision size can be
     210             :         controlled by the exponent argument, which specifies the
     211             :         minimal number of smaller tiles used in one recursion
     212             :         step. The resulting tile size is given as the integer number
     213             :         of repetitions of the original bitmap along x and y. As the
     214             :         exponent need not necessarily divide these numbers without
     215             :         remainder, the repetition counts are effectively converted to
     216             :         base-exponent numbers, where each place denotes the number of
     217             :         times the corresponding tile size is rendered.
     218             : 
     219             :         @param rVDev
     220             :         Virtual device to render everything into
     221             : 
     222             :         @param nExponent
     223             :         Number of repetitions per subdivision step, _must_ be greater than 1
     224             : 
     225             :         @param nNumTilesX
     226             :         Number of original tiles to generate in x direction
     227             : 
     228             :         @param nNumTilesY
     229             :         Number of original tiles to generate in y direction
     230             : 
     231             :         @param rTileSizePixel
     232             :         Size in pixel of the original tile bitmap to render it in
     233             : 
     234             :         @param pAttr
     235             :         Graphic attributes to be used for rendering
     236             : 
     237             :         @param nFlags
     238             :         Graphic flags to be used for rendering
     239             : 
     240             :         @param rCurrPos
     241             :         Current output point for this recursion level (should start with (0,0))
     242             : 
     243             :         @return true, if everything was successfully rendered.
     244             :     */
     245             :     bool SVT_DLLPRIVATE     ImplRenderTempTile(
     246             :                                 VirtualDevice& rVDev,
     247             :                                 int nExponent,
     248             :                                 int nNumTilesX,
     249             :                                 int nNumTilesY,
     250             :                                 const Size& rTileSizePixel,
     251             :                                 const GraphicAttr* pAttr,
     252             :                                 sal_uLong nFlags
     253             :                             );
     254             : 
     255             :     /// internally called by ImplRenderTempTile()
     256             :     bool SVT_DLLPRIVATE     ImplRenderTileRecursive(
     257             :                                 VirtualDevice& rVDev,
     258             :                                 int nExponent,
     259             :                                 int nMSBFactor,
     260             :                                 int nNumOrigTilesX,
     261             :                                 int nNumOrigTilesY,
     262             :                                 int nRemainderTilesX,
     263             :                                 int nRemainderTilesY,
     264             :                                 const Size& rTileSizePixel,
     265             :                                 const GraphicAttr* pAttr,
     266             :                                 sal_uLong nFlags,
     267             :                                 ImplTileInfo& rTileInfo
     268             :                             );
     269             : 
     270             :     bool SVT_DLLPRIVATE     ImplDrawTiled(
     271             :                                 OutputDevice* pOut,
     272             :                                 const Rectangle& rArea,
     273             :                                 const Size& rSizePixel,
     274             :                                 const Size& rOffset,
     275             :                                 const GraphicAttr* pAttr,
     276             :                                 sal_uLong nFlags,
     277             :                                 int nTileCacheSize1D
     278             :                             );
     279             : 
     280             :     bool SVT_DLLPRIVATE     ImplDrawTiled(
     281             :                                 OutputDevice& rOut,
     282             :                                 const Point& rPos,
     283             :                                 int nNumTilesX,
     284             :                                 int nNumTilesY,
     285             :                                 const Size& rTileSize,
     286             :                                 const GraphicAttr* pAttr,
     287             :                                 sal_uLong nFlags
     288             :                             );
     289             : 
     290             :     void SVT_DLLPRIVATE     ImplTransformBitmap(
     291             :                                 BitmapEx&           rBmpEx,
     292             :                                 const GraphicAttr&  rAttr,
     293             :                                 const Size&         rCropLeftTop,
     294             :                                 const Size&         rCropRightBottom,
     295             :                                 const Rectangle&    rCropRect,
     296             :                                 const Size&         rDstSize,
     297             :                                 sal_Bool            bEnlarge
     298             :                             ) const;
     299             : 
     300             :                             DECL_LINK( ImplAutoSwapOutHdl, void* );
     301             : 
     302             : protected:
     303             : 
     304             :     virtual void            GraphicManagerDestroyed();
     305             :     virtual SvStream*       GetSwapStream() const;
     306             : 
     307             :     virtual void            Load( SvStream& );
     308             :     virtual void            Save( SvStream& );
     309             :     virtual void            Assign( const SvDataCopyStream& );
     310             : 
     311             : public:
     312             : 
     313             :                             TYPEINFO();
     314             : 
     315             :                             GraphicObject( const GraphicManager* pMgr = NULL );
     316             :                             GraphicObject( const Graphic& rGraphic, const GraphicManager* pMgr = NULL );
     317             :                             GraphicObject( const GraphicObject& rCacheObj, const GraphicManager* pMgr = NULL );
     318             :                             explicit GraphicObject( const OString& rUniqueID, const GraphicManager* pMgr = NULL );
     319             :                             ~GraphicObject();
     320             : 
     321             :     GraphicObject&          operator=( const GraphicObject& rCacheObj );
     322             :     sal_Bool                operator==( const GraphicObject& rCacheObj ) const;
     323           0 :     sal_Bool                operator!=( const GraphicObject& rCacheObj ) const { return !( *this == rCacheObj ); }
     324             : 
     325          62 :     sal_Bool                HasSwapStreamHdl() const { return( mpSwapStreamHdl != NULL && mpSwapStreamHdl->IsSet() ); }
     326             :     void                    SetSwapStreamHdl();
     327             :     void                    SetSwapStreamHdl( const Link& rHdl, const sal_uLong nSwapOutTimeout = 0UL );
     328             :     sal_uLong               GetSwapOutTimeout() const { return( mpSwapOutTimer ? mpSwapOutTimer->GetTimeout() : 0 ); }
     329             : 
     330             :     void                    FireSwapInRequest();
     331             :     void                    FireSwapOutRequest();
     332             : 
     333           0 :     GraphicManager&         GetGraphicManager() const { return *mpMgr; }
     334             : 
     335             :     sal_Bool                IsCached(
     336             :                                 OutputDevice* pOut,
     337             :                                 const Point& rPt,
     338             :                                 const Size& rSz,
     339             :                                 const GraphicAttr* pAttr = NULL,
     340             :                                 sal_uLong nFlags = GRFMGR_DRAW_STANDARD
     341             :                             ) const;
     342             :     void                    ReleaseFromCache();
     343             : 
     344             :     const Graphic&          GetGraphic() const;
     345             :     void                    SetGraphic( const Graphic& rGraphic, const GraphicObject* pCopyObj = 0);
     346             :     void                    SetGraphic( const Graphic& rGraphic, const String& rLink );
     347             : 
     348             :     /** Get graphic transformed according to given attributes
     349             : 
     350             :         This method returns a Graphic transformed, cropped and scaled
     351             :         to the given parameters, ready to be rendered to printer or
     352             :         display. The returned graphic has the same visual appearance
     353             :         as if it had been drawn via GraphicObject::Draw() to a
     354             :         specific output device.
     355             : 
     356             :         @param rDestSize
     357             :         Desired output size in logical coordinates. The mapmode to
     358             :         interpret these logical coordinates in is given by the second
     359             :         parameter, rDestMap.
     360             : 
     361             :         @param rDestMap
     362             :         Mapmode the output should be interpreted in. This is used to
     363             :         interpret rDestSize, to set the appropriate PrefMapMode on the
     364             :         returned Graphic, and to deal correctly with metafile graphics.
     365             : 
     366             :         @param rAttr
     367             :         Graphic attributes used to transform the graphic. This
     368             :         includes cropping, rotation, mirroring, and various color
     369             :         adjustment parameters.
     370             : 
     371             :         @return the readily transformed Graphic
     372             :      */
     373             :     Graphic                 GetTransformedGraphic(
     374             :                                 const Size& rDestSize,
     375             :                                 const MapMode& rDestMap,
     376             :                                 const GraphicAttr& rAttr
     377             :                             ) const;
     378             :     Graphic                 GetTransformedGraphic( const GraphicAttr* pAttr = NULL ) const; // TODO: Change to Impl
     379             : 
     380             :     void                    SetAttr( const GraphicAttr& rAttr );
     381          24 :     const GraphicAttr&      GetAttr() const { return maAttr; }
     382             : 
     383           0 :     sal_Bool                HasLink() const { return( mpLink != NULL && mpLink->Len() > 0 ); }
     384             :     void                    SetLink();
     385             :     void                    SetLink( const String& rLink );
     386             :     String                  GetLink() const;
     387             : 
     388         190 :     sal_Bool                HasUserData() const { return( mpUserData != NULL && mpUserData->Len() > 0 ); }
     389             :     void                    SetUserData();
     390             :     void                    SetUserData( const String& rUserData );
     391             :     String                  GetUserData() const;
     392             : 
     393             :     OString            GetUniqueID() const;
     394             : 
     395        6820 :     GraphicType             GetType() const { return meType; }
     396           2 :     const Size&             GetPrefSize() const { return maPrefSize; }
     397           2 :     const MapMode&          GetPrefMapMode() const { return maPrefMapMode; }
     398          59 :     sal_uLong               GetSizeBytes() const { return mnSizeBytes; }
     399         247 :     sal_Bool                IsTransparent() const { return mbTransparent; }
     400             :     sal_Bool                IsAlpha() const { return mbAlpha; }
     401         216 :     sal_Bool                IsAnimated() const { return mbAnimated; }
     402         444 :     sal_Bool                IsEPS() const { return mbEPS; }
     403             : 
     404           0 :     Link                    GetAnimationNotifyHdl() const { return maGraphic.GetAnimationNotifyHdl(); }
     405             : 
     406             :     sal_Bool                SwapOut();
     407             :     sal_Bool                SwapOut( SvStream* pOStm );
     408             :     sal_Bool                SwapIn();
     409             : 
     410         444 :     sal_Bool                IsInSwapIn() const { return mbIsInSwapIn; }
     411          62 :     sal_Bool                IsInSwapOut() const { return mbIsInSwapOut; }
     412             :     sal_Bool                IsInSwap() const { return( mbIsInSwapOut || mbIsInSwapOut ); }
     413        9004 :     sal_Bool                IsSwappedOut() const { return( mbAutoSwapped || maGraphic.IsSwapOut() ); }
     414             :     void                    SetSwapState();
     415             : 
     416             :     bool                    Draw(
     417             :                                 OutputDevice* pOut,
     418             :                                 const Point& rPt,
     419             :                                 const Size& rSz,
     420             :                                 const GraphicAttr* pAttr = NULL,
     421             :                                 sal_uLong nFlags = GRFMGR_DRAW_STANDARD
     422             :                             );
     423             : 
     424             :     sal_Bool                DrawWithPDFHandling(
     425             :                                 OutputDevice& rOutDev,
     426             :                                 const Point& rPt,
     427             :                                 const Size& rSz,
     428             :                                 const GraphicAttr* pGrfAttr = NULL,
     429             :                                 const sal_uLong nFlags = GRFMGR_DRAW_STANDARD
     430             :                             );
     431             : 
     432             :     /** Draw the graphic repeatedly into the given output rectangle
     433             : 
     434             :         @param pOut
     435             :         OutputDevice where the rendering should take place
     436             : 
     437             :         @param rArea
     438             :         The output area that is filled with tiled instances of this graphic
     439             : 
     440             :         @param rSize
     441             :         The actual size of a single tile
     442             : 
     443             :         @param rOffset
     444             :         Offset from the left, top position of rArea, where to start
     445             :         the tiling. The upper left corner of the graphic tilings will
     446             :         virtually start at this position. Concretely, only that many
     447             :         tiles are drawn to completely fill the given output area.
     448             : 
     449             :         @param pAttr
     450             :         Optional GraphicAttr
     451             : 
     452             :         @param nFlags
     453             :         Optional rendering flags
     454             : 
     455             :         @param nTileCacheSize1D
     456             :         Optional dimension of the generated cache tiles. The pOut sees
     457             :         a number of tile draws, which have approximately
     458             :         nTileCacheSize1D times nTileCacheSize1D bitmap sizes if the
     459             :         tile bitmap is smaller. Otherwise, the tile is drawn as
     460             :         is. This is useful if e.g. you want only a few, very large
     461             :         bitmap drawings appear on the outdev.
     462             : 
     463             :         @return sal_True, if drawing completed successfully
     464             :      */
     465             :     sal_Bool                DrawTiled(
     466             :                                 OutputDevice* pOut,
     467             :                                 const Rectangle& rArea,
     468             :                                 const Size& rSize,
     469             :                                 const Size& rOffset,
     470             :                                 const GraphicAttr* pAttr = NULL,
     471             :                                 sal_uLong nFlags = GRFMGR_DRAW_STANDARD,
     472             :                                 int nTileCacheSize1D=128
     473             :                             );
     474             : 
     475             :     sal_Bool                StartAnimation(
     476             :                                 OutputDevice* pOut,
     477             :                                 const Point& rPt,
     478             :                                 const Size& rSz,
     479             :                                 long nExtraData = 0L,
     480             :                                 const GraphicAttr* pAttr = NULL,
     481             :                                 sal_uLong nFlags = GRFMGR_DRAW_STANDARD,
     482             :                                 OutputDevice* pFirstFrameOutDev = NULL
     483             :                             );
     484             : 
     485             :     void                    StopAnimation( OutputDevice* pOut = NULL, long nExtraData = 0L );
     486             : 
     487             :     friend SvStream&        operator<<( SvStream& rOStm, const GraphicObject& rGraphicObj );
     488             :     friend SvStream&        operator>>( SvStream& rIStm, GraphicObject& rGraphicObj );
     489             : 
     490             :     static GraphicObject    CreateGraphicObjectFromURL( const OUString &rURL );
     491             :     // will inspect an object ( e.g. a control ) for any 'ImageURL'
     492             :     // properties and return these in a vector. Note: this implementation
     493             :     // will cater for XNameContainer objects and deepinspect any containees
     494             :     // if they exist
     495             :     static void InspectForGraphicObjectImageURL( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& rxIf, std::vector< OUString >& rvEmbedImgUrls );
     496             : 
     497             :     // create CropScaling information
     498             :     // fWidth, fHeight: object size
     499             :     // f*Crop: crop values relative to original bitmap size
     500             :     basegfx::B2DVector calculateCropScaling(
     501             :         double fWidth,
     502             :         double fHeight,
     503             :         double fLeftCrop,
     504             :         double fTopCrop,
     505             :         double fRightCrop,
     506             :         double fBottomCrop) const;
     507             : };
     508             : 
     509             : typedef ::std::vector< GraphicObject* > GraphicObjectList_impl;
     510             : 
     511             : class SVT_DLLPUBLIC GraphicManager
     512             : {
     513             :     friend class GraphicObject;
     514             :     friend class GraphicDisplayCacheEntry;
     515             : 
     516             : private:
     517             : 
     518             :     GraphicObjectList_impl  maObjList;
     519             :     GraphicCache*           mpCache;
     520             : 
     521             :                         GraphicManager( const GraphicManager& ) {}
     522             :     GraphicManager&     operator=( const GraphicManager& ) { return *this; }
     523             : 
     524             :     sal_Bool SVT_DLLPRIVATE ImplDraw(
     525             :                             OutputDevice* pOut,
     526             :                             const Point& rPt,
     527             :                             const Size& rSz,
     528             :                             GraphicObject& rObj,
     529             :                             const GraphicAttr& rAttr,
     530             :                             const sal_uLong nFlags,
     531             :                             sal_Bool& rCached
     532             :                         );
     533             : 
     534             :     sal_Bool SVT_DLLPRIVATE ImplCreateOutput(
     535             :                             OutputDevice* pOut,
     536             :                             const Point& rPt,
     537             :                             const Size& rSz,
     538             :                             const BitmapEx& rBmpEx,
     539             :                             const GraphicAttr& rAttr,
     540             :                             const sal_uLong nFlags,
     541             :                             BitmapEx* pBmpEx = NULL
     542             :                         );
     543             :     sal_Bool SVT_DLLPRIVATE ImplCreateOutput(
     544             :                             OutputDevice* pOut,
     545             :                             const Point& rPt,
     546             :                             const Size& rSz,
     547             :                             const GDIMetaFile& rMtf,
     548             :                             const GraphicAttr& rAttr,
     549             :                             const sal_uLong nFlags,
     550             :                             GDIMetaFile& rOutMtf,
     551             :                             BitmapEx& rOutBmpEx
     552             :                         );
     553             : 
     554             :     static void SVT_DLLPRIVATE ImplAdjust(
     555             :                             BitmapEx& rBmpEx,
     556             :                             const GraphicAttr& rAttr,
     557             :                             sal_uLong nAdjustmentFlags
     558             :                         );
     559             :     static void SVT_DLLPRIVATE ImplAdjust(
     560             :                             GDIMetaFile& rMtf,
     561             :                             const GraphicAttr& rAttr,
     562             :                             sal_uLong nAdjustmentFlags
     563             :                         );
     564             :     static void SVT_DLLPRIVATE ImplAdjust(
     565             :                             Animation& rAnimation,
     566             :                             const GraphicAttr& rAttr,
     567             :                             sal_uLong nAdjustmentFlags
     568             :                         );
     569             : 
     570             :     static void SVT_DLLPRIVATE ImplDraw(
     571             :                             OutputDevice* pOut,
     572             :                             const Point& rPt,
     573             :                             const Size& rSz,
     574             :                             const GDIMetaFile& rMtf,
     575             :                             const GraphicAttr& rAttr
     576             :                         );
     577             : 
     578             :                     // Only used by GraphicObject's Ctor's and Dtor's
     579             :     void SVT_DLLPRIVATE ImplRegisterObj(
     580             :                             const GraphicObject& rObj,
     581             :                             Graphic& rSubstitute,
     582             :                             const OString* pID = NULL,
     583             :                             const GraphicObject* pCopyObj = NULL
     584             :                         );
     585             :     void SVT_DLLPRIVATE ImplUnregisterObj( const GraphicObject& rObj );
     586        4545 :     inline sal_Bool SVT_DLLPRIVATE ImplHasObjects() const { return !maObjList.empty(); }
     587             : 
     588             :                     // Only used in swap case by GraphicObject
     589             :     void SVT_DLLPRIVATE ImplGraphicObjectWasSwappedOut( const GraphicObject& rObj );
     590             :     sal_Bool SVT_DLLPRIVATE ImplFillSwappedGraphicObject(
     591             :                             const GraphicObject& rObj,
     592             :                             Graphic& rSubstitute
     593             :                         );
     594             :     void SVT_DLLPRIVATE ImplGraphicObjectWasSwappedIn( const GraphicObject& rObj );
     595             : 
     596             :     OString SVT_DLLPRIVATE ImplGetUniqueID( const GraphicObject& rObj ) const;
     597             : 
     598             : public:
     599             : 
     600             :                         GraphicManager( sal_uLong nCacheSize = 10000000UL, sal_uLong nMaxObjCacheSize = 2400000UL );
     601             :                         ~GraphicManager();
     602             : 
     603             :     void                SetMaxCacheSize( sal_uLong nNewCacheSize );
     604             : 
     605             :     void                SetMaxObjCacheSize(
     606             :                             sal_uLong nNewMaxObjSize,
     607             :                             sal_Bool bDestroyGreaterCached = sal_False
     608             :                         );
     609             : 
     610             :     void                SetCacheTimeout( sal_uLong nTimeoutSeconds );
     611             : 
     612             :     void                ReleaseFromCache( const GraphicObject& rObj );
     613             : 
     614             :     sal_Bool            IsInCache(
     615             :                             OutputDevice* pOut,
     616             :                             const Point& rPt,
     617             :                             const Size& rSz,
     618             :                             const GraphicObject& rObj,
     619             :                             const GraphicAttr& rAttr
     620             :                         ) const;
     621             : 
     622             :     sal_Bool            DrawObj(
     623             :                             OutputDevice* pOut,
     624             :                             const Point& rPt,
     625             :                             const Size& rSz,
     626             :                             GraphicObject& rObj,
     627             :                             const GraphicAttr& rAttr,
     628             :                             const sal_uLong nFlags,
     629             :                             sal_Bool& rCached
     630             :                         );
     631             : };
     632             : 
     633             : #endif // _GRFMGR_HXX
     634             : 
     635             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10