| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #ifndef _GRFMGR_HXX |
| #define _GRFMGR_HXX |
| |
| #include <vcl/graph.hxx> |
| #include <svtools/svtdllapi.h> |
| |
| // ----------- |
| // - Defines - |
| // ----------- |
| |
| #define GRFMGR_DRAW_NOTCACHED 0x00000000UL |
| #define GRFMGR_DRAW_CACHED 0x00000001UL |
| #define GRFMGR_DRAW_BILINEAR 0x00000002UL |
| #define GRFMGR_DRAW_USE_DRAWMODE_SETTINGS 0x00000004UL |
| #define GRFMGR_DRAW_SUBSTITUTE 0x00000008UL |
| #define GRFMGR_DRAW_NO_SUBSTITUTE 0x00000010UL |
| #define GRFMGR_DRAW_STANDARD (GRFMGR_DRAW_CACHED|GRFMGR_DRAW_BILINEAR) |
| |
| // -------------------- |
| // - AutoSwap Defines - |
| // -------------------- |
| |
| #define GRFMGR_AUTOSWAPSTREAM_LINK ((SvStream*)0x00000000UL) |
| #define GRFMGR_AUTOSWAPSTREAM_LOADED ((SvStream*)0xfffffffdUL) |
| #define GRFMGR_AUTOSWAPSTREAM_TEMP ((SvStream*)0xfffffffeUL) |
| #define GRFMGR_AUTOSWAPSTREAM_NONE ((SvStream*)0xffffffffUL) |
| |
| // ---------------------- |
| // - Adjustment Defines - |
| // ---------------------- |
| |
| #define ADJUSTMENT_NONE 0x00000000UL |
| #define ADJUSTMENT_DRAWMODE 0x00000001UL |
| #define ADJUSTMENT_COLORS 0x00000002UL |
| #define ADJUSTMENT_MIRROR 0x00000004UL |
| #define ADJUSTMENT_ROTATE 0x00000008UL |
| #define ADJUSTMENT_TRANSPARENCY 0x00000010UL |
| #define ADJUSTMENT_ALL 0xFFFFFFFFUL |
| |
| // --------- |
| // - Enums - |
| // --------- |
| |
| enum GraphicDrawMode |
| { |
| GRAPHICDRAWMODE_STANDARD = 0, |
| GRAPHICDRAWMODE_GREYS = 1, |
| GRAPHICDRAWMODE_MONO = 2, |
| GRAPHICDRAWMODE_WATERMARK = 3 |
| }; |
| |
| // ------------ |
| // - Forwards - |
| // ------------ |
| |
| class GraphicManager; |
| class SvStream; |
| class BitmapWriteAccess; |
| class GraphicCache; |
| class VirtualDevice; |
| struct GrfSimpleCacheObj; |
| struct ImplTileInfo; |
| |
| // --------------- |
| // - GraphicAttr - |
| // --------------- |
| |
| class SVT_DLLPUBLIC GraphicAttr |
| { |
| private: |
| |
| long mnDummy1; |
| long mnDummy2; |
| double mfGamma; |
| sal_uInt32 mnMirrFlags; |
| long mnLeftCrop; |
| long mnTopCrop; |
| long mnRightCrop; |
| long mnBottomCrop; |
| sal_uInt16 mnRotate10; |
| short mnContPercent; |
| short mnLumPercent; |
| short mnRPercent; |
| short mnGPercent; |
| short mnBPercent; |
| sal_Bool mbInvert; |
| sal_uInt8 mcTransparency; |
| GraphicDrawMode meDrawMode; |
| |
| void* mpDummy; |
| |
| public: |
| |
| GraphicAttr(); |
| ~GraphicAttr(); |
| |
| sal_Bool operator==( const GraphicAttr& rAttr ) const; |
| sal_Bool operator!=( const GraphicAttr& rAttr ) const { return !( *this == rAttr ); } |
| |
| void SetDrawMode( GraphicDrawMode eDrawMode ) { meDrawMode = eDrawMode; } |
| GraphicDrawMode GetDrawMode() const { return meDrawMode; } |
| |
| void SetMirrorFlags( sal_uLong nMirrFlags ) { mnMirrFlags = nMirrFlags; } |
| sal_uLong GetMirrorFlags() const { return mnMirrFlags; } |
| |
| void SetCrop( long nLeft_100TH_MM, long nTop_100TH_MM, long nRight_100TH_MM, long nBottom_100TH_MM ) |
| { |
| mnLeftCrop = nLeft_100TH_MM; mnTopCrop = nTop_100TH_MM; |
| mnRightCrop = nRight_100TH_MM; mnBottomCrop = nBottom_100TH_MM; |
| } |
| long GetLeftCrop() const { return mnLeftCrop; } |
| long GetTopCrop() const { return mnTopCrop; } |
| long GetRightCrop() const { return mnRightCrop; } |
| long GetBottomCrop() const { return mnBottomCrop; } |
| |
| void SetRotation( sal_uInt16 nRotate10 ) { mnRotate10 = nRotate10; } |
| sal_uInt16 GetRotation() const { return mnRotate10; } |
| |
| void SetLuminance( short nLuminancePercent ) { mnLumPercent = nLuminancePercent; } |
| short GetLuminance() const { return mnLumPercent; } |
| |
| void SetContrast( short nContrastPercent ) { mnContPercent = nContrastPercent; } |
| short GetContrast() const { return mnContPercent; } |
| |
| void SetChannelR( short nChannelRPercent ) { mnRPercent = nChannelRPercent; } |
| short GetChannelR() const { return mnRPercent; } |
| |
| void SetChannelG( short nChannelGPercent ) { mnGPercent = nChannelGPercent; } |
| short GetChannelG() const { return mnGPercent; } |
| |
| void SetChannelB( short nChannelBPercent ) { mnBPercent = nChannelBPercent; } |
| short GetChannelB() const { return mnBPercent; } |
| |
| void SetGamma( double fGamma ) { mfGamma = fGamma; } |
| double GetGamma() const { return mfGamma; } |
| |
| void SetInvert( sal_Bool bInvert ) { mbInvert = bInvert; } |
| sal_Bool IsInvert() const { return mbInvert; } |
| |
| void SetTransparency( sal_uInt8 cTransparency ) { mcTransparency = cTransparency; } |
| sal_uInt8 GetTransparency() const { return mcTransparency; } |
| |
| sal_Bool IsSpecialDrawMode() const { return( meDrawMode != GRAPHICDRAWMODE_STANDARD ); } |
| sal_Bool IsMirrored() const { return( mnMirrFlags != 0UL ); } |
| sal_Bool IsCropped() const |
| { |
| return( mnLeftCrop != 0 || mnTopCrop != 0 || |
| mnRightCrop != 0 || mnBottomCrop != 0 ); |
| } |
| sal_Bool IsRotated() const { return( ( mnRotate10 % 3600 ) != 0 ); } |
| sal_Bool IsTransparent() const { return( mcTransparency > 0 ); } |
| sal_Bool IsAdjusted() const |
| { |
| return( mnLumPercent != 0 || mnContPercent != 0 || mnRPercent != 0 || |
| mnGPercent != 0 || mnBPercent != 0 || mfGamma != 1.0 || mbInvert ); |
| } |
| |
| friend SvStream& operator<<( SvStream& rOStm, const GraphicAttr& rAttr ); |
| friend SvStream& operator>>( SvStream& rIStm, GraphicAttr& rAttr ); |
| }; |
| |
| // ----------------- |
| // - GraphicObject - |
| // ----------------- |
| |
| class SVT_DLLPUBLIC GraphicObject : public SvDataCopyStream |
| { |
| friend class GraphicManager; |
| |
| private: |
| |
| static GraphicManager* mpGlobalMgr; |
| |
| Graphic maGraphic; |
| GraphicAttr maAttr; |
| Size maPrefSize; |
| MapMode maPrefMapMode; |
| sal_uLong mnSizeBytes; |
| GraphicType meType; |
| GraphicManager* mpMgr; |
| String* mpLink; |
| Link* mpSwapStreamHdl; |
| String* mpUserData; |
| Timer* mpSwapOutTimer; |
| GrfSimpleCacheObj* mpSimpleCache; |
| sal_uLong mnAnimationLoopCount; |
| |
| // a unique increasing ID to be able to say which data change is older |
| sal_uLong mnDataChangeTimeStamp; |
| |
| void* mpDummy2; |
| sal_Bool mbAutoSwapped : 1; |
| sal_Bool mbTransparent : 1; |
| sal_Bool mbAnimated : 1; |
| sal_Bool mbEPS : 1; |
| sal_Bool mbIsInSwapIn : 1; |
| sal_Bool mbIsInSwapOut : 1; |
| sal_Bool mbAlpha : 1; |
| sal_Bool mbDummyFlag8 : 1; |
| |
| void SVT_DLLPRIVATE ImplConstruct(); |
| void SVT_DLLPRIVATE ImplAssignGraphicData(); |
| void SVT_DLLPRIVATE ImplSetGraphicManager( const GraphicManager* pMgr, |
| const ByteString* pID = NULL, |
| const GraphicObject* pCopyObj = NULL ); |
| void SVT_DLLPRIVATE ImplAutoSwapIn(); |
| sal_Bool SVT_DLLPRIVATE ImplIsAutoSwapped() const { return mbAutoSwapped; } |
| sal_Bool SVT_DLLPRIVATE ImplGetCropParams( OutputDevice* pOut, Point& rPt, Size& rSz, const GraphicAttr* pAttr, |
| PolyPolygon& rClipPolyPoly, sal_Bool& bRectClipRegion ) const; |
| |
| /** Render a given number of tiles in an optimized way |
| |
| This method recursively subdivides the tile rendering problem |
| in smaller parts, i.e. rendering output size x with few tiles |
| of size y, which in turn are generated from the original |
| bitmap in a recursive fashion. The subdivision size can be |
| controlled by the exponent argument, which specifies the |
| minimal number of smaller tiles used in one recursion |
| step. The resulting tile size is given as the integer number |
| of repetitions of the original bitmap along x and y. As the |
| exponent need not necessarily divide these numbers without |
| remainder, the repetition counts are effectively converted to |
| base-exponent numbers, where each place denotes the number of |
| times the corresponding tile size is rendered. |
| |
| @param rVDev |
| Virtual device to render everything into |
| |
| @param nExponent |
| Number of repetitions per subdivision step, _must_ be greater than 1 |
| |
| @param nNumTilesX |
| Number of original tiles to generate in x direction |
| |
| @param nNumTilesY |
| Number of original tiles to generate in y direction |
| |
| @param rTileSizePixel |
| Size in pixel of the original tile bitmap to render it in |
| |
| @param pAttr |
| Graphic attributes to be used for rendering |
| |
| @param nFlags |
| Graphic flags to be used for rendering |
| |
| @param rCurrPos |
| Current output point for this recursion level (should start with (0,0)) |
| |
| @return true, if everything was successfully rendered. |
| */ |
| bool SVT_DLLPRIVATE ImplRenderTempTile( VirtualDevice& rVDev, int nExponent, |
| int nNumTilesX, int nNumTilesY, |
| const Size& rTileSizePixel, |
| const GraphicAttr* pAttr, sal_uLong nFlags ); |
| |
| /// internally called by ImplRenderTempTile() |
| bool SVT_DLLPRIVATE ImplRenderTileRecursive( VirtualDevice& rVDev, int nExponent, int nMSBFactor, |
| int nNumOrigTilesX, int nNumOrigTilesY, |
| int nRemainderTilesX, int nRemainderTilesY, |
| const Size& rTileSizePixel, const GraphicAttr* pAttr, |
| sal_uLong nFlags, ImplTileInfo& rTileInfo ); |
| |
| bool SVT_DLLPRIVATE ImplDrawTiled( OutputDevice* pOut, const Rectangle& rArea, const Size& rSizePixel, |
| const Size& rOffset, const GraphicAttr* pAttr, sal_uLong nFlags, int nTileCacheSize1D ); |
| |
| bool SVT_DLLPRIVATE ImplDrawTiled( OutputDevice& rOut, const Point& rPos, |
| int nNumTilesX, int nNumTilesY, |
| const Size& rTileSize, |
| const GraphicAttr* pAttr, sal_uLong nFlags ); |
| |
| void SVT_DLLPRIVATE ImplTransformBitmap( BitmapEx& rBmpEx, |
| const GraphicAttr& rAttr, |
| const Size& rCropLeftTop, |
| const Size& rCropRightBottom, |
| const Rectangle& rCropRect, |
| const Size& rDstSize, |
| sal_Bool bEnlarge ) const; |
| |
| DECL_LINK( ImplAutoSwapOutHdl, void* ); |
| |
| // Handle evtl. needed AfterDataChanges, needs to be called when new |
| // graphic data is swapped in/added to the GraphicManager |
| void ImplAfterDataChange(); |
| |
| protected: |
| |
| virtual void GraphicManagerDestroyed(); |
| virtual SvStream* GetSwapStream() const; |
| |
| // !!! to be removed |
| virtual sal_uLong GetReleaseFromCache() const; |
| |
| virtual void Load( SvStream& ); |
| virtual void Save( SvStream& ); |
| virtual void Assign( const SvDataCopyStream& ); |
| |
| public: |
| |
| TYPEINFO(); |
| |
| GraphicObject( const GraphicManager* pMgr = NULL ); |
| GraphicObject( const Graphic& rGraphic, const GraphicManager* pMgr = NULL ); |
| GraphicObject( const Graphic& rGraphic, const String& rLink, const GraphicManager* pMgr = NULL ); |
| GraphicObject( const GraphicObject& rCacheObj, const GraphicManager* pMgr = NULL ); |
| GraphicObject( const ByteString& rUniqueID, const GraphicManager* pMgr = NULL ); |
| ~GraphicObject(); |
| |
| GraphicObject& operator=( const GraphicObject& rCacheObj ); |
| sal_Bool operator==( const GraphicObject& rCacheObj ) const; |
| sal_Bool operator!=( const GraphicObject& rCacheObj ) const { return !( *this == rCacheObj ); } |
| |
| sal_Bool HasSwapStreamHdl() const { return( mpSwapStreamHdl != NULL && mpSwapStreamHdl->IsSet() ); } |
| void SetSwapStreamHdl(); |
| void SetSwapStreamHdl( const Link& rHdl, const sal_uLong nSwapOutTimeout = 0UL ); |
| Link GetSwapStreamHdl() const; |
| sal_uLong GetSwapOutTimeout() const { return( mpSwapOutTimer ? mpSwapOutTimer->GetTimeout() : 0 ); } |
| |
| void FireSwapInRequest(); |
| void FireSwapOutRequest(); |
| |
| void SetGraphicManager( const GraphicManager& rMgr ); |
| GraphicManager& GetGraphicManager() const { return *mpMgr; } |
| |
| sal_Bool IsCached( OutputDevice* pOut, const Point& rPt, const Size& rSz, |
| const GraphicAttr* pAttr = NULL, sal_uLong nFlags = GRFMGR_DRAW_STANDARD) const; |
| void ReleaseFromCache(); |
| |
| const Graphic& GetGraphic() const; |
| void SetGraphic( const Graphic& rGraphic, const GraphicObject* pCopyObj = 0); |
| void SetGraphic( const Graphic& rGraphic, const String& rLink ); |
| |
| /** Get graphic transformed according to given attributes |
| |
| This method returns a Graphic transformed, cropped and scaled |
| to the given parameters, ready to be rendered to printer or |
| display. The returned graphic has the same visual appearance |
| as if it had been drawn via GraphicObject::Draw() to a |
| specific output device. |
| |
| @param rDestSize |
| Desired output size in logical coordinates. The mapmode to |
| interpret these logical coordinates in is given by the second |
| parameter, rDestMap. |
| |
| @param rDestMap |
| Mapmode the output should be interpreted in. This is used to |
| interpret rDestSize, to set the appropriate PrefMapMode on the |
| returned Graphic, and to deal correctly with metafile graphics. |
| |
| @param rAttr |
| Graphic attributes used to transform the graphic. This |
| includes cropping, rotation, mirroring, and various color |
| adjustment parameters. |
| |
| @return the readily transformed Graphic |
| */ |
| Graphic GetTransformedGraphic( const Size& rDestSize, const MapMode& rDestMap, const GraphicAttr& rAttr ) const; |
| Graphic GetTransformedGraphic( const GraphicAttr* pAttr = NULL ) const; // TODO: Change to Impl |
| |
| void SetAttr( const GraphicAttr& rAttr ); |
| const GraphicAttr& GetAttr() const { return maAttr; } |
| |
| sal_Bool HasLink() const { return( mpLink != NULL && mpLink->Len() > 0 ); } |
| void SetLink(); |
| void SetLink( const String& rLink ); |
| String GetLink() const; |
| |
| sal_Bool HasUserData() const { return( mpUserData != NULL && mpUserData->Len() > 0 ); } |
| void SetUserData(); |
| void SetUserData( const String& rUserData ); |
| String GetUserData() const; |
| |
| ByteString GetUniqueID() const; |
| |
| GraphicType GetType() const { return meType; } |
| const Size& GetPrefSize() const { return maPrefSize; } |
| const MapMode& GetPrefMapMode() const { return maPrefMapMode; } |
| sal_uLong GetSizeBytes() const { return mnSizeBytes; } |
| sal_uLong GetChecksum() const; |
| sal_Bool IsTransparent() const { return mbTransparent; } |
| sal_Bool IsAlpha() const { return mbAlpha; } |
| sal_Bool IsAnimated() const { return mbAnimated; } |
| sal_Bool IsEPS() const { return mbEPS; } |
| |
| void ResetAnimationLoopCount(); |
| List* GetAnimationInfoList() const; |
| Link GetAnimationNotifyHdl() const { return maGraphic.GetAnimationNotifyHdl(); } |
| void SetAnimationNotifyHdl( const Link& rLink ); |
| |
| sal_Bool SwapOut(); |
| sal_Bool SwapOut( SvStream* pOStm ); |
| sal_Bool SwapIn(); |
| sal_Bool SwapIn( SvStream* pIStm ); |
| |
| sal_Bool IsInSwapIn() const { return mbIsInSwapIn; } |
| sal_Bool IsInSwapOut() const { return mbIsInSwapOut; } |
| sal_Bool IsInSwap() const { return( mbIsInSwapOut || mbIsInSwapOut ); } |
| sal_Bool IsSwappedOut() const { return( mbAutoSwapped || maGraphic.IsSwapOut() ); } |
| void SetSwapState(); |
| |
| sal_Bool Draw( OutputDevice* pOut, const Point& rPt, const Size& rSz, |
| const GraphicAttr* pAttr = NULL, sal_uLong nFlags = GRFMGR_DRAW_STANDARD ); |
| |
| sal_Bool DrawWithPDFHandling( OutputDevice& rOutDev, |
| const Point& rPt, const Size& rSz, |
| const GraphicAttr* pGrfAttr = NULL, |
| const sal_uLong nFlags = GRFMGR_DRAW_STANDARD ); |
| |
| /** Draw the graphic repeatedly into the given output rectangle |
| |
| @param pOut |
| OutputDevice where the rendering should take place |
| |
| @param rArea |
| The output area that is filled with tiled instances of this graphic |
| |
| @param rSize |
| The actual size of a single tile |
| |
| @param rOffset |
| Offset from the left, top position of rArea, where to start |
| the tiling. The upper left corner of the graphic tilings will |
| virtually start at this position. Concretely, only that many |
| tiles are drawn to completely fill the given output area. |
| |
| @param pAttr |
| Optional GraphicAttr |
| |
| @param nFlags |
| Optional rendering flags |
| |
| @param nTileCacheSize1D |
| Optional dimension of the generated cache tiles. The pOut sees |
| a number of tile draws, which have approximately |
| nTileCacheSize1D times nTileCacheSize1D bitmap sizes if the |
| tile bitmap is smaller. Otherwise, the tile is drawn as |
| is. This is useful if e.g. you want only a few, very large |
| bitmap drawings appear on the outdev. |
| |
| @return sal_True, if drawing completed successfully |
| */ |
| sal_Bool DrawTiled( OutputDevice* pOut, const Rectangle& rArea, const Size& rSize, |
| const Size& rOffset, const GraphicAttr* pAttr = NULL, |
| sal_uLong nFlags = GRFMGR_DRAW_STANDARD, int nTileCacheSize1D=128 ); |
| |
| sal_Bool StartAnimation( OutputDevice* pOut, const Point& rPt, const Size& rSz, long nExtraData = 0L, |
| const GraphicAttr* pAttr = NULL, sal_uLong nFlags = GRFMGR_DRAW_STANDARD, |
| OutputDevice* pFirstFrameOutDev = NULL ); |
| |
| void StopAnimation( OutputDevice* pOut = NULL, long nExtraData = 0L ); |
| |
| friend SvStream& operator<<( SvStream& rOStm, const GraphicObject& rGraphicObj ); |
| friend SvStream& operator>>( SvStream& rIStm, GraphicObject& rGraphicObj ); |
| |
| static GraphicObject CreateGraphicObjectFromURL( const ::rtl::OUString &rURL ); |
| |
| // create CropScaling information |
| // fWidth, fHeight: object size |
| // f*Crop: crop values relative to original bitmap size |
| basegfx::B2DVector calculateCropScaling( |
| double fWidth, |
| double fHeight, |
| double fLeftCrop, |
| double fTopCrop, |
| double fRightCrop, |
| double fBottomCrop) const; |
| |
| // read access |
| sal_uLong GetDataChangeTimeStamp() const { return mnDataChangeTimeStamp; } |
| |
| // restart SwapOut timer; this is like touching in a cache to reset to the full timeout value |
| void restartSwapOutTimer() const; |
| }; |
| |
| // ------------------ |
| // - GraphicManager - |
| // ------------------ |
| |
| class SVT_DLLPUBLIC GraphicManager |
| { |
| friend class GraphicObject; |
| friend class GraphicDisplayCacheEntry; |
| |
| private: |
| |
| List maObjList; |
| GraphicCache* mpCache; |
| |
| GraphicManager( const GraphicManager& ) {} |
| GraphicManager& operator=( const GraphicManager& ) { return *this; } |
| |
| sal_Bool SVT_DLLPRIVATE ImplDraw( OutputDevice* pOut, const Point& rPt, |
| const Size& rSz, GraphicObject& rObj, |
| const GraphicAttr& rAttr, |
| const sal_uLong nFlags, sal_Bool& rCached ); |
| |
| sal_Bool SVT_DLLPRIVATE ImplCreateOutput( OutputDevice* pOut, const Point& rPt, const Size& rSz, |
| const BitmapEx& rBmpEx, const GraphicAttr& rAttr, |
| const sal_uLong nFlags, BitmapEx* pBmpEx = NULL ); |
| sal_Bool SVT_DLLPRIVATE ImplCreateOutput( OutputDevice* pOut, |
| const Point& rPt, const Size& rSz, |
| const GDIMetaFile& rMtf, const GraphicAttr& rAttr, |
| const sal_uLong nFlags, GDIMetaFile& rOutMtf, BitmapEx& rOutBmpEx ); |
| |
| sal_Bool SVT_DLLPRIVATE ImplCreateScaled( const BitmapEx& rBmpEx, |
| long* pMapIX, long* pMapFX, long* pMapIY, long* pMapFY, |
| long nStartX, long nEndX, long nStartY, long nEndY, |
| BitmapEx& rOutBmpEx ); |
| |
| sal_Bool SVT_DLLPRIVATE ImplCreateRotatedScaled( const BitmapEx& rBmpEx, |
| sal_uInt16 nRot10, const Size& rOutSzPix, const Size& rUntSzPix, |
| long* pMapIX, long* pMapFX, long* pMapIY, long* pMapFY, |
| long nStartX, long nEndX, long nStartY, long nEndY, |
| BitmapEx& rOutBmpEx ); |
| |
| static void SVT_DLLPRIVATE ImplAdjust( BitmapEx& rBmpEx, const GraphicAttr& rAttr, sal_uLong nAdjustmentFlags ); |
| static void SVT_DLLPRIVATE ImplAdjust( GDIMetaFile& rMtf, const GraphicAttr& rAttr, sal_uLong nAdjustmentFlags ); |
| static void SVT_DLLPRIVATE ImplAdjust( Animation& rAnimation, const GraphicAttr& rAttr, sal_uLong nAdjustmentFlags ); |
| |
| static void SVT_DLLPRIVATE ImplDraw( OutputDevice* pOut, const Point& rPt, const Size& rSz, |
| const GDIMetaFile& rMtf, const GraphicAttr& rAttr ); |
| |
| // Only used by GraphicObject's Ctor's and Dtor's |
| void SVT_DLLPRIVATE ImplRegisterObj( const GraphicObject& rObj, Graphic& rSubstitute, |
| const ByteString* pID = NULL, |
| const GraphicObject* pCopyObj = NULL ); |
| void SVT_DLLPRIVATE ImplUnregisterObj( const GraphicObject& rObj ); |
| inline sal_Bool SVT_DLLPRIVATE ImplHasObjects() const { return( maObjList.Count() > 0UL ); } |
| |
| // Only used in swap case by GraphicObject |
| void SVT_DLLPRIVATE ImplGraphicObjectWasSwappedOut( const GraphicObject& rObj ); |
| sal_Bool SVT_DLLPRIVATE ImplFillSwappedGraphicObject( const GraphicObject& rObj, Graphic& rSubstitute ); |
| void SVT_DLLPRIVATE ImplGraphicObjectWasSwappedIn( const GraphicObject& rObj ); |
| |
| ByteString SVT_DLLPRIVATE ImplGetUniqueID( const GraphicObject& rObj ) const; |
| |
| // This method allows to check memory footprint for all currently swapped in GraphicObjects on this GraphicManager |
| // which are based on Bitmaps. This is needed on 32Bit systems and only does something on those systems. The problem |
| // to solve is that normally the SwapOut is timer-driven, but even with short timer settings there are situations |
| // where this does not trigger - or in other words: A maximum limitation for GraphicManagers was not in place before. |
| // For 32Bit systems this leads to situations where graphics will be missing. This method will actively swap out |
| // the longest swapped in graphics until a maximum memory boundary (derived from user settings in tools/options/memory) |
| // is no longer exceeded |
| void ImplCheckSizeOfSwappedInGraphics(); |
| |
| public: |
| |
| GraphicManager( sal_uLong nCacheSize = 10000000UL, sal_uLong nMaxObjCacheSize = 2400000UL ); |
| ~GraphicManager(); |
| |
| void SetMaxCacheSize( sal_uLong nNewCacheSize ); |
| sal_uLong GetMaxCacheSize() const; |
| |
| void SetMaxObjCacheSize( sal_uLong nNewMaxObjSize, sal_Bool bDestroyGreaterCached = sal_False ); |
| sal_uLong GetMaxObjCacheSize() const; |
| |
| sal_uLong GetUsedCacheSize() const; |
| sal_uLong GetFreeCacheSize() const; |
| |
| void SetCacheTimeout( sal_uLong nTimeoutSeconds ); |
| sal_uLong GetCacheTimeout() const; |
| |
| void ClearCache(); |
| |
| void ReleaseFromCache( const GraphicObject& rObj ); |
| |
| sal_Bool IsInCache( OutputDevice* pOut, const Point& rPt, const Size& rSz, |
| const GraphicObject& rObj, const GraphicAttr& rAttr ) const; |
| |
| sal_Bool DrawObj( OutputDevice* pOut, const Point& rPt, const Size& rSz, |
| GraphicObject& rObj, const GraphicAttr& rAttr, |
| const sal_uLong nFlags, sal_Bool& rCached ); |
| }; |
| |
| #endif // _GRFMGR_HXX |
