summaryrefslogtreecommitdiffstats
path: root/emfio/inc/mtftools.hxx
diff options
context:
space:
mode:
Diffstat (limited to 'emfio/inc/mtftools.hxx')
-rw-r--r--emfio/inc/mtftools.hxx842
1 files changed, 842 insertions, 0 deletions
diff --git a/emfio/inc/mtftools.hxx b/emfio/inc/mtftools.hxx
new file mode 100644
index 000000000..997f2287f
--- /dev/null
+++ b/emfio/inc/mtftools.hxx
@@ -0,0 +1,842 @@
+/* -*- 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_EMFIO_INC_MTFTOOLS_HXX
+#define INCLUDED_EMFIO_INC_MTFTOOLS_HXX
+
+#include <config_options.h>
+#include <basegfx/utils/b2dclipstate.hxx>
+#include <tools/poly.hxx>
+#include <vcl/font.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/lineinfo.hxx>
+#include <vcl/rendercontext/State.hxx>
+#include <vcl/metaact.hxx>
+#include <rtl/ref.hxx>
+
+#include "emfiodllapi.h"
+
+namespace emfio
+{
+ /* [MS-EMF] - v20210625 - pages 43, 107 */
+ enum class RegionMode : sal_uInt32
+ {
+ RGN_AND = 0x01,
+ RGN_OR = 0x02,
+ RGN_XOR = 0x03,
+ RGN_DIFF = 0x04,
+ RGN_COPY = 0x05
+ };
+
+ /* [MS-EMF] - v20210625 - pages 40, 198 */
+ enum class BackgroundMode : sal_uInt32
+ {
+ NONE = 0,
+ Transparent = 1,
+ OPAQUE = 2,
+ };
+
+ /* [MS-EMF] - v20210625 - pages 40, 210 */
+ /* xform stuff */
+ enum class ModifyWorldTransformMode : sal_uInt32
+ {
+ MWT_IDENTITY = 0x01,
+ MWT_LEFTMULTIPLY = 0x02,
+ MWT_RIGHTMULTIPLY = 0x03,
+ MWT_SET = 0x04
+ };
+
+ constexpr sal_uInt32 ENHMETA_STOCK_OBJECT = 0x80000000;
+
+ /* [MS-EMF] - v20210625 - pages 44, 45, 182 */
+ /* Stock Logical Objects */
+ enum class StockObject : sal_uInt32
+ {
+ WHITE_BRUSH = 0,
+ LTGRAY_BRUSH = 1,
+ GRAY_BRUSH = 2,
+ DKGRAY_BRUSH = 3,
+ BLACK_BRUSH = 4,
+ NULL_BRUSH = 5,
+ WHITE_PEN = 6,
+ BLACK_PEN = 7,
+ NULL_PEN = 8,
+ ANSI_FIXED_FONT = 11,
+ ANSI_VAR_FONT = 12,
+ SYSTEM_FIXED_FONT = 16
+ };
+
+ /* Note: This enum is incomplete compared to the specification */
+ /* [MS-WMF] - v20210625 - pages 25-26 */
+ enum class WMFRasterOp : sal_uInt16
+ {
+ NONE = 0,
+ Black = 1,
+ Not = 6,
+ XorPen = 7,
+ Nop = 11,
+ CopyPen = 13
+ };
+
+ /* Note: We have MapMode elsewhere, so we use MappingMode instead */
+ /* [MS-EMF] - v20210625 - pages 38-50, 202 */
+ /* Mapping modes */
+ enum MappingMode : sal_uInt32
+ {
+ MM_TEXT = 0x01,
+ MM_LOMETRIC = 0x02,
+ MM_HIMETRIC = 0x03,
+ MM_LOENGLISH = 0x04,
+ MM_HIENGLISH = 0x05,
+ MM_TWIPS = 0x06,
+ MM_ISOTROPIC = 0x07,
+ MM_ANISOTROPIC = 0x08
+ };
+
+ /* Note: No type is specified, but 32-bit unsigned is used to provide
+ * to match the number of bits in the binary literal, and also the
+ * previous definition of SetGfxMode() and GetGfxMode() functions */
+ /* [MS-EMF] - v20210625 - pages 35 */
+ /* Graphics modes */
+ enum class GraphicsMode : sal_uInt32
+ {
+ GM_COMPATIBLE = 0x00000001,
+ GM_ADVANCED = 0x00000002
+ } ;
+
+ /* [MS-WMF] - v20210625 - pages 46 */
+ /* StretchBlt() modes */
+ enum class StretchMode : sal_uInt16
+ {
+ BLACKONWHITE = 0x0001,
+ WHITEONBLACK = 0x0002,
+ COLORONCOLOR = 0x0003,
+ HALFTONE = 0x0004,
+ STRETCH_ANDSCANS = BLACKONWHITE,
+ STRETCH_ORSCANS = WHITEONBLACK,
+ STRETCH_DELETESCANS = COLORONCOLOR
+ };
+
+ constexpr sal_Int32 LF_FACESIZE = 32;
+
+ struct LOGFONTW
+ {
+ sal_Int32 lfHeight;
+ sal_Int32 lfWidth;
+ sal_Int32 lfEscapement;
+ sal_Int32 lfOrientation;
+ sal_Int32 lfWeight;
+ sal_uInt8 lfItalic;
+ sal_uInt8 lfUnderline;
+ sal_uInt8 lfStrikeOut;
+ sal_uInt8 lfCharSet;
+ sal_uInt8 lfOutPrecision;
+ sal_uInt8 lfClipPrecision;
+ sal_uInt8 lfQuality;
+ sal_uInt8 lfPitchAndFamily;
+ OUString alfFaceName;
+ LOGFONTW()
+ : lfHeight(0)
+ , lfWidth(0)
+ , lfEscapement(0)
+ , lfOrientation(0)
+ , lfWeight(0)
+ , lfItalic(0)
+ , lfUnderline(0)
+ , lfStrikeOut(0)
+ , lfCharSet(0)
+ , lfOutPrecision(0)
+ , lfClipPrecision(0)
+ , lfQuality(0)
+ , lfPitchAndFamily(0)
+ {
+ }
+ };
+
+ /* [MS-WMF] - v20210625 - pages 153 */
+ enum TextAlignmentMode : sal_uInt16
+ {
+ TA_NOUPDATECP = 0x0000,
+ TA_UPDATECP = 0x0001,
+ TA_LEFT = 0x0000,
+ TA_RIGHT = 0x0002,
+ TA_CENTER = 0x0006,
+ TA_RIGHT_CENTER = (TA_RIGHT | TA_CENTER),
+ TA_TOP = 0x0000,
+ TA_BOTTOM = 0x0008,
+ TA_BASELINE = 0x0018,
+ TA_RTLREADING = 0x0100
+ };
+
+ /* Note: This enum is incomplete compared to the specification */
+ /* [MS-EMF] - v20210625 - pages 47-50, 126 */
+ /* Ternary raster operations */
+ enum TernaryRasterOperation : sal_uInt32
+ {
+ SRCCOPY = 0x00CC0020L,
+ SRCPAINT = 0x00EE0086L,
+ SRCAND = 0x008800C6L,
+ SRCINVERT = 0x00660046L,
+ SRCERASE = 0x00440328L,
+ PATCOPY = 0x00F00021L,
+ PATINVERT = 0x005A0049L,
+ BLACKNESS = 0x00000042L,
+ WHITENESS = 0x00FF0062L
+ };
+
+ /* [MS-EMF] - v20210625 - pages 40, 41, 65 */
+ enum PenStyle : sal_uInt32
+ {
+ PS_COSMETIC = 0x00000000,
+ PS_SOLID = 0x00000000,
+ PS_DASH = 0x00000001,
+ PS_DOT = 0x00000002,
+ PS_DASHDOT = 0x00000003,
+ PS_DASHDOTDOT = 0x00000004,
+ PS_NULL = 0x00000005,
+ PS_INSIDEFRAME = 0x00000006,
+ PS_USERSTYLE = 0x00000007,
+ PS_ALTERNATE = 0x00000008,
+ PS_STYLE_MASK = 0x0000000F,
+
+ PS_ENDCAP_ROUND = 0x00000000,
+ PS_ENDCAP_SQUARE = 0x00000100,
+ PS_ENDCAP_FLAT = 0x00000200,
+ PS_ENDCAP_STYLE_MASK = 0x00000F00,
+
+ PS_JOIN_ROUND = 0x00000000,
+ PS_JOIN_BEVEL = 0x00001000,
+ PS_JOIN_MITER = 0x00002000,
+ PS_JOIN_STYLE_MASK = 0x0000F000,
+
+ PS_GEOMETRIC = 0x00010000
+ };
+
+ /* [MS-WMF] - v20210625 - pages 30, 82 */
+ /* Character Sets */
+ enum CharacterSet : sal_uInt8
+ {
+ ANSI_CHARSET = 0x00000000,
+ DEFAULT_CHARSET = 0x00000001,
+ SYMBOL_CHARSET = 0x00000002,
+ SHIFTJIS_CHARSET = 0x00000080,
+ HANGUL_CHARSET = 0x00000081,
+ GB2312_CHARSET = 0x00000086,
+ CHINESEBIG5_CHARSET = 0x00000088,
+ OEM_CHARSET = 0x000000FF,
+ /* WINVER >= 0x0400 */
+ MAC_CHARSET = 0x0000004D,
+ JOHAB_CHARSET = 0x00000082,
+ GREEK_CHARSET = 0x000000A1,
+ TURKISH_CHARSET = 0x000000A2,
+ VIETNAMESE_CHARSET = 0x000000A3,
+ HEBREW_CHARSET = 0x000000B1,
+ ARABIC_CHARSET = 0x000000B2,
+ BALTIC_CHARSET = 0x000000BA,
+ RUSSIAN_CHARSET = 0x000000CC,
+ THAI_CHARSET = 0x000000DE,
+ EASTEUROPE_CHARSET = 0x000000EE
+ };
+
+ /* Note: This enum is incomplete compared to the specification */
+ /* [MS-EMF] - v20210625 - pages 32, 283 */
+ enum ExtTextOutOptions : sal_uInt32
+ {
+ ETO_OPAQUE = 0x0002,
+ ETO_CLIPPED = 0x0004,
+ /* WINVER >= 0x0400 */
+ ETO_GLYPH_INDEX = 0x0010,
+ ETO_RTLREADING = 0x0080,
+ /* _WIN32_WINNT >= 0x0500 */
+ ETO_NO_RECT = 0x0100,
+ ETO_PDY = 0x2000
+ };
+
+ /* [MS-WMF] - v20210625 - pages 44, 96 */
+ /* This is packed into a byte as 2 bits */
+ enum PitchFont : sal_uInt8
+ {
+ DEFAULT_PITCH = 0,
+ FIXED_PITCH = 1,
+ VARIABLE_PITCH = 2
+ };
+
+ /* [MS-WMF] - v20210625 - pages 33, */
+ enum FamilyFont : sal_uInt8
+ {
+ FF_DONTCARE = 0x00,
+ FF_ROMAN = 0x01,
+ FF_SWISS = 0x02,
+ FF_MODERN = 0x03,
+ FF_SCRIPT = 0x04,
+ FF_DECORATIVE = 0x05
+ };
+
+ enum WeightFont
+ {
+ FW_THIN = 100,
+ FW_EXTRALIGHT = 200,
+ FW_LIGHT = 300,
+ FW_NORMAL = 400,
+ FW_MEDIUM = 500,
+ FW_SEMIBOLD = 600,
+ FW_BOLD = 700,
+ FW_EXTRABOLD = 800,
+ FW_ULTRALIGHT = 200,
+ FW_ULTRABOLD = 800,
+ FW_BLACK = 900
+ };
+
+ /* [MS-WMF] - v20210625 - pages 29, 30, 182 */
+ enum class BrushStyle : sal_uInt16
+ {
+ BS_SOLID = 0,
+ BS_NULL = 1,
+ BS_HOLLOW = 1,
+ BS_HATCHED = 2,
+ BS_PATTERN = 3,
+ BS_INDEXED = 4,
+ BS_DIBPATTERN = 5,
+ BS_DIBPATTERNPT = 6,
+ BS_PATTERN8X8 = 7,
+ BS_DIBPATTERN8X8 = 8,
+ BS_MONOPATTERN = 9
+ };
+
+ constexpr sal_Int32 RDH_RECTANGLES = 1;
+ constexpr sal_Int32 W_MFCOMMENT = 15;
+ constexpr sal_Int32 PRIVATE_ESCAPE_UNICODE = 2;
+
+ //Scalar constants
+ constexpr sal_Int32 UNDOCUMENTED_WIN_RCL_RELATION = 32;
+ constexpr sal_Int32 MS_FIXPOINT_BITCOUNT_28_4 = 4;
+}
+
+//============================ WmfReader ==================================
+
+namespace emfio
+{
+ class WinMtfClipPath
+ {
+ basegfx::utils::B2DClipState maClip;
+
+ public:
+ WinMtfClipPath() : maClip() {};
+
+ void setClipPath(const basegfx::B2DPolyPolygon&, RegionMode nClippingMode);
+ void intersectClip(const basegfx::B2DPolyPolygon& rPolyPolygon);
+ void excludeClip(const basegfx::B2DPolyPolygon& rPolyPolygon);
+ void moveClipRegion(const Size& rSize);
+ void setDefaultClipPath();
+
+ bool isEmpty() const { return maClip.isCleared(); }
+
+ basegfx::utils::B2DClipState const & getClip() const { return maClip; }
+ basegfx::B2DPolyPolygon const & getClipPath() const;
+
+ bool operator==(const WinMtfClipPath& rPath) const
+ {
+ return maClip == rPath.maClip;
+ };
+ };
+
+ class WinMtfPathObj : public tools::PolyPolygon
+ {
+ bool bClosed;
+
+ public:
+
+ WinMtfPathObj() :
+ bClosed(true)
+ {}
+
+ void Init()
+ {
+ Clear();
+ bClosed = true;
+ }
+
+ void ClosePath();
+ void AddPoint(const Point& rPoint);
+ void AddPolygon(const tools::Polygon& rPoly);
+ void AddPolyLine(const tools::Polygon& rPoly);
+ void AddPolyPolygon(const tools::PolyPolygon& rPolyPolygon);
+ };
+
+ struct EMFIO_DLLPUBLIC GDIObj
+ {
+ GDIObj() = default;
+ GDIObj(GDIObj const &) = default;
+ virtual ~GDIObj() = default; // Polymorphic base class
+ GDIObj & operator =(GDIObj const &) = default;
+ };
+
+ struct UNLESS_MERGELIBS(EMFIO_DLLPUBLIC) WinMtfFontStyle final : GDIObj
+ {
+ vcl::Font aFont;
+
+ explicit WinMtfFontStyle(LOGFONTW const & rLogFont);
+ };
+
+ enum class WinMtfFillStyleType
+ {
+ Solid, Pattern
+ };
+
+ struct WinMtfFillStyle final : GDIObj
+ {
+ Color aFillColor;
+ bool bTransparent;
+ WinMtfFillStyleType aType;
+ Bitmap aBmp;
+
+ WinMtfFillStyle()
+ : aFillColor(COL_BLACK)
+ , bTransparent(false)
+ , aType(WinMtfFillStyleType::Solid)
+ {}
+
+ WinMtfFillStyle(const Color& rColor, bool bTrans = false)
+ : aFillColor(rColor)
+ , bTransparent(bTrans)
+ , aType(WinMtfFillStyleType::Solid)
+ {}
+
+ explicit WinMtfFillStyle(Bitmap const & rBmp)
+ : bTransparent(false)
+ , aType(WinMtfFillStyleType::Pattern)
+ , aBmp(rBmp)
+ {}
+
+ bool operator==(const WinMtfFillStyle& rStyle) const
+ {
+ return aFillColor == rStyle.aFillColor
+ && bTransparent == rStyle.bTransparent
+ && aType == rStyle.aType;
+ }
+ };
+
+
+ struct WinMtfPalette final : GDIObj
+ {
+ std::vector< Color > aPaletteColors;
+
+ WinMtfPalette()
+ : aPaletteColors(std::vector< Color >{})
+ {}
+
+ WinMtfPalette(const std::vector< Color > rPaletteColors)
+ : aPaletteColors(rPaletteColors)
+ {}
+
+ };
+
+
+ struct WinMtfLineStyle final : GDIObj
+ {
+ Color aLineColor;
+ LineInfo aLineInfo;
+ bool bTransparent;
+
+ WinMtfLineStyle()
+ : aLineColor(COL_BLACK)
+ , bTransparent(false)
+ {}
+
+ WinMtfLineStyle(const Color& rColor, bool bTrans = false)
+ : aLineColor(rColor)
+ , bTransparent(bTrans)
+ {}
+
+ WinMtfLineStyle(const Color& rColor, const sal_uInt32 nStyle, const sal_Int32 nPenWidth)
+ : aLineColor(rColor)
+ {
+ // According to documentation: nStyle = PS_COSMETIC = 0x0 - line with a width of one logical unit and a style that is a solid color
+ // tdf#140271 Based on observed behaviour the line width is not constant with PS_COSMETIC
+
+ // Width 0 means default width for LineInfo (HairLine) with 1 pixel wide
+ aLineInfo.SetWidth(nPenWidth);
+ switch (nStyle & PS_STYLE_MASK)
+ {
+ case PS_DASHDOTDOT:
+ aLineInfo.SetStyle(LineStyle::Dash);
+ aLineInfo.SetDashCount(1);
+ aLineInfo.SetDotCount(2);
+ break;
+ case PS_DASHDOT:
+ aLineInfo.SetStyle(LineStyle::Dash);
+ aLineInfo.SetDashCount(1);
+ aLineInfo.SetDotCount(1);
+ break;
+ case PS_DOT:
+ aLineInfo.SetStyle(LineStyle::Dash);
+ aLineInfo.SetDashCount(0);
+ aLineInfo.SetDotCount(1);
+ break;
+ case PS_DASH:
+ aLineInfo.SetStyle(LineStyle::Dash);
+ aLineInfo.SetDashCount(1);
+ aLineInfo.SetDotCount(0);
+ break;
+ case PS_NULL:
+ aLineInfo.SetStyle(LineStyle::NONE);
+ break;
+ case PS_INSIDEFRAME: // TODO Implement PS_INSIDEFRAME
+ case PS_SOLID:
+ default:
+ aLineInfo.SetStyle(LineStyle::Solid);
+ }
+ if (nPenWidth)
+ switch (nStyle & PS_ENDCAP_STYLE_MASK)
+ {
+ case PS_ENDCAP_ROUND:
+ aLineInfo.SetLineCap(css::drawing::LineCap_ROUND);
+ break;
+ case PS_ENDCAP_SQUARE:
+ aLineInfo.SetLineCap(css::drawing::LineCap_SQUARE);
+ break;
+ case PS_ENDCAP_FLAT:
+ default:
+ aLineInfo.SetLineCap(css::drawing::LineCap_BUTT);
+ }
+ else
+ aLineInfo.SetLineCap(css::drawing::LineCap_BUTT);
+ switch (nStyle & PS_JOIN_STYLE_MASK)
+ {
+ case PS_JOIN_ROUND:
+ aLineInfo.SetLineJoin(basegfx::B2DLineJoin::Round);
+ break;
+ case PS_JOIN_BEVEL:
+ aLineInfo.SetLineJoin(basegfx::B2DLineJoin::Bevel);
+ break;
+ // Undocumented but based on experiments with MS Paint and MS Word,
+ // the default Join Style is PS_JOIN_MITER
+ case PS_JOIN_MITER:
+ default:
+ aLineInfo.SetLineJoin(basegfx::B2DLineJoin::Miter);
+ }
+ bTransparent = aLineInfo.GetStyle() == LineStyle::NONE;
+ }
+
+ bool operator==(const WinMtfLineStyle& rStyle) const
+ {
+ return aLineColor == rStyle.aLineColor
+ && bTransparent == rStyle.bTransparent
+ && aLineInfo == rStyle.aLineInfo;
+ }
+ };
+
+ struct XForm
+ {
+ float eM11;
+ float eM12;
+ float eM21;
+ float eM22;
+ float eDx;
+ float eDy;
+
+ XForm()
+ : eM11(1.0f)
+ , eM12(0.0f)
+ , eM21(0.0f)
+ , eM22(1.0f)
+ , eDx(0.0f)
+ , eDy(0.0f)
+ {}
+ };
+
+ SvStream& operator >> (SvStream& rInStream, XForm& rXForm);
+
+ struct SaveStruct
+ {
+ BackgroundMode nBkMode;
+ MappingMode eMapMode;
+ GraphicsMode eGfxMode;
+ vcl::text::ComplexTextLayoutFlags nTextLayoutMode;
+ sal_Int32 nWinOrgX, nWinOrgY, nWinExtX, nWinExtY;
+ sal_Int32 nDevOrgX, nDevOrgY, nDevWidth, nDevHeight;
+
+ WinMtfLineStyle aLineStyle;
+ WinMtfFillStyle aFillStyle;
+
+ vcl::Font aFont;
+ Color aBkColor;
+ Color aTextColor;
+ sal_uInt32 nTextAlign;
+ RasterOp eRasterOp;
+
+ Point aActPos;
+ WinMtfPathObj maPathObj;
+ WinMtfClipPath maClipPath;
+ XForm aXForm;
+
+ bool bClockWiseArcDirection;
+ bool bFillStyleSelected;
+ };
+
+ struct BSaveStruct
+ {
+ BitmapEx aBmpEx;
+ tools::Rectangle aOutRect;
+ sal_uInt32 nWinRop;
+ bool m_bForceAlpha = false;
+
+ BSaveStruct(const Bitmap& rBmp, const tools::Rectangle& rOutRect, sal_uInt32 nRop)
+ : aBmpEx(rBmp)
+ , aOutRect(rOutRect)
+ , nWinRop(nRop)
+ {}
+
+ BSaveStruct(const BitmapEx& rBmpEx, const tools::Rectangle& rOutRect, sal_uInt32 nRop,
+ bool bForceAlpha = false)
+ : aBmpEx(rBmpEx)
+ , aOutRect(rOutRect)
+ , nWinRop(nRop)
+ , m_bForceAlpha(bForceAlpha)
+ {}
+ };
+
+ // tdf#127471 implement detection and correction of wrongly scaled
+ // fonts in own-written, old (before this fix) EMF/WMF files
+ class ScaledFontDetectCorrectHelper
+ {
+ private:
+ rtl::Reference<MetaFontAction> maCurrentMetaFontAction;
+ std::vector<double> maAlternativeFontScales;
+ std::vector<std::pair<rtl::Reference<MetaFontAction>, double>> maPositiveIdentifiedCases;
+ std::vector<std::pair<rtl::Reference<MetaFontAction>, double>> maNegativeIdentifiedCases;
+
+ public:
+ ScaledFontDetectCorrectHelper();
+ void endCurrentMetaFontAction();
+ void newCurrentMetaFontAction(const rtl::Reference<MetaFontAction>& rNewMetaFontAction);
+ void evaluateAlternativeFontScale(OUString const & rText, tools::Long nImportedTextLength);
+ void applyAlternativeFontScale();
+ };
+
+ class MtfTools
+ {
+ MtfTools(MtfTools const &) = delete;
+ MtfTools& operator =(MtfTools const &) = delete;
+
+ protected:
+ WinMtfPathObj maPathObj;
+ WinMtfClipPath maClipPath;
+
+ WinMtfLineStyle maLatestLineStyle;
+ WinMtfLineStyle maLineStyle;
+ WinMtfLineStyle maNopLineStyle;
+ WinMtfFillStyle maLatestFillStyle;
+ WinMtfFillStyle maFillStyle;
+ WinMtfFillStyle maNopFillStyle;
+ WinMtfPalette maPalette;
+
+ vcl::Font maLatestFont;
+ vcl::Font maFont;
+ sal_uInt32 mnLatestTextAlign;
+ sal_uInt32 mnTextAlign;
+ Color maLatestTextColor;
+ Color maTextColor;
+ Color maLatestBkColor;
+ Color maBkColor;
+ vcl::text::ComplexTextLayoutFlags mnLatestTextLayoutMode;
+ vcl::text::ComplexTextLayoutFlags mnTextLayoutMode;
+ BackgroundMode mnLatestBkMode;
+ BackgroundMode mnBkMode;
+ RasterOp meLatestRasterOp;
+ RasterOp meRasterOp;
+
+ std::vector< std::unique_ptr<GDIObj> > mvGDIObj;
+ Point maActPos;
+ WMFRasterOp mnRop;
+ std::vector< std::shared_ptr<SaveStruct> > mvSaveStack;
+
+ GraphicsMode meGfxMode;
+ MappingMode meMapMode;
+
+ XForm maXForm;
+ sal_Int32 mnDevOrgX;
+ sal_Int32 mnDevOrgY;
+ sal_Int32 mnDevWidth;
+ sal_Int32 mnDevHeight;
+ sal_Int32 mnWinOrgX;
+ sal_Int32 mnWinOrgY;
+ sal_Int32 mnWinExtX;
+ sal_Int32 mnWinExtY;
+
+ sal_Int32 mnPixX; // Reference Device in pixel
+ sal_Int32 mnPixY; // Reference Device in pixel
+ sal_Int32 mnMillX; // Reference Device in Mill
+ sal_Int32 mnMillY; // Reference Device in Mill
+ tools::Rectangle mrclFrame;
+ tools::Rectangle mrclBounds;
+
+ GDIMetaFile* mpGDIMetaFile;
+
+ SvStream* mpInputStream; // the WMF/EMF file to be read
+ sal_uInt32 mnStartPos;
+ sal_uInt32 mnEndPos;
+ std::vector<BSaveStruct> maBmpSaveList;
+
+ // tdf#127471 always try to detect - only used with ScaledText
+ ScaledFontDetectCorrectHelper maScaledFontHelper;
+
+ bool mbNopMode : 1;
+ bool mbClockWiseArcDirection : 1;
+ bool mbFillStyleSelected : 1;
+ bool mbClipNeedsUpdate : 1;
+ bool mbComplexClip : 1;
+ bool mbIsMapWinSet : 1;
+ bool mbIsMapDevSet : 1;
+
+ void UpdateLineStyle();
+ void UpdateFillStyle();
+
+ Point ImplMap(const Point& rPt);
+ Point ImplScale(const Point& rPt);
+ Size ImplMap(const Size& rSize, bool bDoWorldTransform = true);
+ tools::Rectangle ImplMap(const tools::Rectangle& rRectangle);
+ void ImplMap(vcl::Font& rFont);
+ tools::Polygon& ImplMap(tools::Polygon& rPolygon);
+ tools::PolyPolygon& ImplMap(tools::PolyPolygon& rPolyPolygon);
+ void ImplScale(tools::Polygon& rPolygon);
+ tools::PolyPolygon& ImplScale(tools::PolyPolygon& rPolyPolygon);
+ void ImplResizeObjectArry(sal_uInt32 nNewEntry);
+ void ImplSetNonPersistentLineColorTransparenz();
+ void ImplDrawClippedPolyPolygon(const tools::PolyPolygon& rPolyPoly);
+ void ImplDrawBitmap(const Point& rPos, const Size& rSize, const BitmapEx& rBitmap);
+
+ public:
+
+ void SetDevByWin(); //Hack to set varying defaults for incompletely defined files.
+ void SetDevOrg(const Point& rPoint);
+ void SetDevOrgOffset(sal_Int32 nXAdd, sal_Int32 nYAdd);
+ void SetDevExt(const Size& rSize, bool regular = true);
+ void ScaleDevExt(double fX, double fY);
+
+ void SetWinOrg(const Point& rPoint, bool bIsEMF = false);
+ void SetWinOrgOffset(sal_Int32 nX, sal_Int32 nY);
+ void SetWinExt(const Size& rSize, bool bIsEMF = false);
+ void ScaleWinExt(double fX, double fY);
+
+ void SetrclBounds(const tools::Rectangle& rRect);
+ void SetrclFrame(const tools::Rectangle& rRect);
+ void SetRefPix(const Size& rSize);
+ void SetRefMill(const Size& rSize);
+
+ void SetMapMode(MappingMode mnMapMode);
+ void SetWorldTransform(const XForm& rXForm);
+ void ModifyWorldTransform(const XForm& rXForm, ModifyWorldTransformMode nMode);
+
+ void Push();
+ void Pop( const sal_Int32 nSavedDC = -1 );
+
+ WMFRasterOp SetRasterOp(WMFRasterOp nRasterOp);
+ void StrokeAndFillPath(bool bStroke, bool bFill);
+
+ void SetArcDirection(bool bCounterClockWise);
+ bool IsArcDirectionClockWise() { return mbClockWiseArcDirection; };
+ void SetGfxMode(GraphicsMode nGfxMode) { meGfxMode = nGfxMode; };
+ GraphicsMode GetGfxMode() const { return meGfxMode; };
+ void SetBkMode(BackgroundMode nMode);
+ void SetBkColor(const Color& rColor);
+ void SetTextColor(const Color& rColor);
+ void SetTextAlign(sal_uInt32 nAlign);
+
+ void CreateObject(std::unique_ptr<GDIObj> pObject);
+ void CreateObjectIndexed(sal_uInt32 nIndex, std::unique_ptr<GDIObj> pObject);
+ void CreateObject();
+
+ void DeleteObject(sal_uInt32 nIndex);
+ void SelectObject(sal_uInt32 nIndex);
+ rtl_TextEncoding GetCharSet() const { return maFont.GetCharSet(); };
+ const vcl::Font& GetFont() const { return maFont; }
+ void SetTextLayoutMode(vcl::text::ComplexTextLayoutFlags nLayoutMode);
+
+ void ClearPath() { maPathObj.Init(); };
+ void ClosePath() { maPathObj.ClosePath(); };
+ const tools::PolyPolygon& GetPathObj() const { return maPathObj; };
+
+ void MoveTo(const Point& rPoint, bool bRecordPath = false);
+ void LineTo(const Point& rPoint, bool bRecordPath = false);
+ void DrawPixel(const Point& rSource, const Color& rColor);
+ void DrawRect(const tools::Rectangle& rRect, bool bEdge = true);
+ void DrawRectWithBGColor(const tools::Rectangle& rRect);
+ void DrawRoundRect(const tools::Rectangle& rRect, const Size& rSize);
+ void DrawEllipse(const tools::Rectangle& rRect);
+ void DrawArc(
+ const tools::Rectangle& rRect,
+ const Point& rStartAngle,
+ const Point& rEndAngle,
+ bool bDrawTo = false
+ );
+ void DrawPie(
+ const tools::Rectangle& rRect,
+ const Point& rStartAngle,
+ const Point& rEndAngle
+ );
+ void DrawChord(
+ const tools::Rectangle& rRect,
+ const Point& rStartAngle,
+ const Point& rEndAngle
+ );
+ void DrawPolygon(tools::Polygon rPolygon, bool bRecordPath);
+ void DrawPolyPolygon(tools::PolyPolygon& rPolyPolygon, bool bRecordPath = false);
+ void DrawPolyLine(tools::Polygon rPolygon,
+ bool bDrawTo = false,
+ bool bRecordPath = false
+ );
+ void DrawPolyBezier(tools::Polygon rPolygon,
+ bool bDrawTo,
+ bool bRecordPath
+ );
+ void DrawText(Point& rPosition,
+ OUString const & rString,
+ std::vector<sal_Int32>* pDXArry = nullptr,
+ tools::Long* pDYArry = nullptr,
+ bool bRecordPath = false,
+ GraphicsMode nGraphicsMode = GraphicsMode::GM_COMPATIBLE);
+
+ void ResolveBitmapActions(std::vector<BSaveStruct>& rSaveList);
+
+ void IntersectClipRect(const tools::Rectangle& rRect);
+ void ExcludeClipRect(const tools::Rectangle& rRect);
+ void MoveClipRegion(const Size& rSize);
+ void SetClipPath(
+ const tools::PolyPolygon& rPolyPoly,
+ RegionMode nClippingMode,
+ bool bIsMapped
+ );
+ void SetDefaultClipPath();
+ void UpdateClipRegion();
+ void AddFromGDIMetaFile(GDIMetaFile& rGDIMetaFile);
+
+ void PassEMFPlus(void const * pBuffer, sal_uInt32 nLength);
+ void PassEMFPlusHeaderInfo();
+
+ Color ReadColor();
+
+ explicit MtfTools(GDIMetaFile& rGDIMetaFile, SvStream& rStreamWMF);
+ ~MtfTools() COVERITY_NOEXCEPT_FALSE;
+ };
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-11 09:04:05 +0000