strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/emfio/inc/mtftools.hxx
Stephan Bergmann 16e3b84d2e Improve loplugin:dyncastvisibility to check for non-inline key functions 
This would have caught the issue discussed in
709b1f3ddb "Make sure VCLXPopupMenu has unique
RTTI".  (The commit message talks about RTTI there, while what Clang actually
compared for an optimized implementation of a dynamic_cast to a final class is
vtable pointers, but the overall picture remains the same.  Both RTTI and
vtables are emitted along the key function, and if that is missing or inline,
they are emitted for each dynamic library individually, and as internal symbols
on macOS.)

This commit also addresses all the issues found by the improved
loplugin:dyncastvisibility on Linux.  See the newly added TODO in
compilerplugins/clang/dyncastvisibility.cxx and
86b86ac87e "Give DocumentEventHolder (aka
EventHolder<DocumentEvent>) a key function" for an issue with key functions for
class template instantiations.

Change-Id: Ia19155efb1d23692c92b9c97ff17f18ae7a1f3ee
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/176576
Reviewed-by: Stephan Bergmann <stephan.bergmann@allotropia.de>
Tested-by: Jenkins
2024-11-14 12:49:22 +01:00

843 lines
29 KiB
C++
Raw Blame History

/* -*- 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 .
*/
#pragma once
#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,
// In [MS-WMF] 2.1.2.3, TA_BASELINE value is wrong.
// It is 0x0018 and it should be 0x0010.
TA_BASELINE = 0x0010,
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 EMFIO_DLLPUBLIC WinMtfFontStyle final : GDIObj
{
vcl::Font aFont;
explicit WinMtfFontStyle(LOGFONTW const & rLogFont);
~WinMtfFontStyle() override;
};
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);
Point GetWinOrg() { return Point(mnWinOrgX, mnWinOrgY); }
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,
KernArray* 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;
};
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in a new issue View git blame Copy permalink