diff options
Diffstat (limited to '')
| -rw-r--r-- | include/vcl/GraphicObject.hxx | 401 |
1 files changed, 401 insertions, 0 deletions
diff --git a/include/vcl/GraphicObject.hxx b/include/vcl/GraphicObject.hxx new file mode 100644 index 000000000..5a4053fa6 --- /dev/null +++ b/include/vcl/GraphicObject.hxx @@ -0,0 +1,401 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#ifndef INCLUDED_VCL_GRAPHICOBJECT_HXX +#define INCLUDED_VCL_GRAPHICOBJECT_HXX + +#include <memory> +#include <vcl/graph.hxx> +#include <vcl/dllapi.h> +#include <o3tl/typed_flags_set.hxx> + +namespace com::sun::star::graphic { class XGraphic; } + +// Adjustment defines +enum class GraphicAdjustmentFlags +{ + NONE = 0x00, + DRAWMODE = 0x01, + COLORS = 0x02, + MIRROR = 0x04, + ROTATE = 0x08, + TRANSPARENCY = 0x10, + ALL = 0x1f, +}; +namespace o3tl +{ + template<> struct typed_flags<GraphicAdjustmentFlags> : is_typed_flags<GraphicAdjustmentFlags, 0x1f> {}; +} + +enum class GraphicDrawMode +{ + Standard = 0, + Greys = 1, + Mono = 2, + Watermark = 3 +}; + +class VirtualDevice; +struct GrfSimpleCacheObj; +struct ImplTileInfo; + +class VCL_DLLPUBLIC GraphicAttr +{ +private: + + double mfGamma; + BmpMirrorFlags mnMirrFlags; + long mnLeftCrop; + long mnTopCrop; + long mnRightCrop; + long mnBottomCrop; + sal_uInt16 mnRotate10; + short mnContPercent; + short mnLumPercent; + short mnRPercent; + short mnGPercent; + short mnBPercent; + bool mbInvert; + sal_uInt8 mcTransparency; + GraphicDrawMode meDrawMode; + +public: + + GraphicAttr(); + + bool operator==( const GraphicAttr& rAttr ) const; + bool operator!=( const GraphicAttr& rAttr ) const { return !( *this == rAttr ); } + + void SetDrawMode( GraphicDrawMode eDrawMode ) { meDrawMode = eDrawMode; } + GraphicDrawMode GetDrawMode() const { return meDrawMode; } + + void SetMirrorFlags( BmpMirrorFlags nMirrFlags ) { mnMirrFlags = nMirrFlags; } + BmpMirrorFlags 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( bool bInvert ) { mbInvert = bInvert; } + bool IsInvert() const { return mbInvert; } + + void SetTransparency( sal_uInt8 cTransparency ) { mcTransparency = cTransparency; } + sal_uInt8 GetTransparency() const { return mcTransparency; } + + bool IsSpecialDrawMode() const { return( meDrawMode != GraphicDrawMode::Standard ); } + bool IsMirrored() const { return mnMirrFlags != BmpMirrorFlags::NONE; } + bool IsCropped() const + { + return( mnLeftCrop != 0 || mnTopCrop != 0 || + mnRightCrop != 0 || mnBottomCrop != 0 ); + } + bool IsRotated() const { return( ( mnRotate10 % 3600 ) != 0 ); } + bool IsTransparent() const { return( mcTransparency > 0 ); } + bool IsAdjusted() const + { + return( mnLumPercent != 0 || mnContPercent != 0 || mnRPercent != 0 || + mnGPercent != 0 || mnBPercent != 0 || mfGamma != 1.0 || mbInvert ); + } +}; + +class VCL_DLLPUBLIC GraphicObject +{ + friend class SdrGrafObj; + +private: + Graphic maGraphic; + GraphicAttr maAttr; + OUString maUserData; + std::unique_ptr<GrfSimpleCacheObj> mxSimpleCache; + + bool VCL_DLLPRIVATE ImplGetCropParams( + OutputDevice const * pOut, + Point& rPt, + Size& rSz, + const GraphicAttr* pAttr, + tools::PolyPolygon& rClipPolyPoly, + 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 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 VCL_DLLPRIVATE ImplRenderTempTile( + VirtualDevice& rVDev, + int nNumTilesX, + int nNumTilesY, + const Size& rTileSizePixel, + const GraphicAttr* pAttr + ); + + /// internally called by ImplRenderTempTile() + bool VCL_DLLPRIVATE ImplRenderTileRecursive( + VirtualDevice& rVDev, + int nExponent, + int nMSBFactor, + int nNumOrigTilesX, + int nNumOrigTilesY, + int nRemainderTilesX, + int nRemainderTilesY, + const Size& rTileSizePixel, + const GraphicAttr* pAttr, + ImplTileInfo& rTileInfo + ); + + bool VCL_DLLPRIVATE ImplDrawTiled( + OutputDevice* pOut, + const tools::Rectangle& rArea, + const Size& rSizePixel, + const Size& rOffset, + const GraphicAttr* pAttr, + int nTileCacheSize1D + ); + + bool VCL_DLLPRIVATE ImplDrawTiled( + OutputDevice& rOut, + const Point& rPos, + int nNumTilesX, + int nNumTilesY, + const Size& rTileSize, + const GraphicAttr* pAttr + ); + + void VCL_DLLPRIVATE ImplTransformBitmap( + BitmapEx& rBmpEx, + const GraphicAttr& rAttr, + const Size& rCropLeftTop, + const Size& rCropRightBottom, + const tools::Rectangle& rCropRect, + const Size& rDstSize, + bool bEnlarge + ) const; + +public: + GraphicObject(); + GraphicObject( const Graphic& rGraphic ); + GraphicObject( const GraphicObject& rCacheObj ); + ~GraphicObject(); + + GraphicObject& operator=( const GraphicObject& rCacheObj ); + bool operator==( const GraphicObject& rCacheObj ) const; + bool operator!=( const GraphicObject& rCacheObj ) const { return !( *this == rCacheObj ); } + + const Graphic& GetGraphic() const; + void SetGraphic( const Graphic& rGraphic, const GraphicObject* pCopyObj = nullptr); + void SetGraphic( const Graphic& rGraphic, const OUString& 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 ) const; // TODO: Change to Impl + + void SetAttr( const GraphicAttr& rAttr ); + const GraphicAttr& GetAttr() const { return maAttr; } + + bool HasUserData() const { return !maUserData.isEmpty(); } + void SetUserData(); + void SetUserData( const OUString& rUserData ); + const OUString& GetUserData() const { return maUserData; } + + OString GetUniqueID() const; + + GraphicType GetType() const; + Size GetPrefSize() const; + MapMode GetPrefMapMode() const; + bool IsTransparent() const; + bool IsAnimated() const; + bool IsEPS() const; + + bool Draw( + OutputDevice* pOut, + const Point& rPt, + const Size& rSz, + const GraphicAttr* pAttr = nullptr + ); + + /** 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 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. + */ + void DrawTiled( + OutputDevice* pOut, + const tools::Rectangle& rArea, + const Size& rSize, + const Size& rOffset, + int nTileCacheSize1D=128 + ); + + bool StartAnimation( + OutputDevice* pOut, + const Point& rPt, + const Size& rSz, + long nExtraData = 0, + OutputDevice* pFirstFrameOutDev = nullptr + ); + + void StopAnimation( OutputDevice* pOut = nullptr, long nExtraData = 0 ); + + static bool isGraphicObjectUniqueIdURL(OUString const & 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; +}; + +namespace vcl +{ +namespace graphic +{ + +// Will search an object ( e.g. a control ) for any 'ImageURL' or 'Graphic' +// properties and return graphics from the properties in a vector. ImageURL +// will be loaded from the URL. +// +// Note: this implementation will cater for XNameContainer objects and deep inspect any containers +// if they exist + +VCL_DLLPUBLIC void SearchForGraphics(css::uno::Reference<css::uno::XInterface> const & rxInterface, + std::vector<css::uno::Reference<css::graphic::XGraphic>> & raGraphicList); + +} +} // end namespace vcl::graphic + +#endif // INCLUDED_VCL_GRAPHICOBJECT_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |