strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/emfio/inc/mtftools.hxx
Bartosz Kosiorek 717bdd06a7 EMF Fix text aligning for EMR_SETTEXTALIGN for wrong values. 
Change-Id: I4d67eb7112d2295185905eac52ebab022a1beb78
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/151670
Tested-by: Jenkins
Reviewed-by: Bartosz Kosiorek <gang65@poczta.onet.pl>
2023-05-12 22:42:00 +02:00

841 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);
};
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