summaryrefslogtreecommitdiffstats
path: root/emfio/source
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:51:28 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:51:28 +0000
commit940b4d1848e8c70ab7642901a68594e8016caffc (patch)
treeeb72f344ee6c3d9b80a7ecc079ea79e9fba8676d /emfio/source
parentInitial commit. (diff)
downloadlibreoffice-940b4d1848e8c70ab7642901a68594e8016caffc.tar.xz
libreoffice-940b4d1848e8c70ab7642901a68594e8016caffc.zip
Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'emfio/source')
-rw-r--r--emfio/source/emfuno/emfuno.cxx46
-rw-r--r--emfio/source/emfuno/xemfparser.cxx237
-rw-r--r--emfio/source/emfuno/xemfparser.hxx49
-rw-r--r--emfio/source/reader/emfreader.cxx2188
-rw-r--r--emfio/source/reader/mtftools.cxx2244
-rw-r--r--emfio/source/reader/wmfreader.cxx1871
6 files changed, 6635 insertions, 0 deletions
diff --git a/emfio/source/emfuno/emfuno.cxx b/emfio/source/emfuno/emfuno.cxx
new file mode 100644
index 000000000..1bf9e098d
--- /dev/null
+++ b/emfio/source/emfuno/emfuno.cxx
@@ -0,0 +1,46 @@
+/* -*- 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 .
+ */
+
+#include <sal/config.h>
+
+#include <cppuhelper/factory.hxx>
+#include <cppuhelper/implementationentry.hxx>
+#include <sal/types.h>
+
+#include "xemfparser.hxx"
+
+namespace {
+
+static cppu::ImplementationEntry const services[] = {
+ { &emfio::emfreader::XEmfParser_createInstance,
+ &emfio::emfreader::XEmfParser_getImplementationName,
+ &emfio::emfreader::XEmfParser_getSupportedServiceNames,
+ &cppu::createSingleComponentFactory, nullptr, 0 },
+ { nullptr, nullptr, nullptr, nullptr, nullptr, 0 } };
+
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT void * emfio_component_getFactory(
+ char const * pImplName, void * pServiceManager, void * pRegistryKey)
+{
+ return cppu::component_getFactoryHelper(
+ pImplName, pServiceManager, pRegistryKey, services);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/emfio/source/emfuno/xemfparser.cxx b/emfio/source/emfuno/xemfparser.cxx
new file mode 100644
index 000000000..88a115f79
--- /dev/null
+++ b/emfio/source/emfuno/xemfparser.cxx
@@ -0,0 +1,237 @@
+/* -*- 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 .
+ */
+
+#include <sal/config.h>
+
+#include <com/sun/star/graphic/XEmfParser.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <cppuhelper/implbase2.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <comphelper/sequence.hxx>
+#include <drawinglayer/primitive2d/baseprimitive2d.hxx>
+
+#include <vcl/outdev.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/wmfexternal.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+#include <unotools/ucbstreamhelper.hxx>
+#include <drawinglayer/primitive2d/metafileprimitive2d.hxx>
+#include <sal/log.hxx>
+
+#include <wmfreader.hxx>
+#include <emfreader.hxx>
+
+#include "xemfparser.hxx"
+
+using namespace ::com::sun::star;
+
+namespace emfio::emfreader
+{
+ namespace {
+
+ class XEmfParser : public ::cppu::WeakAggImplHelper2< graphic::XEmfParser, lang::XServiceInfo >
+ {
+ private:
+ uno::Reference< uno::XComponentContext > context_;
+ basegfx::B2DTuple maSizeHint;
+
+ protected:
+ public:
+ explicit XEmfParser(
+ uno::Reference< uno::XComponentContext > const & context);
+ XEmfParser(const XEmfParser&) = delete;
+ XEmfParser& operator=(const XEmfParser&) = delete;
+
+ // XEmfParser
+ virtual uno::Sequence< uno::Reference< ::graphic::XPrimitive2D > > SAL_CALL getDecomposition(
+ const uno::Reference< ::io::XInputStream >& xEmfStream,
+ const OUString& aAbsolutePath,
+ const uno::Sequence< ::beans::PropertyValue >& rProperties) override;
+ void SAL_CALL setSizeHint(const geometry::RealPoint2D& rSize) override;
+
+ // XServiceInfo
+ virtual OUString SAL_CALL getImplementationName() override;
+ virtual sal_Bool SAL_CALL supportsService(const OUString&) override;
+ virtual uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+ };
+
+ }
+} // end of namespace emfio::emfreader
+
+// uno functions
+namespace emfio::emfreader
+{
+ uno::Sequence< OUString > XEmfParser_getSupportedServiceNames()
+ {
+ return uno::Sequence< OUString > { "com.sun.star.graphic.EmfTools" };
+ }
+
+ OUString XEmfParser_getImplementationName()
+ {
+ return "emfio::emfreader::XEmfParser";
+ }
+
+ uno::Reference< uno::XInterface > XEmfParser_createInstance(const uno::Reference< uno::XComponentContext >& context)
+ {
+ return static_cast< ::cppu::OWeakObject* >(new XEmfParser(context));
+ }
+} // end of namespace emfio::emfreader
+
+namespace emfio::emfreader
+{
+ XEmfParser::XEmfParser(
+ uno::Reference< uno::XComponentContext > const & context):
+ context_(context)
+ {
+ }
+
+ uno::Sequence< uno::Reference< ::graphic::XPrimitive2D > > XEmfParser::getDecomposition(
+ const uno::Reference< ::io::XInputStream >& xEmfStream,
+ const OUString& /*aAbsolutePath*/,
+ const uno::Sequence< ::beans::PropertyValue >& rProperties)
+ {
+ drawinglayer::primitive2d::Primitive2DContainer aRetval;
+
+ if (xEmfStream.is())
+ {
+ WmfExternal aExternalHeader;
+ const bool bExternalHeaderUsed(aExternalHeader.setSequence(rProperties));
+
+ // rough check - import and conv to primitive
+ GDIMetaFile aMtf;
+ std::unique_ptr<SvStream> pStream(::utl::UcbStreamHelper::CreateStream(xEmfStream));
+ sal_uInt32 nOrgPos = pStream->Tell();
+
+ SvStreamEndian nOrigNumberFormat = pStream->GetEndian();
+ pStream->SetEndian(SvStreamEndian::LITTLE);
+
+ sal_uInt32 nMetaType(0);
+ if (checkSeek(*pStream, 0x28))
+ pStream->ReadUInt32(nMetaType);
+ pStream->Seek(nOrgPos);
+
+ bool bReadError(false);
+
+ try
+ {
+ if (nMetaType == 0x464d4520)
+ {
+ // read and get possible failure/error, ReadEnhWMF returns success
+ emfio::EmfReader aReader(*pStream, aMtf);
+ aReader.SetSizeHint(maSizeHint);
+ bReadError = !aReader.ReadEnhWMF();
+ }
+ else
+ {
+ emfio::WmfReader(*pStream, aMtf, bExternalHeaderUsed ? &aExternalHeader : nullptr).ReadWMF();
+
+ // Need to check for ErrCode at stream to not lose former work.
+ // This may contain important information and will behave the
+ // same as before. When we have an error, do not create content
+ ErrCode aErrCode(pStream->GetError());
+
+ bReadError = aErrCode.IsError();
+ }
+ }
+ catch (...)
+ {
+ bReadError = true;
+ }
+
+ pStream->SetEndian(nOrigNumberFormat);
+
+ if (!bReadError)
+ {
+ Size aSize(aMtf.GetPrefSize());
+
+ if (aMtf.GetPrefMapMode().GetMapUnit() == MapUnit::MapPixel)
+ {
+ aSize = Application::GetDefaultDevice()->PixelToLogic(aSize, MapMode(MapUnit::Map100thMM));
+ }
+ else
+ {
+ aSize = OutputDevice::LogicToLogic(aSize, aMtf.GetPrefMapMode(), MapMode(MapUnit::Map100thMM));
+ }
+
+ // use size
+ const basegfx::B2DHomMatrix aMetafileTransform(
+ basegfx::utils::createScaleB2DHomMatrix(
+ aSize.Width(),
+ aSize.Height()));
+
+ // ...and create a single MetafilePrimitive2D containing the Metafile.
+ // CAUTION: Currently, ReadWindowMetafile uses the local VectorGraphicData
+ // and a MetafileAccessor hook at the MetafilePrimitive2D inside of
+ // ImpGraphic::ImplGetGDIMetaFile to get the Metafile. Thus, the first
+ // and only primitive in this case *has to be* a MetafilePrimitive2D.
+ aRetval.push_back(
+ new drawinglayer::primitive2d::MetafilePrimitive2D(
+ aMetafileTransform,
+ aMtf));
+
+ // // force to use decomposition directly to get rid of the metafile
+ // const css::uno::Sequence< css::beans::PropertyValue > aViewParameters;
+ // drawinglayer::primitive2d::MetafilePrimitive2D aMetafilePrimitive2D(
+ // aMetafileTransform,
+ // aMtf);
+ // aRetval.append(aMetafilePrimitive2D.getDecomposition(aViewParameters));
+
+ // if (aRetval.empty())
+ // {
+ // // for test, just create some graphic data that will get visualized
+ // const basegfx::B2DRange aRange(1000, 1000, 5000, 5000);
+ // const basegfx::BColor aColor(1.0, 0.0, 0.0);
+ // const basegfx::B2DPolygon aOutline(basegfx::utils::createPolygonFromRect(aRange));
+ //
+ // aRetval.push_back(new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(basegfx::B2DPolyPolygon(aOutline), aColor));
+ // }
+ }
+ }
+ else
+ {
+ SAL_WARN("emfio", "Invalid stream (!)");
+ }
+
+ return comphelper::containerToSequence(aRetval);
+ }
+
+ void XEmfParser::setSizeHint(const geometry::RealPoint2D& rSize)
+ {
+ maSizeHint.setX(rSize.X);
+ maSizeHint.setY(rSize.Y);
+ }
+
+ OUString SAL_CALL XEmfParser::getImplementationName()
+ {
+ return XEmfParser_getImplementationName();
+ }
+
+ sal_Bool SAL_CALL XEmfParser::supportsService(const OUString& rServiceName)
+ {
+ return cppu::supportsService(this, rServiceName);
+ }
+
+ uno::Sequence< OUString > SAL_CALL XEmfParser::getSupportedServiceNames()
+ {
+ return XEmfParser_getSupportedServiceNames();
+ }
+
+} // end of namespace emfio::emfreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/emfio/source/emfuno/xemfparser.hxx b/emfio/source/emfuno/xemfparser.hxx
new file mode 100644
index 000000000..426231d36
--- /dev/null
+++ b/emfio/source/emfuno/xemfparser.hxx
@@ -0,0 +1,49 @@
+/* -*- 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_SOURCE_EMFUNO_XEMFARSER_HXX
+#define INCLUDED_EMFIO_SOURCE_EMFUNO_XEMFARSER_HXX
+
+#include <sal/config.h>
+
+#include <com/sun/star/uno/Reference.hxx>
+#include <com/sun/star/uno/Sequence.hxx>
+
+namespace com::sun::star {
+ namespace uno {
+ class XComponentContext;
+ class XInterface;
+ }
+}
+
+namespace emfio::emfreader {
+
+css::uno::Reference< css::uno::XInterface >
+XEmfParser_createInstance( css::uno::Reference< css::uno::XComponentContext > const &);
+
+OUString XEmfParser_getImplementationName();
+
+css::uno::Sequence< OUString >
+XEmfParser_getSupportedServiceNames();
+
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/emfio/source/reader/emfreader.cxx b/emfio/source/reader/emfreader.cxx
new file mode 100644
index 000000000..fee0fdef6
--- /dev/null
+++ b/emfio/source/reader/emfreader.cxx
@@ -0,0 +1,2188 @@
+/* -*- 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 .
+ */
+
+#include <emfreader.hxx>
+#include <sal/log.hxx>
+#include <osl/diagnose.h>
+#include <vcl/dibtools.hxx>
+#include <o3tl/safeint.hxx>
+#include <tools/stream.hxx>
+#include <memory>
+#include <vcl/graph.hxx>
+#include <vcl/pdfread.hxx>
+
+#ifdef DBG_UTIL
+#include <vcl/pngwrite.hxx>
+#endif
+
+using namespace std;
+
+// GDI-Array
+
+#define EMR_HEADER 1
+#define EMR_POLYBEZIER 2
+#define EMR_POLYGON 3
+#define EMR_POLYLINE 4
+#define EMR_POLYBEZIERTO 5
+#define EMR_POLYLINETO 6
+#define EMR_POLYPOLYLINE 7
+#define EMR_POLYPOLYGON 8
+#define EMR_SETWINDOWEXTEX 9
+#define EMR_SETWINDOWORGEX 10
+#define EMR_SETVIEWPORTEXTEX 11
+#define EMR_SETVIEWPORTORGEX 12
+#define EMR_SETBRUSHORGEX 13
+#define EMR_EOF 14
+#define EMR_SETPIXELV 15
+#define EMR_SETMAPPERFLAGS 16
+#define EMR_SETMAPMODE 17
+#define EMR_SETBKMODE 18
+#define EMR_SETPOLYFILLMODE 19
+#define EMR_SETROP2 20
+#define EMR_SETSTRETCHBLTMODE 21
+#define EMR_SETTEXTALIGN 22
+#define EMR_SETCOLORADJUSTMENT 23
+#define EMR_SETTEXTCOLOR 24
+#define EMR_SETBKCOLOR 25
+#define EMR_OFFSETCLIPRGN 26
+#define EMR_MOVETOEX 27
+#define EMR_SETMETARGN 28
+#define EMR_EXCLUDECLIPRECT 29
+#define EMR_INTERSECTCLIPRECT 30
+#define EMR_SCALEVIEWPORTEXTEX 31
+#define EMR_SCALEWINDOWEXTEX 32
+#define EMR_SAVEDC 33
+#define EMR_RESTOREDC 34
+#define EMR_SETWORLDTRANSFORM 35
+#define EMR_MODIFYWORLDTRANSFORM 36
+#define EMR_SELECTOBJECT 37
+#define EMR_CREATEPEN 38
+#define EMR_CREATEBRUSHINDIRECT 39
+#define EMR_DELETEOBJECT 40
+#define EMR_ANGLEARC 41
+#define EMR_ELLIPSE 42
+#define EMR_RECTANGLE 43
+#define EMR_ROUNDRECT 44
+#define EMR_ARC 45
+#define EMR_CHORD 46
+#define EMR_PIE 47
+#define EMR_SELECTPALETTE 48
+#define EMR_CREATEPALETTE 49
+#define EMR_SETPALETTEENTRIES 50
+#define EMR_RESIZEPALETTE 51
+#define EMR_REALIZEPALETTE 52
+#define EMR_EXTFLOODFILL 53
+#define EMR_LINETO 54
+#define EMR_ARCTO 55
+#define EMR_POLYDRAW 56
+#define EMR_SETARCDIRECTION 57
+#define EMR_SETMITERLIMIT 58
+#define EMR_BEGINPATH 59
+#define EMR_ENDPATH 60
+#define EMR_CLOSEFIGURE 61
+#define EMR_FILLPATH 62
+#define EMR_STROKEANDFILLPATH 63
+#define EMR_STROKEPATH 64
+#define EMR_FLATTENPATH 65
+#define EMR_WIDENPATH 66
+#define EMR_SELECTCLIPPATH 67
+#define EMR_ABORTPATH 68
+
+#define EMR_COMMENT 70 // Contains arbitrary private data.
+// Comment Identifiers:
+#define EMR_COMMENT_EMFPLUS 0x2B464D45 // Contains embedded EMF+ records.
+#define EMR_COMMENT_EMFSPOOL 0x00000000 // Contains embedded EMFSPOOL records.
+#define EMR_COMMENT_PUBLIC 0x43494447 // Specify extensions to EMF processing.
+
+#define EMR_FILLRGN 71
+#define EMR_FRAMERGN 72
+#define EMR_INVERTRGN 73
+#define EMR_PAINTRGN 74
+#define EMR_EXTSELECTCLIPRGN 75
+#define EMR_BITBLT 76
+#define EMR_STRETCHBLT 77
+#define EMR_MASKBLT 78
+#define EMR_PLGBLT 79
+#define EMR_SETDIBITSTODEVICE 80
+#define EMR_STRETCHDIBITS 81
+#define EMR_EXTCREATEFONTINDIRECTW 82
+#define EMR_EXTTEXTOUTA 83
+#define EMR_EXTTEXTOUTW 84
+#define EMR_POLYBEZIER16 85
+#define EMR_POLYGON16 86
+#define EMR_POLYLINE16 87
+#define EMR_POLYBEZIERTO16 88
+#define EMR_POLYLINETO16 89
+#define EMR_POLYPOLYLINE16 90
+#define EMR_POLYPOLYGON16 91
+#define EMR_POLYDRAW16 92
+#define EMR_CREATEMONOBRUSH 93
+#define EMR_CREATEDIBPATTERNBRUSHPT 94
+#define EMR_EXTCREATEPEN 95
+#define EMR_POLYTEXTOUTA 96
+#define EMR_POLYTEXTOUTW 97
+
+// WINDOWS VERSION >= 0x400
+#define EMR_SETICMMODE 98
+#define EMR_CREATECOLORSPACE 99
+#define EMR_SETCOLORSPACE 100
+#define EMR_DELETECOLORSPACE 101
+#define EMR_GLSRECORD 102
+#define EMR_GLSBOUNDEDRECORD 103
+#define EMR_PIXELFORMAT 104
+
+// WINDOWS VERSION >= 0x500
+#define EMR_DRAWESCAPE 105
+#define EMR_EXTESCAPE 106
+#define EMR_STARTDOC 107
+#define EMR_SMALLTEXTOUT 108
+#define EMR_FORCEUFIMAPPING 109
+#define EMR_NAMEDESCAPE 110
+#define EMR_COLORCORRECTPALETTE 111
+#define EMR_SETICMPROFILEA 112
+#define EMR_SETICMPROFILEW 113
+#define EMR_ALPHABLEND 114
+#define EMR_ALPHADIBBLEND 115
+#define EMR_TRANSPARENTBLT 116
+#define EMR_TRANSPARENTDIB 117
+#define EMR_GRADIENTFILL 118
+#define EMR_SETLINKEDUFIS 119
+#define EMR_SETTEXTJUSTIFICATION 120
+
+#define PDF_SIGNATURE 0x50444620 // "PDF "
+
+namespace
+{
+
+const char *
+record_type_name(sal_uInt32 nRecType)
+{
+#ifndef SAL_LOG_INFO
+ (void) nRecType;
+ return "";
+#else
+ switch( nRecType )
+ {
+ case EMR_HEADER: return "HEADER";
+ case EMR_POLYBEZIER: return "POLYBEZIER";
+ case EMR_POLYGON: return "POLYGON";
+ case EMR_POLYLINE: return "POLYLINE";
+ case EMR_POLYBEZIERTO: return "POLYBEZIERTO";
+ case EMR_POLYLINETO: return "POLYLINETO";
+ case EMR_POLYPOLYLINE: return "POLYPOLYLINE";
+ case EMR_POLYPOLYGON: return "POLYPOLYGON";
+ case EMR_SETWINDOWEXTEX: return "SETWINDOWEXTEX";
+ case EMR_SETWINDOWORGEX: return "SETWINDOWORGEX";
+ case EMR_SETVIEWPORTEXTEX: return "SETVIEWPORTEXTEX";
+ case EMR_SETVIEWPORTORGEX: return "SETVIEWPORTORGEX";
+ case EMR_SETBRUSHORGEX: return "SETBRUSHORGEX";
+ case EMR_EOF: return "EOF";
+ case EMR_SETPIXELV: return "SETPIXELV";
+ case EMR_SETMAPPERFLAGS: return "SETMAPPERFLAGS";
+ case EMR_SETMAPMODE: return "SETMAPMODE";
+ case EMR_SETBKMODE: return "SETBKMODE";
+ case EMR_SETPOLYFILLMODE: return "SETPOLYFILLMODE";
+ case EMR_SETROP2: return "SETROP2";
+ case EMR_SETSTRETCHBLTMODE: return "SETSTRETCHBLTMODE";
+ case EMR_SETTEXTALIGN: return "SETTEXTALIGN";
+ case EMR_SETCOLORADJUSTMENT: return "SETCOLORADJUSTMENT";
+ case EMR_SETTEXTCOLOR: return "SETTEXTCOLOR";
+ case EMR_SETBKCOLOR: return "SETBKCOLOR";
+ case EMR_OFFSETCLIPRGN: return "OFFSETCLIPRGN";
+ case EMR_MOVETOEX: return "MOVETOEX";
+ case EMR_SETMETARGN: return "SETMETARGN";
+ case EMR_EXCLUDECLIPRECT: return "EXCLUDECLIPRECT";
+ case EMR_INTERSECTCLIPRECT: return "INTERSECTCLIPRECT";
+ case EMR_SCALEVIEWPORTEXTEX: return "SCALEVIEWPORTEXTEX";
+ case EMR_SCALEWINDOWEXTEX: return "SCALEWINDOWEXTEX";
+ case EMR_SAVEDC: return "SAVEDC";
+ case EMR_RESTOREDC: return "RESTOREDC";
+ case EMR_SETWORLDTRANSFORM: return "SETWORLDTRANSFORM";
+ case EMR_MODIFYWORLDTRANSFORM: return "MODIFYWORLDTRANSFORM";
+ case EMR_SELECTOBJECT: return "SELECTOBJECT";
+ case EMR_CREATEPEN: return "CREATEPEN";
+ case EMR_CREATEBRUSHINDIRECT: return "CREATEBRUSHINDIRECT";
+ case EMR_DELETEOBJECT: return "DELETEOBJECT";
+ case EMR_ANGLEARC: return "ANGLEARC";
+ case EMR_ELLIPSE: return "ELLIPSE";
+ case EMR_RECTANGLE: return "RECTANGLE";
+ case EMR_ROUNDRECT: return "ROUNDRECT";
+ case EMR_ARC: return "ARC";
+ case EMR_CHORD: return "CHORD";
+ case EMR_PIE: return "PIE";
+ case EMR_SELECTPALETTE: return "SELECTPALETTE";
+ case EMR_CREATEPALETTE: return "CREATEPALETTE";
+ case EMR_SETPALETTEENTRIES: return "SETPALETTEENTRIES";
+ case EMR_RESIZEPALETTE: return "RESIZEPALETTE";
+ case EMR_REALIZEPALETTE: return "REALIZEPALETTE";
+ case EMR_EXTFLOODFILL: return "EXTFLOODFILL";
+ case EMR_LINETO: return "LINETO";
+ case EMR_ARCTO: return "ARCTO";
+ case EMR_POLYDRAW: return "POLYDRAW";
+ case EMR_SETARCDIRECTION: return "SETARCDIRECTION";
+ case EMR_SETMITERLIMIT: return "SETMITERLIMIT";
+ case EMR_BEGINPATH: return "BEGINPATH";
+ case EMR_ENDPATH: return "ENDPATH";
+ case EMR_CLOSEFIGURE: return "CLOSEFIGURE";
+ case EMR_FILLPATH: return "FILLPATH";
+ case EMR_STROKEANDFILLPATH: return "STROKEANDFILLPATH";
+ case EMR_STROKEPATH: return "STROKEPATH";
+ case EMR_FLATTENPATH: return "FLATTENPATH";
+ case EMR_WIDENPATH: return "WIDENPATH";
+ case EMR_SELECTCLIPPATH: return "SELECTCLIPPATH";
+ case EMR_ABORTPATH: return "ABORTPATH";
+ case EMR_COMMENT: return "COMMENT";
+ case EMR_FILLRGN: return "FILLRGN";
+ case EMR_FRAMERGN: return "FRAMERGN";
+ case EMR_INVERTRGN: return "INVERTRGN";
+ case EMR_PAINTRGN: return "PAINTRGN";
+ case EMR_EXTSELECTCLIPRGN: return "EXTSELECTCLIPRGN";
+ case EMR_BITBLT: return "BITBLT";
+ case EMR_STRETCHBLT: return "STRETCHBLT";
+ case EMR_MASKBLT: return "MASKBLT";
+ case EMR_PLGBLT: return "PLGBLT";
+ case EMR_SETDIBITSTODEVICE: return "SETDIBITSTODEVICE";
+ case EMR_STRETCHDIBITS: return "STRETCHDIBITS";
+ case EMR_EXTCREATEFONTINDIRECTW: return "EXTCREATEFONTINDIRECTW";
+ case EMR_EXTTEXTOUTA: return "EXTTEXTOUTA";
+ case EMR_EXTTEXTOUTW: return "EXTTEXTOUTW";
+ case EMR_POLYBEZIER16: return "POLYBEZIER16";
+ case EMR_POLYGON16: return "POLYGON16";
+ case EMR_POLYLINE16: return "POLYLINE16";
+ case EMR_POLYBEZIERTO16: return "POLYBEZIERTO16";
+ case EMR_POLYLINETO16: return "POLYLINETO16";
+ case EMR_POLYPOLYLINE16: return "POLYPOLYLINE16";
+ case EMR_POLYPOLYGON16: return "POLYPOLYGON16";
+ case EMR_POLYDRAW16: return "POLYDRAW16";
+ case EMR_CREATEMONOBRUSH: return "CREATEMONOBRUSH";
+ case EMR_CREATEDIBPATTERNBRUSHPT: return "CREATEDIBPATTERNBRUSHPT";
+ case EMR_EXTCREATEPEN: return "EXTCREATEPEN";
+ case EMR_POLYTEXTOUTA: return "POLYTEXTOUTA";
+ case EMR_POLYTEXTOUTW: return "POLYTEXTOUTW";
+ case EMR_SETICMMODE: return "SETICMMODE";
+ case EMR_CREATECOLORSPACE: return "CREATECOLORSPACE";
+ case EMR_SETCOLORSPACE: return "SETCOLORSPACE";
+ case EMR_DELETECOLORSPACE: return "DELETECOLORSPACE";
+ case EMR_GLSRECORD: return "GLSRECORD";
+ case EMR_GLSBOUNDEDRECORD: return "GLSBOUNDEDRECORD";
+ case EMR_PIXELFORMAT: return "PIXELFORMAT";
+ case EMR_DRAWESCAPE: return "DRAWESCAPE";
+ case EMR_EXTESCAPE: return "EXTESCAPE";
+ case EMR_STARTDOC: return "STARTDOC";
+ case EMR_SMALLTEXTOUT: return "SMALLTEXTOUT";
+ case EMR_FORCEUFIMAPPING: return "FORCEUFIMAPPING";
+ case EMR_NAMEDESCAPE: return "NAMEDESCAPE";
+ case EMR_COLORCORRECTPALETTE: return "COLORCORRECTPALETTE";
+ case EMR_SETICMPROFILEA: return "SETICMPROFILEA";
+ case EMR_SETICMPROFILEW: return "SETICMPROFILEW";
+ case EMR_ALPHABLEND: return "ALPHABLEND";
+ case EMR_ALPHADIBBLEND: return "ALPHADIBBLEND";
+ case EMR_TRANSPARENTBLT: return "TRANSPARENTBLT";
+ case EMR_TRANSPARENTDIB: return "TRANSPARENTDIB";
+ case EMR_GRADIENTFILL: return "GRADIENTFILL";
+ case EMR_SETLINKEDUFIS: return "SETLINKEDUFIS";
+ case EMR_SETTEXTJUSTIFICATION: return "SETTEXTJUSTIFICATION";
+ default:
+ // Yes, return a pointer to a static buffer. This is a very
+ // local debugging output function, so no big deal.
+ static char buffer[11];
+ sprintf(buffer, "0x%08" SAL_PRIxUINT32, nRecType);
+ return buffer;
+ }
+#endif
+}
+
+struct BLENDFUNCTION
+{
+ unsigned char aBlendOperation;
+ unsigned char aBlendFlags;
+ unsigned char aSrcConstantAlpha;
+ unsigned char aAlphaFormat;
+
+ friend SvStream& operator>>(SvStream& rInStream, BLENDFUNCTION& rBlendFun);
+};
+
+SvStream& operator>>(SvStream& rInStream, BLENDFUNCTION& rBlendFun)
+{
+ rInStream.ReadUChar(rBlendFun.aBlendOperation);
+ rInStream.ReadUChar(rBlendFun.aBlendFlags);
+ rInStream.ReadUChar(rBlendFun.aSrcConstantAlpha);
+ rInStream.ReadUChar(rBlendFun.aAlphaFormat);
+ return rInStream;
+}
+
+bool ImplReadRegion( tools::PolyPolygon& rPolyPoly, SvStream& rStream, sal_uInt32 nLen )
+{
+ if (nLen == 0)
+ return false;
+
+ sal_uInt32 nHdSize, nType, nCount, nRgnSize, i;
+ rStream.ReadUInt32(nHdSize);
+ rStream.ReadUInt32(nType);
+ rStream.ReadUInt32(nCount);
+ rStream.ReadUInt32(nRgnSize);
+
+ if (!rStream.good() || nCount == 0 || nType != RDH_RECTANGLES)
+ return false;
+
+ sal_uInt32 nSize;
+ if (o3tl::checked_multiply<sal_uInt32>(nCount, 16, nSize))
+ return false;
+ if (o3tl::checked_add<sal_uInt32>(nSize, nHdSize - 16, nSize))
+ return false;
+ if (nLen < nSize)
+ return false;
+
+ sal_Int32 nx1, ny1, nx2, ny2;
+ for (i = 0; i < nCount; i++)
+ {
+ rStream.ReadInt32(nx1);
+ rStream.ReadInt32(ny1);
+ rStream.ReadInt32(nx2);
+ rStream.ReadInt32(ny2);
+
+ tools::Rectangle aRectangle(Point(nx1, ny1), Point(nx2, ny2));
+
+ tools::Polygon aPolygon(aRectangle);
+ tools::PolyPolygon aPolyPolyOr1(aPolygon);
+ tools::PolyPolygon aPolyPolyOr2(rPolyPoly);
+ rPolyPoly.GetUnion(aPolyPolyOr1, aPolyPolyOr2);
+ rPolyPoly = aPolyPolyOr2;
+ }
+ return true;
+}
+
+} // anonymous namespace
+
+namespace emfio
+{
+ EmfReader::EmfReader(SvStream& rStream,GDIMetaFile& rGDIMetaFile)
+ : MtfTools(rGDIMetaFile, rStream)
+ , mnRecordCount(0)
+ , mbRecordPath(false)
+ , mbEMFPlus(false)
+ , mbEMFPlusDualMode(false)
+ {
+ }
+
+ EmfReader::~EmfReader()
+ {
+ }
+
+ const sal_uInt32 EMR_COMMENT_BEGINGROUP = 0x00000002;
+ const sal_uInt32 EMR_COMMENT_ENDGROUP = 0x00000003;
+ const sal_uInt32 EMR_COMMENT_MULTIFORMATS = 0x40000004;
+ const sal_uInt32 EMR_COMMENT_WINDOWS_METAFILE = 0x80000001;
+
+ void EmfReader::ReadGDIComment(sal_uInt32 nCommentId)
+ {
+ sal_uInt32 nPublicCommentIdentifier;
+ mpInputStream->ReadUInt32(nPublicCommentIdentifier);
+
+ SAL_INFO("emfio", "\t\tEMR_COMMENT_PUBLIC, id: 0x" << std::hex << nCommentId << std::dec);
+ switch (nPublicCommentIdentifier)
+ {
+ case EMR_COMMENT_BEGINGROUP:
+ {
+ SAL_INFO("emfio", "\t\t\tEMR_COMMENT_BEGINGROUP");
+ sal_uInt32 left, top, right, bottom;
+ mpInputStream->ReadUInt32(left).ReadUInt32(top).ReadUInt32(right).ReadUInt32(bottom);
+
+ SAL_INFO("emfio", "\t\t\t\tBounding rect");
+ SAL_INFO("emfio", "\t\t\t\t\tLeft: " << left);
+ SAL_INFO("emfio", "\t\t\t\t\tTop: " << top);
+ SAL_INFO("emfio", "\t\t\t\t\tRight: " << right);
+ SAL_INFO("emfio", "\t\t\t\t\tBottom: " << bottom);
+
+ sal_uInt32 nDescChars;
+ mpInputStream->ReadUInt32(nDescChars);
+
+ OUString aDesc;
+ for (sal_uInt32 i=0; i < nDescChars; i++)
+ {
+ sal_uInt16 cChar(0);
+ mpInputStream->ReadUInt16(cChar);
+ if (cChar == '\0')
+ break;
+
+ sal_Unicode cUniChar = static_cast<sal_Unicode>(cChar);
+ aDesc = aDesc.concat(OUString(cUniChar));
+ }
+
+ SAL_INFO("emfio", "\t\tDescription: " << aDesc);
+ }
+ break;
+
+ case EMR_COMMENT_ENDGROUP:
+ SAL_INFO("emfio", "\t\t\tEMR_COMMENT_ENDGROUP");
+ break;
+
+ case EMR_COMMENT_MULTIFORMATS:
+ ReadMultiformatsComment();
+ break;
+
+ case EMR_COMMENT_WINDOWS_METAFILE:
+ SAL_WARN("emfio", "\t\tEMR_COMMENT_WINDOWS_METAFILE not implemented");
+ break;
+
+ default:
+ SAL_WARN("emfio", "\t\tEMR_COMMENT_PUBLIC not implemented, id: 0x" << std::hex << nCommentId << std::dec);
+ break;
+ }
+ }
+
+ void EmfReader::ReadMultiformatsComment()
+ {
+ tools::Rectangle aOutputRect = EmfReader::ReadRectangle();
+
+ sal_uInt32 nCountFormats;
+ mpInputStream->ReadUInt32(nCountFormats);
+ if (nCountFormats < 1)
+ {
+ return;
+ }
+
+ // Read the first EmrFormat.
+ sal_uInt32 nSignature;
+ mpInputStream->ReadUInt32(nSignature);
+ if (nSignature != PDF_SIGNATURE)
+ {
+ return;
+ }
+
+ sal_uInt32 nVersion;
+ mpInputStream->ReadUInt32(nVersion);
+ if (nVersion != 1)
+ {
+ return;
+ }
+
+ sal_uInt32 nSizeData;
+ mpInputStream->ReadUInt32(nSizeData);
+ if (!nSizeData || nSizeData > mpInputStream->remainingSize())
+ {
+ return;
+ }
+
+ sal_uInt32 nOffData;
+ mpInputStream->ReadUInt32(nOffData);
+ if (!nOffData)
+ {
+ return;
+ }
+
+ std::vector<char> aPdfData(nSizeData);
+ mpInputStream->ReadBytes(aPdfData.data(), aPdfData.size());
+ if (!mpInputStream->good())
+ {
+ return;
+ }
+
+ SvMemoryStream aPdfStream;
+ aPdfStream.WriteBytes(aPdfData.data(), aPdfData.size());
+ aPdfStream.Seek(0);
+ Graphic aGraphic;
+ if (!vcl::ImportPDF(aPdfStream, aGraphic))
+ {
+ return;
+ }
+
+ // aGraphic will be the only output of the EMF parser, so its size hint can be the same as
+ // ours.
+ aGraphic.getVectorGraphicData()->setSizeHint(maSizeHint);
+
+ maBmpSaveList.emplace_back(new BSaveStruct(aGraphic.GetBitmapEx(), aOutputRect, SRCCOPY));
+ const std::shared_ptr<VectorGraphicData> pVectorGraphicData
+ = aGraphic.getVectorGraphicData();
+ if (!pVectorGraphicData)
+ {
+ return;
+ }
+
+ if (pVectorGraphicData->getVectorGraphicDataType() != VectorGraphicDataType::Pdf)
+ {
+ return;
+ }
+
+ mbReadOtherGraphicFormat = true;
+ }
+
+ void EmfReader::ReadEMFPlusComment(sal_uInt32 length, bool& bHaveDC)
+ {
+ if (!mbEMFPlus)
+ {
+ PassEMFPlusHeaderInfo();
+
+ #if OSL_DEBUG_LEVEL > 1
+ // debug code - write the stream to debug file /tmp/emf-stream.emf
+ sal_uInt64 const pos = mpInputStream->Tell();
+ mpInputStream->Seek(0);
+ SvFileStream file( OUString( "/tmp/emf-stream.emf" ), StreamMode::WRITE | StreamMode::TRUNC );
+
+ mpInputStream->WriteStream(file);
+ file.Flush();
+ file.Close();
+
+ mpInputStream->Seek( pos );
+ #endif
+
+ }
+
+ mbEMFPlus = true;
+ sal_uInt64 const pos = mpInputStream->Tell();
+ auto buffer = std::make_unique<char[]>( length );
+ PassEMFPlus( buffer.get(), mpInputStream->ReadBytes(buffer.get(), length) );
+ buffer.reset();
+ mpInputStream->Seek( pos );
+
+ bHaveDC = false;
+
+ // skip in SeekRel if impossibly unavailable
+ sal_uInt32 nRemainder = length;
+
+ const size_t nRequiredHeaderSize = 12;
+ while (nRemainder >= nRequiredHeaderSize)
+ {
+ sal_uInt16 type(0), flags(0);
+ sal_uInt32 size(0), dataSize(0);
+
+ mpInputStream->ReadUInt16( type ).ReadUInt16( flags ).ReadUInt32( size ).ReadUInt32( dataSize );
+ nRemainder -= nRequiredHeaderSize;
+
+ SAL_INFO("emfio", "\t\tEMF+ record type: 0x" << std::hex << type << std::dec);
+
+ // Get Device Context
+ // TODO We should use EmfPlusRecordType::GetDC instead
+ if( type == 0x4004 )
+ {
+ bHaveDC = true;
+ SAL_INFO("emfio", "\t\tEMF+ lock DC (device context)");
+ }
+
+ // look for the "dual mode" in header
+ // it indicates that either EMF or EMF+ records should be processed
+ // 0x4001 = EMF+ header
+ // flags & 1 = dual mode active
+ if ( type == 0x4001 && flags & 1 )
+ {
+ mbEMFPlusDualMode = true;
+ SAL_INFO ("emfio", "\t\tEMF+ dual mode detected");
+ }
+
+ // Get the length of the remaining data of this record based
+ // on the alleged size
+ sal_uInt32 nRemainingRecordData = size >= nRequiredHeaderSize ?
+ size-nRequiredHeaderSize : 0;
+ // clip to available size
+ nRemainingRecordData = std::min(nRemainingRecordData, nRemainder);
+ mpInputStream->SeekRel(nRemainingRecordData);
+ nRemainder -= nRemainingRecordData;
+ }
+ mpInputStream->SeekRel(nRemainder);
+ }
+
+ // these are referenced from inside the templates
+ static SvStream& operator >> (SvStream& rStream, sal_Int16 &n)
+ {
+ return rStream.ReadInt16(n);
+ }
+
+ static SvStream& operator >> (SvStream& rStream, sal_Int32 &n)
+ {
+ return rStream.ReadInt32(n);
+ }
+
+ /**
+ * Reads polygons from the stream.
+ * The \<class T> parameter is for the type of the points (sal_uInt32 or sal_uInt16).
+ * skipFirst: if the first point read is the 0th point or the 1st point in the array.
+ * */
+ template <class T>
+ tools::Polygon EmfReader::ReadPolygonWithSkip(const bool skipFirst, sal_uInt32 nNextPos)
+ {
+ sal_uInt32 nPoints(0), nStartIndex(0);
+ mpInputStream->SeekRel( 16 );
+ mpInputStream->ReadUInt32( nPoints );
+ if (skipFirst)
+ {
+ nPoints ++;
+ nStartIndex ++;
+ }
+
+ return ReadPolygon<T>(nStartIndex, nPoints, nNextPos);
+ }
+
+ /**
+ * Reads polygons from the stream.
+ * The \<class T> parameter is for the type of the points
+ * nStartIndex: which is the starting index in the polygon of the first point read
+ * nPoints: number of points
+ * mpInputStream: the stream containing the polygons
+ * */
+ template <class T>
+ tools::Polygon EmfReader::ReadPolygon(sal_uInt32 nStartIndex, sal_uInt32 nPoints, sal_uInt32 nNextPos)
+ {
+ SAL_INFO ("emfio", "\t\tPolygon:");
+
+ bool bRecordOk = nPoints <= SAL_MAX_UINT16;
+ SAL_WARN_IF(!bRecordOk, "emfio", "polygon record has more polygons than we can handle");
+ if (!bRecordOk || !nPoints)
+ return tools::Polygon();
+
+ auto nRemainingSize = std::min(nNextPos - mpInputStream->Tell(), mpInputStream->remainingSize());
+ auto nMaxPossiblePoints = nRemainingSize / (sizeof(T) * 2);
+ auto nPointCount = nPoints - nStartIndex;
+ if (nPointCount > nMaxPossiblePoints)
+ {
+ SAL_WARN("emfio", "polygon claims more points than record can provide, truncating");
+ nPoints = nMaxPossiblePoints + nStartIndex;
+ }
+
+ tools::Polygon aPolygon(nPoints);
+ for (sal_uInt32 i = nStartIndex ; i < nPoints && mpInputStream->good(); i++ )
+ {
+ T nX, nY;
+ *mpInputStream >> nX >> nY;
+
+ SAL_INFO("emfio", "\t\t\tPoint " << i << " of " << nPoints - 1 << ": " << nX << ", " << nY);
+
+ if (!mpInputStream->good())
+ {
+ SAL_WARN("emfio", "short read on polygon, truncating");
+ aPolygon.SetSize(i);
+ break;
+ }
+ aPolygon[ i ] = Point( nX, nY );
+ }
+
+ return aPolygon;
+ }
+
+ /**
+ * Reads a polyline from the WMF file and draws it
+ * The \<class T> parameter refers to the type of the points. (e.g. sal_uInt16 or sal_uInt32)
+ * */
+ template <class T>
+ void EmfReader::ReadAndDrawPolyLine(sal_uInt32 nNextPos)
+ {
+ SAL_INFO("emfio", "\t\tPolyline: ");
+
+ mpInputStream->SeekRel( 0x10 ); // TODO Skipping Bounds. A 128-bit WMF RectL object (specifies the bounding rectangle in device units.)
+
+ sal_uInt32 nNumberOfPolylines = 0;
+ mpInputStream->ReadUInt32( nNumberOfPolylines );
+ SAL_INFO("emfio", "\t\t\tPolylines: " << nNumberOfPolylines);
+
+ sal_uInt32 nCount = 0;
+ mpInputStream->ReadUInt32( nCount ); // total number of points in all polylines
+ SAL_INFO("emfio", "\t\t\tPoints: " << nCount);
+
+ const auto nEndPos = std::min(nNextPos, mnEndPos);
+ if (mpInputStream->Tell() >= nEndPos)
+ return;
+
+ // taking the amount of points of each polygon, retrieving the total number of points
+ if ( !(mpInputStream->good() &&
+ ( nNumberOfPolylines < SAL_MAX_UINT32 / sizeof( sal_uInt16 ) ) &&
+ ( nNumberOfPolylines * sizeof( sal_uInt16 ) ) <= ( nEndPos - mpInputStream->Tell() ))
+ )
+ return;
+
+ std::unique_ptr< sal_uInt32[] > pnPolylinePointCount( new sal_uInt32[ nNumberOfPolylines ] );
+ for ( sal_uInt32 i = 0; i < nNumberOfPolylines && mpInputStream->good(); i++ )
+ {
+ sal_uInt32 nPoints;
+ mpInputStream->ReadUInt32( nPoints );
+ SAL_INFO("emfio", "\t\t\tPoint " << i << " of " << nNumberOfPolylines << ": " << nPoints);
+ pnPolylinePointCount[ i ] = nPoints;
+ }
+
+ // Get polyline points:
+ for ( sal_uInt32 i = 0; ( i < nNumberOfPolylines ) && mpInputStream->good(); i++ )
+ {
+ tools::Polygon aPolygon = ReadPolygon<T>(0, pnPolylinePointCount[i], nNextPos);
+ DrawPolyLine(aPolygon, false, mbRecordPath);
+ }
+ }
+
+ /**
+ * Reads a poly polygon from the WMF file and draws it.
+ * The \<class T> parameter refers to the type of the points. (e.g. sal_uInt16 or sal_uInt32)
+ * */
+ template <class T>
+ void EmfReader::ReadAndDrawPolyPolygon(sal_uInt32 nNextPos)
+ {
+ SAL_INFO("emfio", "\t\tPolygon: ");
+ mpInputStream->SeekRel( 0x10 ); // RectL bounds
+
+ sal_uInt32 nPoly(0), nGesPoints(0), nReadPoints(0);
+ // Number of polygons
+ mpInputStream->ReadUInt32( nPoly ).ReadUInt32( nGesPoints );
+ SAL_INFO("emfio", "\t\t\tPolygons: " << nPoly);
+ SAL_INFO("emfio", "\t\t\tPoints: " << nGesPoints);
+
+ const auto nEndPos = std::min(nNextPos, mnEndPos);
+ if (mpInputStream->Tell() >= nEndPos)
+ return;
+ if (!mpInputStream->good())
+ return;
+ //check against numeric overflowing
+ if (nGesPoints >= SAL_MAX_UINT32 / sizeof(Point))
+ return;
+ if (nPoly >= SAL_MAX_UINT32 / sizeof(sal_uInt16))
+ return;
+ if (nPoly * sizeof(sal_uInt16) > nEndPos - mpInputStream->Tell())
+ return;
+
+ // Get number of points in each polygon
+ std::vector<sal_uInt16> aPoints(nPoly);
+ for (sal_uInt32 i = 0; i < nPoly && mpInputStream->good(); ++i)
+ {
+ sal_uInt32 nPoints(0);
+ mpInputStream->ReadUInt32( nPoints );
+
+ SAL_INFO("emfio", "\t\t\t\tPolygon " << i << " points: " << nPoints);
+
+ aPoints[i] = static_cast<sal_uInt16>(nPoints);
+ }
+
+ if ( mpInputStream->good() && ( nGesPoints * (sizeof(T)+sizeof(T)) ) <= ( nEndPos - mpInputStream->Tell() ) )
+ {
+ // Get polygon points
+ tools::PolyPolygon aPolyPoly(nPoly);
+ for (sal_uInt32 i = 0; i < nPoly && mpInputStream->good(); ++i)
+ {
+ const sal_uInt16 nPointCount(aPoints[i]);
+ std::vector<Point> aPtAry(nPointCount);
+ for (sal_uInt16 j = 0; j < nPointCount && mpInputStream->good(); ++j)
+ {
+ T nX(0), nY(0);
+ *mpInputStream >> nX >> nY;
+ aPtAry[j] = Point( nX, nY );
+ ++nReadPoints;
+ }
+
+ aPolyPoly.Insert(tools::Polygon(aPtAry.size(), aPtAry.data()));
+ }
+
+ DrawPolyPolygon(aPolyPoly, mbRecordPath);
+ }
+
+ OSL_ENSURE(nReadPoints == nGesPoints, "The number Points processed from EMR_POLYPOLYGON is unequal imported number (!)");
+ }
+
+ bool EmfReader::ReadEnhWMF()
+ {
+ sal_uInt32 nStretchBltMode = 0;
+ sal_uInt32 nNextPos(0),
+ nW(0), nH(0), nColor(0), nIndex(0),
+ nDat32(0), nNom1(0), nDen1(0), nNom2(0), nDen2(0);
+ sal_Int32 nX32(0), nY32(0), nx32(0), ny32(0);
+
+ bool bStatus = ReadHeader();
+ bool bHaveDC = false;
+
+ static bool bEnableEMFPlus = ( getenv( "EMF_PLUS_DISABLE" ) == nullptr );
+
+ SAL_INFO("emfio", "EMF_PLUS_DISABLE is " << (bEnableEMFPlus ? "enabled" : "disabled"));
+
+ while (bStatus && mnRecordCount-- && mpInputStream->good() && !mbReadOtherGraphicFormat)
+ {
+ sal_uInt32 nRecType(0), nRecSize(0);
+ mpInputStream->ReadUInt32(nRecType).ReadUInt32(nRecSize);
+
+ if ( !mpInputStream->good() || ( nRecSize < 8 ) || ( nRecSize & 3 ) ) // Parameters are always divisible by 4
+ {
+ bStatus = false;
+ break;
+ }
+
+ auto nCurPos = mpInputStream->Tell();
+
+ if (mnEndPos < nCurPos - 8)
+ {
+ bStatus = false;
+ break;
+ }
+
+ const sal_uInt32 nMaxPossibleRecSize = mnEndPos - (nCurPos - 8);
+ if (nRecSize > nMaxPossibleRecSize)
+ {
+ bStatus = false;
+ break;
+ }
+
+ nNextPos = nCurPos + (nRecSize - 8);
+
+ if( !maBmpSaveList.empty()
+ && ( nRecType != EMR_STRETCHBLT )
+ && ( nRecType != EMR_STRETCHDIBITS )
+ ) {
+ ResolveBitmapActions( maBmpSaveList );
+ }
+
+ bool bFlag = false;
+
+ SAL_INFO("emfio", "0x" << std::hex << (nNextPos - nRecSize) << "-0x" << nNextPos << " " << record_type_name(nRecType) << " size: "
+ << std::dec << nRecSize);
+
+ if( bEnableEMFPlus && nRecType == EMR_COMMENT )
+ {
+ sal_uInt32 length;
+
+ mpInputStream->ReadUInt32( length );
+
+ SAL_INFO("emfio", "\tGDI comment, length: " << length);
+
+ if( mpInputStream->good() && length >= 4 && length <= mpInputStream->remainingSize() ) {
+ sal_uInt32 nCommentId;
+
+ mpInputStream->ReadUInt32( nCommentId );
+
+ SAL_INFO("emfio", "\t\tbegin " << static_cast<char>(nCommentId & 0xff) << static_cast<char>((nCommentId & 0xff00) >> 8) << static_cast<char>((nCommentId & 0xff0000) >> 16) << static_cast<char>((nCommentId & 0xff000000) >> 24) << " id: 0x" << std::hex << nCommentId << std::dec);
+
+ if( nCommentId == EMR_COMMENT_EMFPLUS && nRecSize >= 12 )
+ {
+ // [MS-EMF] 2.3.3: DataSize includes both CommentIdentifier and CommentRecordParm fields.
+ // We have already read 4-byte CommentIdentifier, so reduce length appropriately
+ ReadEMFPlusComment( length-4, bHaveDC );
+ }
+ else if( nCommentId == EMR_COMMENT_PUBLIC && nRecSize >= 12 )
+ {
+ ReadGDIComment(nCommentId);
+ }
+ else if( nCommentId == EMR_COMMENT_EMFSPOOL && nRecSize >= 12 )
+ {
+ SAL_WARN("emfio", "\t\tEMFSPOOL not implemented, id: 0x" << std::hex << nCommentId << std::dec);
+ // TODO Implement reading EMFSPOOL comment
+
+ }
+ else
+ {
+ SAL_WARN("emfio", "\t\tunknown id: 0x" << std::hex << nCommentId << std::dec);
+ }
+ }
+ }
+ else if ( !bHaveDC && mbEMFPlusDualMode && nRecType != EMR_HEADER && nRecType != EMR_EOF )
+ {
+ // skip content (EMF record) in dual mode
+ // we process only EMR_COMMENT (see above) to access EMF+ data
+ // with 2 exceptions, according to EMF+ specification:
+ // EMR_HEADER and EMR_EOF
+ // if a device context is given (bHaveDC) process the following EMF record, too.
+ }
+ else if( !mbEMFPlus || bHaveDC || nRecType == EMR_EOF )
+ {
+ switch( nRecType )
+ {
+ case EMR_POLYBEZIERTO :
+ DrawPolyBezier(ReadPolygonWithSkip<sal_Int32>(true, nNextPos), true, mbRecordPath);
+ break;
+ case EMR_POLYBEZIER :
+ DrawPolyBezier(ReadPolygonWithSkip<sal_Int32>(false, nNextPos), false, mbRecordPath);
+ break;
+
+ case EMR_POLYGON :
+ DrawPolygon(ReadPolygonWithSkip<sal_Int32>(false, nNextPos), mbRecordPath);
+ break;
+
+ case EMR_POLYLINETO :
+ DrawPolyLine(ReadPolygonWithSkip<sal_Int32>(true, nNextPos), true, mbRecordPath);
+ break;
+
+ case EMR_POLYLINE :
+ DrawPolyLine(ReadPolygonWithSkip<sal_Int32>(false, nNextPos), false, mbRecordPath);
+ break;
+
+ case EMR_POLYPOLYLINE :
+ ReadAndDrawPolyLine<sal_Int32>(nNextPos);
+ break;
+
+ case EMR_POLYPOLYGON :
+ ReadAndDrawPolyPolygon<sal_Int32>(nNextPos);
+ break;
+
+ case EMR_SETWINDOWEXTEX :
+ {
+ sal_Int32 w = 0, h = 0;
+ mpInputStream->ReadInt32( w ).ReadInt32( h );
+ SAL_INFO("emfio", "\t\tWidth: " << w);
+ SAL_INFO("emfio", "\t\tHeight: " << h);
+ SetWinExt( Size( w, h ), true);
+ }
+ break;
+
+ case EMR_SETWINDOWORGEX :
+ {
+ mpInputStream->ReadInt32( nX32 ).ReadInt32( nY32 );
+ SAL_INFO("emfio", "\t\tPoint: (" << nX32 << ", " << nY32 << ")");
+ SetWinOrg( Point( nX32, nY32 ), true);
+ }
+ break;
+
+ case EMR_SCALEWINDOWEXTEX :
+ {
+ mpInputStream->ReadUInt32( nNom1 ).ReadUInt32( nDen1 ).ReadUInt32( nNom2 ).ReadUInt32( nDen2 );
+ SAL_INFO("emfio", "\t\tHorizontal scale: " << nNom1 << " / " << nDen1);
+ SAL_INFO("emfio", "\t\tVertical scale: " << nNom2 << " / " << nDen2);
+
+ if (nDen1 != 0 && nDen2 != 0)
+ ScaleWinExt( static_cast<double>(nNom1) / nDen1, static_cast<double>(nNom2) / nDen2 );
+ else
+ SAL_WARN("vcl.emf", "ignoring bogus divide by zero");
+ }
+ break;
+
+ case EMR_SETVIEWPORTORGEX :
+ {
+ mpInputStream->ReadInt32( nX32 ).ReadInt32( nY32 );
+ SAL_INFO("emfio", "\t\tPoint: (" << nX32 << ", " << nY32 << ")");
+ SetDevOrg( Point( nX32, nY32 ) );
+ }
+ break;
+
+ case EMR_SCALEVIEWPORTEXTEX :
+ {
+ mpInputStream->ReadUInt32( nNom1 ).ReadUInt32( nDen1 ).ReadUInt32( nNom2 ).ReadUInt32( nDen2 );
+ SAL_INFO("emfio", "\t\tHorizontal scale: " << nNom1 << " / " << nDen1);
+ SAL_INFO("emfio", "\t\tVertical scale: " << nNom2 << " / " << nDen2);
+
+ if (nDen1 != 0 && nDen2 != 0)
+ ScaleDevExt( static_cast<double>(nNom1) / nDen1, static_cast<double>(nNom2) / nDen2 );
+ else
+ SAL_WARN("vcl.emf", "ignoring bogus divide by zero");
+ }
+ break;
+
+ case EMR_SETVIEWPORTEXTEX :
+ {
+ sal_Int32 w = 0, h = 0;
+ mpInputStream->ReadInt32( w ).ReadInt32( h );
+ SAL_INFO("emfio", "\t\tWidth: " << w);
+ SAL_INFO("emfio", "\t\tHeight: " << h);
+
+ SetDevExt( Size( w, h ) );
+ }
+ break;
+
+ case EMR_EOF :
+ mnRecordCount = 0;
+ break;
+
+ case EMR_SETPIXELV :
+ {
+ mpInputStream->ReadInt32( nX32 ).ReadInt32( nY32 );
+ SAL_INFO("emfio", "\t\tPoint: (" << nX32 << ", " << nY32 << ")");
+ DrawPixel( Point( nX32, nY32 ), ReadColor() );
+ }
+ break;
+
+ case EMR_SETMAPMODE :
+ {
+ sal_uInt32 nMapMode;
+ mpInputStream->ReadUInt32( nMapMode );
+ SAL_INFO("emfio", "\t\tMapMode: 0x" << std::hex << nMapMode << std::dec);
+ SetMapMode( nMapMode );
+ }
+ break;
+
+ case EMR_SETBKMODE :
+ {
+ mpInputStream->ReadUInt32( nDat32 );
+ SAL_INFO("emfio", "\t\tBkMode: 0x" << std::hex << nDat32 << std::dec);
+ SetBkMode( static_cast<BkMode>(nDat32) );
+ }
+ break;
+
+ case EMR_SETPOLYFILLMODE :
+ break;
+
+ case EMR_SETROP2 :
+ {
+ mpInputStream->ReadUInt32( nDat32 );
+ SAL_INFO("emfio", "\t\tROP2: 0x" << std::hex << nDat32 << std::dec);
+ SetRasterOp( static_cast<WMFRasterOp>(nDat32) );
+ }
+ break;
+
+ case EMR_SETSTRETCHBLTMODE :
+ {
+ mpInputStream->ReadUInt32( nStretchBltMode );
+ SAL_INFO("emfio", "\t\tStretchBltMode: 0x" << std::hex << nDat32 << std::dec);
+ }
+ break;
+
+ case EMR_SETTEXTALIGN :
+ {
+ mpInputStream->ReadUInt32( nDat32 );
+ SAL_INFO("emfio", "\t\tTextAlign: 0x" << std::hex << nDat32 << std::dec);
+ SetTextAlign( nDat32 );
+ }
+ break;
+
+ case EMR_SETTEXTCOLOR :
+ {
+ SetTextColor( ReadColor() );
+ }
+ break;
+
+ case EMR_SETBKCOLOR :
+ {
+ SetBkColor( ReadColor() );
+ }
+ break;
+
+ case EMR_OFFSETCLIPRGN :
+ {
+ mpInputStream->ReadInt32( nX32 ).ReadInt32( nY32 );
+ SAL_INFO("emfio", "\t\tPoint: (" << nX32 << ", " << nY32 << ")");
+ MoveClipRegion( Size( nX32, nY32 ) );
+ }
+ break;
+
+ case EMR_MOVETOEX :
+ {
+ mpInputStream->ReadInt32( nX32 ).ReadInt32( nY32 );
+ SAL_INFO("emfio", "\t\tPoint: (" << nX32 << ", " << nY32 << ")");
+ MoveTo( Point( nX32, nY32 ), mbRecordPath);
+ }
+ break;
+
+ case EMR_INTERSECTCLIPRECT :
+ {
+ mpInputStream->ReadInt32( nX32 ).ReadInt32( nY32 ).ReadInt32( nx32 ).ReadInt32( ny32 );
+ IntersectClipRect( ReadRectangle( nX32, nY32, nx32, ny32 ) );
+ SAL_INFO("emfio", "\t\tPoint: (" << nX32 << ", " << nY32 << ")");
+ SAL_INFO("emfio", "\t\tPoint: (" << nx32 << ", " << ny32 << ")");
+ }
+ break;
+
+ case EMR_SAVEDC :
+ {
+ Push();
+ }
+ break;
+
+ case EMR_RESTOREDC :
+ {
+ Pop();
+ }
+ break;
+
+ case EMR_SETWORLDTRANSFORM :
+ {
+ XForm aTempXForm;
+ *mpInputStream >> aTempXForm;
+ SetWorldTransform( aTempXForm );
+ }
+ break;
+
+ case EMR_MODIFYWORLDTRANSFORM :
+ {
+ sal_uInt32 nMode;
+ XForm aTempXForm;
+ *mpInputStream >> aTempXForm;
+ mpInputStream->ReadUInt32( nMode );
+ ModifyWorldTransform( aTempXForm, nMode );
+ }
+ break;
+
+ case EMR_SELECTOBJECT :
+ {
+ mpInputStream->ReadUInt32( nIndex );
+ SelectObject( nIndex );
+ }
+ break;
+
+ case EMR_CREATEPEN :
+ {
+ mpInputStream->ReadUInt32( nIndex );
+ if ( ( nIndex & ENHMETA_STOCK_OBJECT ) == 0 )
+ {
+ LineInfo aLineInfo;
+ sal_uInt32 nStyle;
+ sal_Int32 nPenWidth, nIgnored;
+
+ mpInputStream->ReadUInt32( nStyle ).ReadInt32( nPenWidth ).ReadInt32( nIgnored );
+
+ SAL_INFO("emfio", "\t\tIndex: " << nIndex << " nStyle: 0x" << std::hex << nStyle << std::dec << " nPenWidth: " << nPenWidth);
+ // nStyle = PS_COSMETIC = 0x0 - line with a width of one logical unit and a style that is a solid color
+ if ( !nStyle )
+ {
+ // Width 0 means default width for LineInfo (HairLine) with 1 pixel wide
+ aLineInfo.SetWidth( 0 );
+ }
+ else
+ {
+ aLineInfo.SetWidth( nPenWidth );
+ }
+
+ bool bTransparent = false;
+ 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 :
+ bTransparent = true;
+ aLineInfo.SetStyle( LineStyle::NONE );
+ break;
+ case PS_INSIDEFRAME :
+ case PS_SOLID :
+ default :
+ aLineInfo.SetStyle( LineStyle::Solid );
+ }
+ switch( nStyle & PS_ENDCAP_STYLE_MASK )
+ {
+ case PS_ENDCAP_ROUND :
+ if ( nPenWidth )
+ {
+ aLineInfo.SetLineCap( css::drawing::LineCap_ROUND );
+ break;
+ }
+ [[fallthrough]];
+ case PS_ENDCAP_SQUARE :
+ if ( nPenWidth )
+ {
+ aLineInfo.SetLineCap( css::drawing::LineCap_SQUARE );
+ break;
+ }
+ [[fallthrough]];
+ case PS_ENDCAP_FLAT :
+ default :
+ 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_MITER :
+ aLineInfo.SetLineJoin ( basegfx::B2DLineJoin::Miter );
+ break;
+ case PS_JOIN_BEVEL :
+ aLineInfo.SetLineJoin ( basegfx::B2DLineJoin::Bevel );
+ break;
+ default :
+ aLineInfo.SetLineJoin ( basegfx::B2DLineJoin::NONE );
+ }
+ CreateObjectIndexed(nIndex, std::make_unique<WinMtfLineStyle>( ReadColor(), aLineInfo, bTransparent ));
+ }
+ }
+ break;
+
+ case EMR_EXTCREATEPEN :
+ {
+ sal_Int32 elpHatch;
+ sal_uInt32 offBmi, cbBmi, offBits, cbBits, nStyle, nWidth, nBrushStyle, elpNumEntries;
+ Color aColorRef;
+
+ mpInputStream->ReadUInt32( nIndex );
+ if ( ( nIndex & ENHMETA_STOCK_OBJECT ) == 0 )
+ {
+ mpInputStream->ReadUInt32( offBmi ).ReadUInt32( cbBmi ).ReadUInt32( offBits ).ReadUInt32( cbBits ). ReadUInt32( nStyle ).ReadUInt32( nWidth ).ReadUInt32( nBrushStyle );
+ SAL_INFO("emfio", "\t\tStyle: 0x" << std::hex << nStyle << std::dec);
+ SAL_INFO("emfio", "\t\tWidth: " << nWidth);
+ aColorRef = ReadColor();
+ mpInputStream->ReadInt32( elpHatch ).ReadUInt32( elpNumEntries );
+
+ LineInfo aLineInfo;
+ if ( nWidth )
+ aLineInfo.SetWidth( nWidth );
+
+ bool bTransparent = false;
+
+ 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 :
+ bTransparent = true;
+ aLineInfo.SetStyle( LineStyle::NONE );
+ break;
+
+ case PS_INSIDEFRAME :
+ case PS_SOLID :
+ default :
+ aLineInfo.SetStyle( LineStyle::Solid );
+ }
+ switch( nStyle & PS_ENDCAP_STYLE_MASK )
+ {
+ case PS_ENDCAP_ROUND :
+ if ( aLineInfo.GetWidth() )
+ {
+ aLineInfo.SetLineCap( css::drawing::LineCap_ROUND );
+ break;
+ }
+ [[fallthrough]];
+ case PS_ENDCAP_SQUARE :
+ if ( aLineInfo.GetWidth() )
+ {
+ aLineInfo.SetLineCap( css::drawing::LineCap_SQUARE );
+ break;
+ }
+ [[fallthrough]];
+ case PS_ENDCAP_FLAT :
+ default :
+ 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_MITER :
+ aLineInfo.SetLineJoin ( basegfx::B2DLineJoin::Miter );
+ break;
+ case PS_JOIN_BEVEL :
+ aLineInfo.SetLineJoin ( basegfx::B2DLineJoin::Bevel );
+ break;
+ default :
+ aLineInfo.SetLineJoin ( basegfx::B2DLineJoin::NONE );
+ }
+ CreateObjectIndexed(nIndex, std::make_unique<WinMtfLineStyle>( aColorRef, aLineInfo, bTransparent ));
+ }
+ }
+ break;
+
+ case EMR_CREATEBRUSHINDIRECT :
+ {
+ sal_uInt32 nStyle;
+ mpInputStream->ReadUInt32( nIndex );
+ if ( ( nIndex & ENHMETA_STOCK_OBJECT ) == 0 )
+ {
+ mpInputStream->ReadUInt32( nStyle );
+ CreateObjectIndexed(nIndex, std::make_unique<WinMtfFillStyle>( ReadColor(), ( nStyle == BS_HOLLOW ) ));
+ }
+ }
+ break;
+
+ case EMR_DELETEOBJECT :
+ {
+ mpInputStream->ReadUInt32( nIndex );
+ if ( ( nIndex & ENHMETA_STOCK_OBJECT ) == 0 )
+ DeleteObject( nIndex );
+ }
+ break;
+
+ case EMR_ELLIPSE :
+ {
+ mpInputStream->ReadInt32( nX32 ).ReadInt32( nY32 ).ReadInt32( nx32 ).ReadInt32( ny32 );
+ DrawEllipse( ReadRectangle( nX32, nY32, nx32, ny32 ) );
+ }
+ break;
+
+ case EMR_RECTANGLE :
+ {
+ mpInputStream->ReadInt32( nX32 ).ReadInt32( nY32 ).ReadInt32( nx32 ).ReadInt32( ny32 );
+ DrawRect( ReadRectangle( nX32, nY32, nx32, ny32 ) );
+ }
+ break;
+
+ case EMR_ROUNDRECT :
+ {
+ mpInputStream->ReadInt32( nX32 ).ReadInt32( nY32 ).ReadInt32( nx32 ).ReadInt32( ny32 ).ReadUInt32( nW ).ReadUInt32( nH );
+ Size aSize( Size( nW, nH ) );
+ DrawRoundRect( ReadRectangle( nX32, nY32, nx32, ny32 ), aSize );
+ }
+ break;
+
+ case EMR_ARC :
+ {
+ sal_uInt32 nStartX, nStartY, nEndX, nEndY;
+ mpInputStream->ReadInt32( nX32 ).ReadInt32( nY32 ).ReadInt32( nx32 ).ReadInt32( ny32 ).ReadUInt32( nStartX ).ReadUInt32( nStartY ).ReadUInt32( nEndX ).ReadUInt32( nEndY );
+ DrawArc( ReadRectangle( nX32, nY32, nx32, ny32 ), Point( nStartX, nStartY ), Point( nEndX, nEndY ) );
+ }
+ break;
+
+ case EMR_CHORD :
+ {
+ sal_uInt32 nStartX, nStartY, nEndX, nEndY;
+ mpInputStream->ReadInt32( nX32 ).ReadInt32( nY32 ).ReadInt32( nx32 ).ReadInt32( ny32 ).ReadUInt32( nStartX ).ReadUInt32( nStartY ).ReadUInt32( nEndX ).ReadUInt32( nEndY );
+ DrawChord( ReadRectangle( nX32, nY32, nx32, ny32 ), Point( nStartX, nStartY ), Point( nEndX, nEndY ) );
+ }
+ break;
+
+ case EMR_PIE :
+ {
+ sal_uInt32 nStartX, nStartY, nEndX, nEndY;
+ mpInputStream->ReadInt32( nX32 ).ReadInt32( nY32 ).ReadInt32( nx32 ).ReadInt32( ny32 ).ReadUInt32( nStartX ).ReadUInt32( nStartY ).ReadUInt32( nEndX ).ReadUInt32( nEndY );
+ const tools::Rectangle aRect( ReadRectangle( nX32, nY32, nx32, ny32 ));
+
+ // #i73608# OutputDevice deviates from WMF
+ // semantics. start==end means full ellipse here.
+ if( nStartX == nEndX && nStartY == nEndY )
+ DrawEllipse( aRect );
+ else
+ DrawPie( aRect, Point( nStartX, nStartY ), Point( nEndX, nEndY ) );
+ }
+ break;
+
+ case EMR_LINETO :
+ {
+ mpInputStream->ReadInt32( nX32 ).ReadInt32( nY32 );
+ LineTo( Point( nX32, nY32 ), mbRecordPath);
+ }
+ break;
+
+ case EMR_ARCTO :
+ {
+ sal_uInt32 nStartX, nStartY, nEndX, nEndY;
+ mpInputStream->ReadInt32( nX32 ).ReadInt32( nY32 ).ReadInt32( nx32 ).ReadInt32( ny32 ).ReadUInt32( nStartX ).ReadUInt32( nStartY ).ReadUInt32( nEndX ).ReadUInt32( nEndY );
+ DrawArc( ReadRectangle( nX32, nY32, nx32, ny32 ), Point( nStartX, nStartY ), Point( nEndX, nEndY ), true );
+ }
+ break;
+
+ case EMR_BEGINPATH :
+ {
+ ClearPath();
+ mbRecordPath = true;
+ }
+ break;
+
+ case EMR_ABORTPATH :
+ ClearPath();
+ [[fallthrough]];
+ case EMR_ENDPATH :
+ mbRecordPath = false;
+ break;
+
+ case EMR_CLOSEFIGURE :
+ ClosePath();
+ break;
+
+ case EMR_FILLPATH :
+ StrokeAndFillPath( false, true );
+ break;
+
+ case EMR_STROKEANDFILLPATH :
+ StrokeAndFillPath( true, true );
+ break;
+
+ case EMR_STROKEPATH :
+ StrokeAndFillPath( true, false );
+ break;
+
+ case EMR_SELECTCLIPPATH :
+ {
+ sal_Int32 nClippingMode(0);
+ mpInputStream->ReadInt32(nClippingMode);
+ SetClipPath(GetPathObj(), nClippingMode, true);
+ }
+ break;
+
+ case EMR_EXTSELECTCLIPRGN :
+ {
+ sal_Int32 nClippingMode(0), cbRgnData(0);
+ mpInputStream->ReadInt32(cbRgnData);
+ mpInputStream->ReadInt32(nClippingMode);
+
+ // This record's region data should be ignored if mode
+ // is RGN_COPY - see EMF spec section 2.3.2.2
+ if (nClippingMode == RGN_COPY)
+ {
+ SetDefaultClipPath();
+ }
+ else
+ {
+ tools::PolyPolygon aPolyPoly;
+ if (cbRgnData)
+ ImplReadRegion(aPolyPoly, *mpInputStream, nRecSize);
+ SetClipPath(aPolyPoly, nClippingMode, false);
+ }
+
+ }
+ break;
+
+ case EMR_ALPHABLEND:
+ {
+ sal_Int32 xDest(0), yDest(0), cxDest(0), cyDest(0);
+
+ BLENDFUNCTION aFunc;
+ sal_Int32 xSrc(0), ySrc(0), cxSrc(0), cySrc(0);
+ XForm xformSrc;
+ sal_uInt32 BkColorSrc(0), iUsageSrc(0), offBmiSrc(0);
+ sal_uInt32 cbBmiSrc(0), offBitsSrc(0), cbBitsSrc(0);
+
+ sal_uInt32 nStart = mpInputStream->Tell() - 8;
+ mpInputStream->SeekRel( 0x10 );
+
+ mpInputStream->ReadInt32( xDest ).ReadInt32( yDest ).ReadInt32( cxDest ).ReadInt32( cyDest );
+ *mpInputStream >> aFunc;
+ mpInputStream->ReadInt32( xSrc ).ReadInt32( ySrc );
+ *mpInputStream >> xformSrc;
+ mpInputStream->ReadUInt32( BkColorSrc ).ReadUInt32( iUsageSrc ).ReadUInt32( offBmiSrc ).ReadUInt32( cbBmiSrc )
+ .ReadUInt32( offBitsSrc ).ReadUInt32( cbBitsSrc ).ReadInt32( cxSrc ).ReadInt32( cySrc ) ;
+
+ if ( (cbBitsSrc > (SAL_MAX_UINT32 - 14)) || ((SAL_MAX_UINT32 - 14) - cbBitsSrc < cbBmiSrc) ||
+ cxDest == SAL_MAX_INT32 || cyDest == SAL_MAX_INT32 )
+ {
+ bStatus = false;
+ }
+ else
+ {
+ tools::Rectangle aRect(Point(xDest, yDest), Size(cxDest + 1, cyDest + 1));
+
+ const sal_uInt32 nSourceSize = cbBmiSrc + cbBitsSrc + 14;
+ bool bSafeRead = nSourceSize <= (mnEndPos - mnStartPos);
+ sal_uInt32 nDeltaToDIB5HeaderSize(0);
+ const bool bReadAlpha(0x01 == aFunc.aAlphaFormat);
+ if (bSafeRead && bReadAlpha)
+ {
+ // we need to read alpha channel data if AlphaFormat of BLENDFUNCTION is
+ // AC_SRC_ALPHA (==0x01). To read it, create a temp DIB-File which is ready
+ // for DIB-5 format
+ const sal_uInt32 nHeaderSize = getDIBV5HeaderSize();
+ if (cbBmiSrc > nHeaderSize)
+ bSafeRead = false;
+ else
+ nDeltaToDIB5HeaderSize = nHeaderSize - cbBmiSrc;
+ }
+ if (bSafeRead)
+ {
+ const sal_uInt32 nTargetSize(cbBmiSrc + nDeltaToDIB5HeaderSize + cbBitsSrc + 14);
+ char* pBuf = new char[ nTargetSize ];
+ SvMemoryStream aTmp( pBuf, nTargetSize, StreamMode::READ | StreamMode::WRITE );
+
+ aTmp.ObjectOwnsMemory( true );
+
+ // write BM-Header (14 bytes)
+ aTmp.WriteUChar( 'B' )
+ .WriteUChar( 'M' )
+ .WriteUInt32( cbBitsSrc )
+ .WriteUInt16( 0 )
+ .WriteUInt16( 0 )
+ .WriteUInt32( cbBmiSrc + nDeltaToDIB5HeaderSize + 14 );
+
+ // copy DIBInfoHeader from source (cbBmiSrc bytes)
+ mpInputStream->Seek( nStart + offBmiSrc );
+ mpInputStream->ReadBytes(pBuf + 14, cbBmiSrc);
+
+ if (bReadAlpha)
+ {
+ // need to add values for all stuff that DIBV5Header is bigger
+ // than DIBInfoHeader, all values are correctly initialized to zero,
+ // so we can use memset here
+ memset(pBuf + cbBmiSrc + 14, 0, nDeltaToDIB5HeaderSize);
+ }
+
+ // copy bitmap data from source (offBitsSrc bytes)
+ mpInputStream->Seek( nStart + offBitsSrc );
+ mpInputStream->ReadBytes(pBuf + 14 + nDeltaToDIB5HeaderSize + cbBmiSrc, cbBitsSrc);
+ aTmp.Seek( 0 );
+
+ // prepare to read and fill BitmapEx
+ BitmapEx aBitmapEx;
+
+ if(bReadAlpha)
+ {
+ Bitmap aBitmap;
+ AlphaMask aAlpha;
+
+ if(ReadDIBV5(aBitmap, aAlpha, aTmp))
+ {
+ aBitmapEx = BitmapEx(aBitmap, aAlpha);
+ }
+ }
+ else
+ {
+ Bitmap aBitmap;
+
+ if(ReadDIB(aBitmap, aTmp, true))
+ {
+ if(0xff != aFunc.aSrcConstantAlpha)
+ {
+ // add const alpha channel
+ aBitmapEx = BitmapEx(
+ aBitmap,
+ AlphaMask(aBitmap.GetSizePixel(), &aFunc.aSrcConstantAlpha));
+ }
+ else
+ {
+ // just use Bitmap
+ aBitmapEx = BitmapEx(aBitmap);
+ }
+ }
+ }
+
+ if(!aBitmapEx.IsEmpty())
+ {
+ // test if it is sensible to crop
+ if (cxSrc > 0 && cySrc > 0 && xSrc >= 0 && ySrc >= 0)
+ {
+ sal_Int32 xEndSrc;
+ sal_Int32 yEndSrc;
+ if (!o3tl::checked_add(xSrc, cxSrc, xEndSrc) && xEndSrc < aBitmapEx.GetSizePixel().Width() &&
+ !o3tl::checked_add(ySrc, cySrc, yEndSrc) && yEndSrc < aBitmapEx.GetSizePixel().Height())
+ {
+ const tools::Rectangle aCropRect( Point( xSrc, ySrc ), Size( cxSrc, cySrc ) );
+ aBitmapEx.Crop( aCropRect );
+ }
+ }
+
+ #ifdef DBG_UTIL
+ static bool bDoSaveForVisualControl(false); // loplugin:constvars:ignore
+
+ if(bDoSaveForVisualControl)
+ {
+ SvFileStream aNew("c:\\metafile_content.png", StreamMode::WRITE|StreamMode::TRUNC);
+ vcl::PNGWriter aPNGWriter(aBitmapEx);
+ aPNGWriter.Write(aNew);
+ }
+ #endif
+ maBmpSaveList.emplace_back(new BSaveStruct(aBitmapEx, aRect, SRCAND|SRCINVERT));
+ }
+ }
+ }
+ }
+ break;
+
+ case EMR_BITBLT : // PASSTHROUGH INTENDED
+ case EMR_STRETCHBLT :
+ {
+ sal_Int32 xDest, yDest, cxDest, cyDest, xSrc, ySrc, cxSrc, cySrc;
+ sal_uInt32 dwRop, iUsageSrc, offBmiSrc, cbBmiSrc, offBitsSrc, cbBitsSrc;
+ XForm xformSrc;
+
+ sal_uInt32 nStart = mpInputStream->Tell() - 8;
+
+ mpInputStream->SeekRel( 0x10 );
+ mpInputStream->ReadInt32( xDest ).ReadInt32( yDest ).ReadInt32( cxDest ).ReadInt32( cyDest ).ReadUInt32( dwRop ).ReadInt32( xSrc ).ReadInt32( ySrc )
+ >> xformSrc;
+ mpInputStream->ReadUInt32( nColor ).ReadUInt32( iUsageSrc ).ReadUInt32( offBmiSrc ).ReadUInt32( cbBmiSrc )
+ .ReadUInt32( offBitsSrc ).ReadUInt32( cbBitsSrc );
+
+ if ( nRecType == EMR_STRETCHBLT )
+ mpInputStream->ReadInt32( cxSrc ).ReadInt32( cySrc );
+ else
+ cxSrc = cySrc = 0;
+
+ Bitmap aBitmap;
+ tools::Rectangle aRect( Point( xDest, yDest ), Size( cxDest, cyDest ) );
+
+ if (!mpInputStream->good() || (cbBitsSrc > (SAL_MAX_UINT32 - 14)) || ((SAL_MAX_UINT32 - 14) - cbBitsSrc < cbBmiSrc))
+ bStatus = false;
+ else
+ {
+ sal_uInt32 nSize = cbBmiSrc + cbBitsSrc + 14;
+ if ( nSize <= ( mnEndPos - mnStartPos ) )
+ {
+ char* pBuf = new char[ nSize ];
+ SvMemoryStream aTmp( pBuf, nSize, StreamMode::READ | StreamMode::WRITE );
+ aTmp.ObjectOwnsMemory( true );
+ aTmp.WriteUChar( 'B' )
+ .WriteUChar( 'M' )
+ .WriteUInt32( cbBitsSrc )
+ .WriteUInt16( 0 )
+ .WriteUInt16( 0 )
+ .WriteUInt32( cbBmiSrc + 14 );
+ mpInputStream->Seek( nStart + offBmiSrc );
+ mpInputStream->ReadBytes(pBuf + 14, cbBmiSrc);
+ mpInputStream->Seek( nStart + offBitsSrc );
+ mpInputStream->ReadBytes(pBuf + 14 + cbBmiSrc, cbBitsSrc);
+ aTmp.Seek( 0 );
+ ReadDIB(aBitmap, aTmp, true);
+
+ // test if it is sensible to crop
+ if ( (cxSrc > 0) && (cySrc > 0) &&
+ (xSrc >= 0) && (ySrc >= 0) &&
+ (aBitmap.GetSizePixel().Width() >= cxSrc) &&
+ (xSrc <= aBitmap.GetSizePixel().Width() - cxSrc) &&
+ (aBitmap.GetSizePixel().Height() >= cySrc) &&
+ (ySrc <= aBitmap.GetSizePixel().Height() - cySrc) )
+ {
+ tools::Rectangle aCropRect( Point( xSrc, ySrc ), Size( cxSrc, cySrc ) );
+ aBitmap.Crop( aCropRect );
+ }
+
+ maBmpSaveList.emplace_back(new BSaveStruct(aBitmap, aRect, dwRop));
+ }
+ }
+ }
+ break;
+
+ case EMR_STRETCHDIBITS :
+ {
+ sal_Int32 xDest, yDest, xSrc, ySrc, cxSrc, cySrc, cxDest, cyDest;
+ sal_uInt32 offBmiSrc, cbBmiSrc, offBitsSrc, cbBitsSrc, iUsageSrc, dwRop;
+ sal_uInt32 nStart = mpInputStream->Tell() - 8;
+
+ mpInputStream->SeekRel( 0x10 );
+ mpInputStream->ReadInt32( xDest )
+ .ReadInt32( yDest )
+ .ReadInt32( xSrc )
+ .ReadInt32( ySrc )
+ .ReadInt32( cxSrc )
+ .ReadInt32( cySrc )
+ .ReadUInt32( offBmiSrc )
+ .ReadUInt32( cbBmiSrc )
+ .ReadUInt32( offBitsSrc )
+ .ReadUInt32( cbBitsSrc )
+ .ReadUInt32( iUsageSrc )
+ .ReadUInt32( dwRop )
+ .ReadInt32( cxDest )
+ .ReadInt32( cyDest );
+
+ if (!mpInputStream->good() ||
+ ((SAL_MAX_UINT32 - 14) < cbBitsSrc) ||
+ ((SAL_MAX_UINT32 - 14) - cbBitsSrc < cbBmiSrc))
+ {
+ bStatus = false;
+ }
+ else
+ {
+ Bitmap aBitmap;
+ tools::Rectangle aRect(xDest, yDest);
+ aRect.SaturatingSetSize(Size(cxDest, cyDest));
+
+ sal_uInt32 nSize = cbBmiSrc + cbBitsSrc + 14;
+ if ( nSize <= ( mnEndPos - mnStartPos ) )
+ {
+ char* pBuf = new char[ nSize ];
+ SvMemoryStream aTmp( pBuf, nSize, StreamMode::READ | StreamMode::WRITE );
+ aTmp.ObjectOwnsMemory( true );
+ aTmp.WriteUChar( 'B' )
+ .WriteUChar( 'M' )
+ .WriteUInt32( cbBitsSrc )
+ .WriteUInt16( 0 )
+ .WriteUInt16( 0 )
+ .WriteUInt32( cbBmiSrc + 14 );
+ mpInputStream->Seek( nStart + offBmiSrc );
+ mpInputStream->ReadBytes(pBuf + 14, cbBmiSrc);
+ mpInputStream->Seek( nStart + offBitsSrc );
+ mpInputStream->ReadBytes(pBuf + 14 + cbBmiSrc, cbBitsSrc);
+ aTmp.Seek( 0 );
+ ReadDIB(aBitmap, aTmp, true);
+
+ // test if it is sensible to crop
+ if ( (cxSrc > 0) && (cySrc > 0) &&
+ (xSrc >= 0) && (ySrc >= 0) &&
+ (aBitmap.GetSizePixel().Width() >= cxSrc) &&
+ (xSrc <= aBitmap.GetSizePixel().Width() - cxSrc) &&
+ (aBitmap.GetSizePixel().Height() >= cySrc) &&
+ (ySrc <= aBitmap.GetSizePixel().Height() - cySrc) )
+ {
+ tools::Rectangle aCropRect( Point( xSrc, ySrc ), Size( cxSrc, cySrc ) );
+ aBitmap.Crop( aCropRect );
+ }
+ maBmpSaveList.emplace_back(new BSaveStruct(aBitmap, aRect, dwRop));
+ }
+ }
+ }
+ break;
+
+ case EMR_EXTCREATEFONTINDIRECTW :
+ {
+ mpInputStream->ReadUInt32( nIndex );
+ if ( ( nIndex & ENHMETA_STOCK_OBJECT ) == 0 )
+ {
+ LOGFONTW aLogFont;
+ mpInputStream->ReadInt32( aLogFont.lfHeight )
+ .ReadInt32( aLogFont.lfWidth )
+ .ReadInt32( aLogFont.lfEscapement )
+ .ReadInt32( aLogFont.lfOrientation )
+ .ReadInt32( aLogFont.lfWeight )
+ .ReadUChar( aLogFont.lfItalic )
+ .ReadUChar( aLogFont.lfUnderline )
+ .ReadUChar( aLogFont.lfStrikeOut )
+ .ReadUChar( aLogFont.lfCharSet )
+ .ReadUChar( aLogFont.lfOutPrecision )
+ .ReadUChar( aLogFont.lfClipPrecision )
+ .ReadUChar( aLogFont.lfQuality )
+ .ReadUChar( aLogFont.lfPitchAndFamily );
+
+ sal_Unicode lfFaceName[LF_FACESIZE+1];
+ lfFaceName[LF_FACESIZE] = 0;
+ for (int i = 0; i < LF_FACESIZE; ++i)
+ {
+ sal_uInt16 nChar(0);
+ mpInputStream->ReadUInt16(nChar);
+ lfFaceName[i] = nChar;
+ }
+ aLogFont.alfFaceName = OUString( lfFaceName );
+
+ // #i123216# Not used in the test case of #121382# (always identity in XForm), also
+ // no hints in ms docu if FontSize should be scaled with WT. Using with the example
+ // from #i123216# creates errors, so removing.
+
+ // // #i121382# Need to apply WorldTransform to FontHeight/Width; this should be completely
+ // // changed to basegfx::B2DHomMatrix instead of 'struct XForm', but not now due to time
+ // // constraints and dangers
+ // const XForm& rXF = GetWorldTransform();
+ // const basegfx::B2DHomMatrix aWT(rXF.eM11, rXF.eM21, rXF.eDx, rXF.eM12, rXF.eM22, rXF.eDy);
+ // const basegfx::B2DVector aTransVec(aWT * basegfx::B2DVector(aLogFont.lfWidth, aLogFont.lfHeight));
+ // aLogFont.lfWidth = aTransVec.getX();
+ // aLogFont.lfHeight = aTransVec.getY();
+ if (mpInputStream->good() && aLogFont.lfHeight != SAL_MIN_INT32 && aLogFont.lfWidth != SAL_MIN_INT32)
+ {
+ CreateObjectIndexed(nIndex, std::make_unique<WinMtfFontStyle>( aLogFont ));
+ }
+ }
+ }
+ break;
+
+ case EMR_EXTTEXTOUTA :
+ bFlag = true;
+ [[fallthrough]];
+ case EMR_EXTTEXTOUTW :
+ {
+ sal_Int32 nLeft, nTop, nRight, nBottom, ptlReferenceX, ptlReferenceY, nGfxMode, nXScale, nYScale;
+ sal_uInt32 nOffString, nOptions, offDx;
+ sal_Int32 nLen;
+
+ nCurPos = mpInputStream->Tell() - 8;
+
+ mpInputStream->ReadInt32( nLeft ).ReadInt32( nTop ).ReadInt32( nRight ).ReadInt32( nBottom ).ReadInt32( nGfxMode ).ReadInt32( nXScale ).ReadInt32( nYScale )
+ .ReadInt32( ptlReferenceX ).ReadInt32( ptlReferenceY ).ReadInt32( nLen ).ReadUInt32( nOffString ).ReadUInt32( nOptions );
+
+ SAL_INFO("emfio", "\t\tBounds: " << nLeft << ", " << nTop << ", " << nRight << ", " << nBottom);
+ SAL_INFO("emfio", "\t\tiGraphicsMode: 0x" << std::hex << nGfxMode << std::dec);
+ SAL_INFO("emfio", "\t\texScale: " << nXScale);
+ SAL_INFO("emfio", "\t\teyScale: " << nYScale);
+ SAL_INFO("emfio", "\t\tReference: (" << ptlReferenceX << ", " << ptlReferenceY << ")");
+
+ mpInputStream->SeekRel( 0x10 );
+ mpInputStream->ReadUInt32( offDx );
+
+ ComplexTextLayoutFlags nTextLayoutMode = ComplexTextLayoutFlags::Default;
+ if ( nOptions & ETO_RTLREADING )
+ nTextLayoutMode = ComplexTextLayoutFlags::BiDiRtl | ComplexTextLayoutFlags::TextOriginLeft;
+ SetTextLayoutMode( nTextLayoutMode );
+ SAL_WARN_IF( ( nOptions & ( ETO_PDY | ETO_GLYPH_INDEX ) ) != 0, "emfio", "SJ: ETO_PDY || ETO_GLYPH_INDEX in EMF" );
+
+ Point aPos( ptlReferenceX, ptlReferenceY );
+ bool bLenSane = nLen > 0 && nLen < static_cast<sal_Int32>( SAL_MAX_UINT32 / sizeof(sal_Int32) );
+ bool bOffStringSane = nOffString <= mnEndPos - nCurPos;
+ if (bLenSane && bOffStringSane)
+ {
+ mpInputStream->Seek( nCurPos + nOffString );
+ OUString aText;
+ if ( bFlag )
+ {
+ if ( nLen <= static_cast<sal_Int32>( mnEndPos - mpInputStream->Tell() ) )
+ {
+ std::unique_ptr<char[]> pBuf(new char[ nLen ]);
+ mpInputStream->ReadBytes(pBuf.get(), nLen);
+ aText = OUString(pBuf.get(), nLen, GetCharSet());
+ }
+ }
+ else
+ {
+ if ( ( nLen * sizeof(sal_Unicode) ) <= ( mnEndPos - mpInputStream->Tell() ) )
+ {
+ aText = read_uInt16s_ToOUString(*mpInputStream, nLen);
+ }
+ }
+
+ SAL_INFO("emfio", "\t\tText: " << aText);
+ SAL_INFO("emfio", "\t\tDxBuffer:");
+
+ std::unique_ptr<long[]> pDXAry, pDYAry;
+
+ sal_Int32 nDxSize;
+ bool bOverflow = o3tl::checked_multiply<sal_Int32>(nLen, (nOptions & ETO_PDY) ? 8 : 4, nDxSize);
+ if (!bOverflow && offDx && ((nCurPos + offDx + nDxSize) <= nNextPos ) && nNextPos <= mnEndPos)
+ {
+ mpInputStream->Seek( nCurPos + offDx );
+ pDXAry.reset( new long[aText.getLength()] );
+ if (nOptions & ETO_PDY)
+ {
+ pDYAry.reset( new long[aText.getLength()] );
+ }
+
+ for (sal_Int32 i = 0; i < aText.getLength(); ++i)
+ {
+ sal_Int32 nDxCount = 1;
+ if (aText.getLength() != nLen)
+ {
+ sal_Unicode cUniChar = aText[i];
+ OString aTmp(&cUniChar, 1, GetCharSet());
+ if (aTmp.getLength() > 1)
+ {
+ nDxCount = aTmp.getLength();
+ }
+ }
+
+ sal_Int32 nDx = 0, nDy = 0;
+ while (nDxCount--)
+ {
+ sal_Int32 nDxTmp = 0;
+ mpInputStream->ReadInt32(nDxTmp);
+ nDx += nDxTmp;
+ if (nOptions & ETO_PDY)
+ {
+ sal_Int32 nDyTmp = 0;
+ mpInputStream->ReadInt32(nDyTmp);
+ nDy += nDyTmp;
+ }
+ }
+
+ SAL_INFO("emfio", "\t\t\tSpacing " << i << ": " << nDx);
+ pDXAry[i] = nDx;
+ if (nOptions & ETO_PDY)
+ {
+ pDYAry[i] = nDy;
+ }
+ }
+ }
+ DrawText(aPos, aText, pDXAry.get(), pDYAry.get(), mbRecordPath, nGfxMode);
+ }
+ }
+ break;
+
+ case EMR_POLYBEZIERTO16 :
+ DrawPolyBezier(ReadPolygonWithSkip<sal_Int16>(true, nNextPos), true, mbRecordPath);
+ break;
+
+ case EMR_POLYBEZIER16 :
+ DrawPolyBezier(ReadPolygonWithSkip<sal_Int16>(false, nNextPos), false, mbRecordPath);
+ break;
+
+ case EMR_POLYGON16 :
+ DrawPolygon(ReadPolygonWithSkip<sal_Int16>(false, nNextPos), mbRecordPath);
+ break;
+
+ case EMR_POLYLINETO16 :
+ DrawPolyLine(ReadPolygonWithSkip<sal_Int16>(true, nNextPos), true, mbRecordPath);
+ break;
+
+ case EMR_POLYLINE16 :
+ DrawPolyLine(ReadPolygonWithSkip<sal_Int16>(false, nNextPos), false, mbRecordPath);
+ break;
+
+ case EMR_POLYPOLYLINE16 :
+ ReadAndDrawPolyLine<sal_Int16>(nNextPos);
+ break;
+
+ case EMR_POLYPOLYGON16 :
+ ReadAndDrawPolyPolygon<sal_Int16>(nNextPos);
+ break;
+
+ case EMR_FILLRGN :
+ {
+ sal_uInt32 nLen;
+ tools::PolyPolygon aPolyPoly;
+ mpInputStream->SeekRel( 0x10 );
+ mpInputStream->ReadUInt32( nLen ).ReadUInt32( nIndex );
+
+ if ( ImplReadRegion( aPolyPoly, *mpInputStream, nRecSize ) )
+ {
+ Push();
+ SelectObject( nIndex );
+ DrawPolyPolygon( aPolyPoly );
+ Pop();
+ }
+ }
+ break;
+
+ case EMR_CREATEDIBPATTERNBRUSHPT :
+ {
+ sal_uInt32 nStart = mpInputStream->Tell() - 8;
+ Bitmap aBitmap;
+
+ mpInputStream->ReadUInt32( nIndex );
+
+ if ( ( nIndex & ENHMETA_STOCK_OBJECT ) == 0 )
+ {
+ sal_uInt32 usage, offBmi, cbBmi, offBits, cbBits;
+
+ mpInputStream->ReadUInt32( usage );
+ mpInputStream->ReadUInt32( offBmi );
+ mpInputStream->ReadUInt32( cbBmi );
+ mpInputStream->ReadUInt32( offBits );
+ mpInputStream->ReadUInt32( cbBits );
+
+ if ( (cbBits > (SAL_MAX_UINT32 - 14)) || ((SAL_MAX_UINT32 - 14) - cbBits < cbBmi) )
+ bStatus = false;
+ else if ( offBmi )
+ {
+ sal_uInt32 nSize = cbBmi + cbBits + 14;
+ if ( nSize <= ( mnEndPos - mnStartPos ) )
+ {
+ char* pBuf = new char[ nSize ];
+
+ SvMemoryStream aTmp( pBuf, nSize, StreamMode::READ | StreamMode::WRITE );
+ aTmp.ObjectOwnsMemory( true );
+ aTmp.WriteUChar( 'B' )
+ .WriteUChar( 'M' )
+ .WriteUInt32( cbBits )
+ .WriteUInt16( 0 )
+ .WriteUInt16( 0 )
+ .WriteUInt32( cbBmi + 14 );
+ mpInputStream->Seek( nStart + offBmi );
+ mpInputStream->ReadBytes(pBuf + 14, cbBmi);
+ mpInputStream->Seek( nStart + offBits );
+ mpInputStream->ReadBytes(pBuf + 14 + cbBmi, cbBits);
+ aTmp.Seek( 0 );
+ ReadDIB(aBitmap, aTmp, true);
+ }
+ }
+ }
+
+ CreateObjectIndexed(nIndex, std::make_unique<WinMtfFillStyle>( aBitmap ));
+ }
+ break;
+
+ case EMR_MASKBLT : SAL_WARN("emfio", "not implemented 'MaskBlt'"); break;
+ case EMR_PLGBLT : SAL_WARN("emfio", "not implemented 'PlgBlt'"); break;
+ case EMR_SETDIBITSTODEVICE : SAL_WARN("emfio", "not implemented 'SetDIBitsToDevice'"); break;
+ case EMR_FRAMERGN : SAL_WARN("emfio", "not implemented 'FrameRgn'"); break;
+ case EMR_INVERTRGN : SAL_WARN("emfio", "not implemented 'InvertRgn'"); break;
+ case EMR_PAINTRGN : SAL_WARN("emfio", "not implemented 'PaintRgn'"); break;
+ case EMR_FLATTENPATH : SAL_WARN("emfio", "not implemented 'FlattenPath'"); break;
+ case EMR_WIDENPATH : SAL_WARN("emfio", "not implemented 'WidenPath'"); break;
+ case EMR_POLYDRAW : SAL_WARN("emfio", "not implemented 'Polydraw'"); break;
+ case EMR_SETARCDIRECTION : SAL_WARN("emfio", "not implemented 'SetArcDirection'"); break;
+ case EMR_SETPALETTEENTRIES : SAL_WARN("emfio", "not implemented 'SetPaletteEntries'"); break;
+ case EMR_RESIZEPALETTE : SAL_WARN("emfio", "not implemented 'ResizePalette'"); break;
+ case EMR_EXTFLOODFILL : SAL_WARN("emfio", "not implemented 'ExtFloodFill'"); break;
+ case EMR_ANGLEARC : SAL_WARN("emfio", "not implemented 'AngleArc'"); break;
+ case EMR_SETCOLORADJUSTMENT : SAL_WARN("emfio", "not implemented 'SetColorAdjustment'"); break;
+ case EMR_POLYDRAW16 : SAL_WARN("emfio", "not implemented 'PolyDraw16'"); break;
+ case EMR_POLYTEXTOUTA : SAL_WARN("emfio", "not implemented 'PolyTextOutA'"); break;
+ case EMR_POLYTEXTOUTW : SAL_WARN("emfio", "not implemented 'PolyTextOutW'"); break;
+ case EMR_CREATECOLORSPACE : SAL_WARN("emfio", "not implemented 'CreateColorSpace'"); break;
+ case EMR_SETCOLORSPACE : SAL_WARN("emfio", "not implemented 'SetColorSpace'"); break;
+ case EMR_DELETECOLORSPACE : SAL_WARN("emfio", "not implemented 'DeleteColorSpace'"); break;
+ case EMR_GLSRECORD : SAL_WARN("emfio", "not implemented 'GlsRecord'"); break;
+ case EMR_GLSBOUNDEDRECORD : SAL_WARN("emfio", "not implemented 'GlsBoundRecord'"); break;
+ case EMR_PIXELFORMAT : SAL_WARN("emfio", "not implemented 'PixelFormat'"); break;
+ case EMR_DRAWESCAPE : SAL_WARN("emfio", "not implemented 'DrawEscape'"); break;
+ case EMR_EXTESCAPE : SAL_WARN("emfio", "not implemented 'ExtEscape'"); break;
+ case EMR_STARTDOC : SAL_WARN("emfio", "not implemented 'StartDoc'"); break;
+ case EMR_SMALLTEXTOUT : SAL_WARN("emfio", "not implemented 'SmallTextOut'"); break;
+ case EMR_FORCEUFIMAPPING : SAL_WARN("emfio", "not implemented 'ForceUFIMapping'"); break;
+ case EMR_NAMEDESCAPE : SAL_WARN("emfio", "not implemented 'NamedEscape'"); break;
+ case EMR_COLORCORRECTPALETTE : SAL_WARN("emfio", "not implemented 'ColorCorrectPalette'"); break;
+ case EMR_SETICMPROFILEA : SAL_WARN("emfio", "not implemented 'SetICMProfileA'"); break;
+ case EMR_SETICMPROFILEW : SAL_WARN("emfio", "not implemented 'SetICMProfileW'"); break;
+ case EMR_TRANSPARENTBLT : SAL_WARN("emfio", "not implemented 'TransparenBlt'"); break;
+ case EMR_TRANSPARENTDIB : SAL_WARN("emfio", "not implemented 'TransparenDib'"); break;
+ case EMR_GRADIENTFILL : SAL_WARN("emfio", "not implemented 'GradientFill'"); break;
+ case EMR_SETLINKEDUFIS : SAL_WARN("emfio", "not implemented 'SetLinkedUFIS'"); break;
+
+ case EMR_SETMAPPERFLAGS : SAL_WARN("emfio", "not implemented 'SetMapperFlags'"); break;
+ case EMR_SETICMMODE : SAL_WARN("emfio", "not implemented 'SetICMMode'"); break;
+ case EMR_CREATEMONOBRUSH : SAL_WARN("emfio", "not implemented 'CreateMonoBrush'"); break;
+ case EMR_SETBRUSHORGEX : SAL_WARN("emfio", "not implemented 'SetBrushOrgEx'"); break;
+ case EMR_SETMETARGN : SAL_WARN("emfio", "not implemented 'SetMetArgn'"); break;
+ case EMR_SETMITERLIMIT : SAL_WARN("emfio", "not implemented 'SetMiterLimit'"); break;
+ case EMR_EXCLUDECLIPRECT : SAL_WARN("emfio", "not implemented 'ExcludeClipRect'"); break;
+ case EMR_REALIZEPALETTE : SAL_WARN("emfio", "not implemented 'RealizePalette'"); break;
+ case EMR_SELECTPALETTE : SAL_WARN("emfio", "not implemented 'SelectPalette'"); break;
+ case EMR_CREATEPALETTE : SAL_WARN("emfio", "not implemented 'CreatePalette'"); break;
+ case EMR_ALPHADIBBLEND : SAL_WARN("emfio", "not implemented 'AlphaDibBlend'"); break;
+ case EMR_SETTEXTJUSTIFICATION : SAL_WARN("emfio", "not implemented 'SetTextJustification'"); break;
+
+ case EMR_COMMENT :
+ case EMR_HEADER : // has already been read at ReadHeader()
+ break;
+
+ default : SAL_INFO("emfio", "Unknown Meta Action"); break;
+ }
+ }
+ mpInputStream->Seek( nNextPos );
+ }
+ if( !maBmpSaveList.empty() )
+ ResolveBitmapActions( maBmpSaveList );
+
+ if ( bStatus )
+ mpInputStream->Seek(mnEndPos);
+
+ return bStatus;
+ };
+
+ bool EmfReader::ReadHeader()
+ {
+ // Spare me the METAFILEHEADER here
+ // Reading the METAHEADER - EMR_HEADER ([MS-EMF] section 2.3.4.2 EMR_HEADER Record Types)
+ sal_uInt32 nType(0), nHeaderSize(0);
+ mpInputStream->ReadUInt32(nType).ReadUInt32(nHeaderSize);
+ SAL_INFO ("emfio", "0x0-0x" << std::hex << nHeaderSize << " " << record_type_name(nType) << " size: " << std::dec << nHeaderSize);
+ if (nType != 0x00000001)
+ {
+ // per [MS-EMF] 2.3.4.2 EMF Header Record Types, type MUST be 0x00000001
+ SAL_WARN("emfio", "EMF header type is not set to 0x00000001 - possibly corrupted file?");
+ return false;
+ }
+
+ // Start reading the EMR_HEADER Header object
+
+ // bound size (RectL object, see [MS-WMF] section 2.2.2.19)
+ SAL_INFO("emfio", "\tBounding rectangle");
+ tools::Rectangle rclBounds = ReadRectangle(); // rectangle in logical units
+
+ // picture frame size (RectL object)
+ SAL_INFO("emfio", "\tPicture frame");
+ tools::Rectangle rclFrame = ReadRectangle(); // rectangle in device units 1/100th mm
+
+ sal_uInt32 nSignature(0);
+ mpInputStream->ReadUInt32(nSignature);
+ SAL_INFO("emfio", "\tSignature: 0x" << std::hex << nSignature << std::dec);
+
+ // nSignature MUST be the ASCII characters "FME", see [WS-EMF] 2.2.9 Header Object
+ // and 2.1.14 FormatSignature Enumeration
+ if (nSignature != 0x464d4520)
+ {
+ SAL_WARN("emfio", "EMF\t\tSignature is not 0x464d4520 (\"FME\") - possibly corrupted file?");
+ return false;
+ }
+
+ sal_uInt32 nVersion(0);
+ mpInputStream->ReadUInt32(nVersion); // according to [WS-EMF] 2.2.9, this SHOULD be 0x0001000, however
+ // Microsoft note that not even Windows checks this...
+ SAL_INFO("emfio", "\tVersion: 0x" << std::hex << nSignature << std::dec);
+ if (nVersion != 0x00010000)
+ {
+ SAL_WARN("emfio", "EMF\t\tThis really should be 0x00010000, though not absolutely essential...");
+ }
+
+ mpInputStream->ReadUInt32(mnEndPos); // size of metafile
+ SAL_INFO("emfio", "\tMetafile size: " << mnEndPos);
+ mnEndPos += mnStartPos;
+
+ sal_uInt32 nStrmPos = mpInputStream->Tell(); // checking if mnEndPos is valid
+ sal_uInt32 nActualFileSize = nStrmPos + mpInputStream->remainingSize();
+
+ if ( nActualFileSize < mnEndPos )
+ {
+ SAL_WARN("emfio", "EMF\t\tEMF Header object records number of bytes as " << mnEndPos
+ << ", however the file size is actually " << nActualFileSize
+ << " bytes. Possible file corruption?");
+ mnEndPos = nActualFileSize;
+ }
+
+ mpInputStream->ReadInt32(mnRecordCount);
+ SAL_INFO("emfio", "\tRecords: " << mnRecordCount);
+
+ if (mnRecordCount <= 0)
+ {
+ SAL_WARN("emfio", "EMF\t\tEMF Header object shows record counter as <= 0! This shouldn't "
+ "be possible... indicator of possible file corruption?");
+ return false;
+ }
+
+ // the number of "handles", or graphics objects used in the metafile
+
+ sal_uInt16 nHandlesCount;
+ mpInputStream->ReadUInt16(nHandlesCount);
+ SAL_INFO("emfio", "\tGraphics: " << nHandlesCount);
+
+ // the next 2 bytes are reserved, but according to [MS-EMF] section 2.2.9
+ // it MUST be 0x000 and MUST be ignored... the thing is, having such a specific
+ // value is actually pretty useful in checking if there is possible corruption
+
+ sal_uInt16 nReserved(0);
+ mpInputStream->ReadUInt16(nReserved);
+ SAL_INFO("emfio", "\tReserved: 0x" << std::hex << nReserved << std::dec);
+
+ if ( nReserved != 0x0000 )
+ {
+ SAL_WARN("emfio", "EMF\t\tEMF Header object's reserved field is NOT 0x0000... possible "
+ "corruption?");
+ }
+
+ // The next 4 bytes specifies the number of characters in the metafile description.
+ // The 4 bytes after that specific the offset from this record that contains the
+ // metafile description... zero means no description string.
+ // For now, we ignore it.
+
+ mpInputStream->SeekRel(0x8);
+
+ sal_uInt32 nPalEntries(0);
+ mpInputStream->ReadUInt32(nPalEntries);
+ SAL_INFO("emfio", "\tPalette entries: " << nPalEntries);
+ sal_Int32 nPixX(0), nPixY(0), nMillX(0), nMillY(0);
+ mpInputStream->ReadInt32(nPixX);
+ mpInputStream->ReadInt32(nPixY);
+ SAL_INFO("emfio", "\tRef (pixels): " << nPixX << ", " << nPixY);
+ mpInputStream->ReadInt32(nMillX);
+ mpInputStream->ReadInt32(nMillY);
+ SAL_INFO("emfio", "\tRef (mm): " << nMillX << ", " << nMillY);
+
+ SetrclFrame(rclFrame);
+ SetrclBounds(rclBounds);
+ SetRefPix(Size( nPixX, nPixY ) );
+ SetRefMill(Size( nMillX, nMillY ) );
+
+ return checkSeek(*mpInputStream, mnStartPos + nHeaderSize);
+ }
+
+ tools::Rectangle EmfReader::ReadRectangle()
+ {
+ sal_Int32 nLeft, nTop, nRight, nBottom;
+ mpInputStream->ReadInt32(nLeft);
+ mpInputStream->ReadInt32(nTop);
+ mpInputStream->ReadInt32(nRight);
+ mpInputStream->ReadInt32(nBottom);
+
+ SAL_INFO("emfio", "\t\tLeft: " << nLeft << ", top: " << nTop << ", right: " << nRight << ", bottom: " << nBottom);
+ if (nLeft > nRight || nTop > nBottom)
+ {
+ SAL_WARN("emfio", "broken rectangle");
+ return tools::Rectangle::Justify(Point(nLeft, nTop), Point(nRight, nBottom));
+ }
+
+ return tools::Rectangle(nLeft, nTop, nRight, nBottom);
+ }
+
+ tools::Rectangle EmfReader::ReadRectangle( sal_Int32 x1, sal_Int32 y1, sal_Int32 x2, sal_Int32 y2 )
+ {
+ Point aTL(x1, y1);
+ Point aBR(o3tl::saturating_add<sal_Int32>(x2, -1), o3tl::saturating_add<sal_Int32>(y2, -1));
+ return tools::Rectangle(aTL, aBR);
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/emfio/source/reader/mtftools.cxx b/emfio/source/reader/mtftools.cxx
new file mode 100644
index 000000000..e90ced506
--- /dev/null
+++ b/emfio/source/reader/mtftools.cxx
@@ -0,0 +1,2244 @@
+/* -*- 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 .
+ */
+
+#include <mtftools.hxx>
+
+#include <memory>
+#include <basegfx/matrix/b2dhommatrix.hxx>
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+#include <vcl/metric.hxx>
+#include <vcl/graphictools.hxx>
+#include <vcl/BitmapTools.hxx>
+#include <vcl/metaact.hxx>
+#include <vcl/canvastools.hxx>
+#include <vcl/svapp.hxx>
+#include <tools/stream.hxx>
+#include <rtl/tencinfo.h>
+#include <sal/log.hxx>
+#include <osl/diagnose.h>
+#include <vcl/virdev.hxx>
+#include <o3tl/safeint.hxx>
+#include <unotools/configmgr.hxx>
+#include <unotools/defaultencoding.hxx>
+#include <unotools/wincodepage.hxx>
+
+#if OSL_DEBUG_LEVEL > 1
+#define EMFP_DEBUG(x) x
+#else
+#define EMFP_DEBUG(x)
+#endif
+
+namespace emfio
+{
+ SvStream& operator >> (SvStream& rInStream, XForm& rXForm)
+ {
+ if (sizeof(float) != 4)
+ {
+ OSL_FAIL("EmfReader::sizeof( float ) != 4");
+ rXForm = XForm();
+ }
+ else
+ {
+ rInStream.ReadFloat(rXForm.eM11);
+ rInStream.ReadFloat(rXForm.eM12);
+ rInStream.ReadFloat(rXForm.eM21);
+ rInStream.ReadFloat(rXForm.eM22);
+ rInStream.ReadFloat(rXForm.eDx);
+ rInStream.ReadFloat(rXForm.eDy);
+ }
+ return rInStream;
+ }
+
+ void WinMtfClipPath::intersectClipRect( const tools::Rectangle& rRect )
+ {
+ maClip.intersectRange(vcl::unotools::b2DRectangleFromRectangle(rRect));
+ }
+
+ void WinMtfClipPath::excludeClipRect( const tools::Rectangle& rRect )
+ {
+ maClip.subtractRange(vcl::unotools::b2DRectangleFromRectangle(rRect));
+ }
+
+ void WinMtfClipPath::setClipPath( const tools::PolyPolygon& rPolyPolygon, sal_Int32 nClippingMode )
+ {
+ const basegfx::B2DPolyPolygon& rB2DPoly=rPolyPolygon.getB2DPolyPolygon();
+ switch ( nClippingMode )
+ {
+ case RGN_OR :
+ maClip.unionPolyPolygon(rB2DPoly);
+ break;
+ case RGN_XOR :
+ maClip.xorPolyPolygon(rB2DPoly);
+ break;
+ case RGN_DIFF :
+ maClip.subtractPolyPolygon(rB2DPoly);
+ break;
+ case RGN_AND :
+ maClip.intersectPolyPolygon(rB2DPoly);
+ break;
+ case RGN_COPY :
+ maClip = basegfx::utils::B2DClipState(rB2DPoly);
+ break;
+ }
+ }
+
+ void WinMtfClipPath::moveClipRegion( const Size& rSize )
+ {
+ basegfx::B2DHomMatrix aTranslate;
+ aTranslate.translate(rSize.Width(), rSize.Height());
+ maClip.transform(aTranslate);
+ }
+
+ void WinMtfClipPath::setDefaultClipPath()
+ {
+ // Empty clip region - everything visible
+ maClip = basegfx::utils::B2DClipState();
+ }
+
+ basegfx::B2DPolyPolygon const & WinMtfClipPath::getClipPath() const
+ {
+ return maClip.getClipPoly();
+ }
+
+ void WinMtfPathObj::AddPoint( const Point& rPoint )
+ {
+ if ( bClosed )
+ Insert( tools::Polygon() );
+ tools::Polygon& rPoly = static_cast<tools::PolyPolygon&>(*this)[ Count() - 1 ];
+ rPoly.Insert( rPoly.GetSize(), rPoint );
+ bClosed = false;
+ }
+
+ void WinMtfPathObj::AddPolyLine( const tools::Polygon& rPolyLine )
+ {
+ if ( bClosed )
+ Insert( tools::Polygon() );
+ tools::Polygon& rPoly = static_cast<tools::PolyPolygon&>(*this)[ Count() - 1 ];
+ rPoly.Insert( rPoly.GetSize(), rPolyLine );
+ bClosed = false;
+ }
+
+ void WinMtfPathObj::AddPolygon( const tools::Polygon& rPoly )
+ {
+ Insert( rPoly );
+ bClosed = true;
+ }
+
+ void WinMtfPathObj::AddPolyPolygon( const tools::PolyPolygon& rPolyPoly )
+ {
+ sal_uInt16 i, nCount = rPolyPoly.Count();
+ for ( i = 0; i < nCount; i++ )
+ Insert( rPolyPoly[ i ] );
+ bClosed = true;
+ }
+
+ void WinMtfPathObj::ClosePath()
+ {
+ if ( Count() )
+ {
+ tools::Polygon& rPoly = static_cast<tools::PolyPolygon&>(*this)[ Count() - 1 ];
+ if ( rPoly.GetSize() > 2 )
+ {
+ Point aFirst( rPoly[ 0 ] );
+ if ( aFirst != rPoly[ rPoly.GetSize() - 1 ] )
+ rPoly.Insert( rPoly.GetSize(), aFirst );
+ }
+ }
+ bClosed = true;
+ }
+
+ WinMtfFontStyle::WinMtfFontStyle( LOGFONTW const & rFont )
+ {
+ rtl_TextEncoding eCharSet;
+ if ((rFont.alfFaceName == "Symbol")
+ || (rFont.alfFaceName == "MT Extra"))
+ eCharSet = RTL_TEXTENCODING_SYMBOL;
+ else if ((rFont.lfCharSet == DEFAULT_CHARSET) || (rFont.lfCharSet == OEM_CHARSET))
+ eCharSet = utl_getWinTextEncodingFromLangStr(utl_getLocaleForGlobalDefaultEncoding(),
+ rFont.lfCharSet == OEM_CHARSET);
+ else
+ eCharSet = rtl_getTextEncodingFromWindowsCharset( rFont.lfCharSet );
+ if ( eCharSet == RTL_TEXTENCODING_DONTKNOW )
+ eCharSet = RTL_TEXTENCODING_MS_1252;
+ aFont.SetCharSet( eCharSet );
+ aFont.SetFamilyName( rFont.alfFaceName );
+ FontFamily eFamily;
+ switch ( rFont.lfPitchAndFamily & 0xf0 )
+ {
+ case FF_ROMAN:
+ eFamily = FAMILY_ROMAN;
+ break;
+
+ case FF_SWISS:
+ eFamily = FAMILY_SWISS;
+ break;
+
+ case FF_MODERN:
+ eFamily = FAMILY_MODERN;
+ break;
+
+ case FF_SCRIPT:
+ eFamily = FAMILY_SCRIPT;
+ break;
+
+ case FF_DECORATIVE:
+ eFamily = FAMILY_DECORATIVE;
+ break;
+
+ default:
+ eFamily = FAMILY_DONTKNOW;
+ break;
+ }
+ aFont.SetFamily( eFamily );
+
+ FontPitch ePitch;
+ switch ( rFont.lfPitchAndFamily & 0x0f )
+ {
+ case FIXED_PITCH:
+ ePitch = PITCH_FIXED;
+ break;
+
+ case DEFAULT_PITCH:
+ case VARIABLE_PITCH:
+ default:
+ ePitch = PITCH_VARIABLE;
+ break;
+ }
+ aFont.SetPitch( ePitch );
+
+ FontWeight eWeight;
+ if (rFont.lfWeight == 0) // default weight SHOULD be used
+ eWeight = WEIGHT_DONTKNOW;
+ else if (rFont.lfWeight <= FW_THIN)
+ eWeight = WEIGHT_THIN;
+ else if( rFont.lfWeight <= FW_ULTRALIGHT )
+ eWeight = WEIGHT_ULTRALIGHT;
+ else if( rFont.lfWeight <= FW_LIGHT )
+ eWeight = WEIGHT_LIGHT;
+ else if( rFont.lfWeight < FW_MEDIUM )
+ eWeight = WEIGHT_NORMAL;
+ else if( rFont.lfWeight == FW_MEDIUM )
+ eWeight = WEIGHT_MEDIUM;
+ else if( rFont.lfWeight <= FW_SEMIBOLD )
+ eWeight = WEIGHT_SEMIBOLD;
+ else if( rFont.lfWeight <= FW_BOLD )
+ eWeight = WEIGHT_BOLD;
+ else if( rFont.lfWeight <= FW_ULTRABOLD )
+ eWeight = WEIGHT_ULTRABOLD;
+ else
+ eWeight = WEIGHT_BLACK;
+ aFont.SetWeight( eWeight );
+
+ if( rFont.lfItalic )
+ aFont.SetItalic( ITALIC_NORMAL );
+
+ if( rFont.lfUnderline )
+ aFont.SetUnderline( LINESTYLE_SINGLE );
+
+ if( rFont.lfStrikeOut )
+ aFont.SetStrikeout( STRIKEOUT_SINGLE );
+
+ aFont.SetOrientation( static_cast<short>(rFont.lfEscapement) );
+
+ Size aFontSize( Size( rFont.lfWidth, rFont.lfHeight ) );
+ if ( rFont.lfHeight > 0 )
+ {
+ // #i117968# VirtualDevice is not thread safe, but filter is used in multithreading
+ SolarMutexGuard aGuard;
+ ScopedVclPtrInstance< VirtualDevice > pVDev;
+ // converting the cell height into a font height
+ aFont.SetFontSize( aFontSize );
+ pVDev->SetFont( aFont );
+ FontMetric aMetric( pVDev->GetFontMetric() );
+ long nHeight = aMetric.GetAscent() + aMetric.GetDescent();
+ if (nHeight)
+ {
+ double fHeight = (static_cast<double>(aFontSize.Height()) * rFont.lfHeight ) / nHeight;
+ aFontSize.setHeight( static_cast<sal_Int32>( fHeight + 0.5 ) );
+ }
+ }
+
+ // Convert height to positive
+ aFontSize.setHeight( std::abs(aFontSize.Height()) );
+
+ aFont.SetFontSize(aFontSize);
+ };
+
+ Color MtfTools::ReadColor()
+ {
+ sal_uInt32 nColor;
+
+ mpInputStream->ReadUInt32( nColor );
+ Color aColor(static_cast<sal_uInt8>(nColor), static_cast<sal_uInt8>(nColor >> 8), static_cast<sal_uInt8>(nColor >> 16));
+
+ SAL_INFO("emfio", "\t\tColor: " << aColor);
+
+ return aColor;
+ };
+
+ Point MtfTools::ImplScale(const Point& rPoint) // Hack to set varying defaults for incompletely defined files.
+ {
+ if (!mbIsMapDevSet)
+ return Point(rPoint.X() * UNDOCUMENTED_WIN_RCL_RELATION - mrclFrame.Left(),
+ rPoint.Y() * UNDOCUMENTED_WIN_RCL_RELATION - mrclFrame.Top());
+ else
+ return rPoint;
+ }
+
+ Point MtfTools::ImplMap( const Point& rPt )
+ {
+ if ( mnWinExtX && mnWinExtY )
+ {
+ double fX = rPt.X();
+ double fY = rPt.Y();
+
+ double fX2 = fX * maXForm.eM11 + fY * maXForm.eM21 + maXForm.eDx;
+ double fY2 = fX * maXForm.eM12 + fY * maXForm.eM22 + maXForm.eDy;
+
+ if ( mnGfxMode == GM_COMPATIBLE )
+ {
+ switch( mnMapMode )
+ {
+ case MM_LOENGLISH :
+ {
+ fX2 -= mnWinOrgX;
+ fY2 = mnWinOrgY-fY2;
+ fX2 *= HUNDREDTH_MILLIMETERS_PER_MILLIINCH*10;
+ fY2 *= HUNDREDTH_MILLIMETERS_PER_MILLIINCH*10;
+ fX2 += mnDevOrgX;
+ fY2 += mnDevOrgY;
+ }
+ break;
+ case MM_HIENGLISH :
+ {
+ fX2 -= mnWinOrgX;
+ fY2 = mnWinOrgY-fY2;
+ fX2 *= HUNDREDTH_MILLIMETERS_PER_MILLIINCH;
+ fY2 *= HUNDREDTH_MILLIMETERS_PER_MILLIINCH;
+ fX2 += mnDevOrgX;
+ fY2 += mnDevOrgY;
+ }
+ break;
+ case MM_TWIPS:
+ {
+ fX2 -= mnWinOrgX;
+ fY2 = mnWinOrgY-fY2;
+ fX2 *= HUNDREDTH_MILLIMETERS_PER_MILLIINCH/MILLIINCH_PER_TWIPS;
+ fY2 *= HUNDREDTH_MILLIMETERS_PER_MILLIINCH/MILLIINCH_PER_TWIPS;
+ fX2 += mnDevOrgX;
+ fY2 += mnDevOrgY;
+ }
+ break;
+ case MM_LOMETRIC :
+ {
+ fX2 -= mnWinOrgX;
+ fY2 = mnWinOrgY-fY2;
+ fX2 *= 10;
+ fY2 *= 10;
+ fX2 += mnDevOrgX;
+ fY2 += mnDevOrgY;
+ }
+ break;
+ case MM_HIMETRIC : // in hundredth of a millimeter
+ {
+ fX2 -= mnWinOrgX;
+ fY2 = mnWinOrgY-fY2;
+ fX2 += mnDevOrgX;
+ fY2 += mnDevOrgY;
+ }
+ break;
+ default :
+ {
+ if (mnPixX == 0 || mnPixY == 0)
+ {
+ SAL_WARN("emfio", "invalid scaling factor");
+ return Point();
+ }
+ else
+ {
+ fX2 -= mnWinOrgX;
+ fY2 -= mnWinOrgY;
+ if ( mnMapMode != MM_TEXT )
+ {
+ fX2 /= mnWinExtX;
+ fY2 /= mnWinExtY;
+ fX2 *= mnDevWidth;
+ fY2 *= mnDevHeight;
+ }
+ fX2 += mnDevOrgX;
+ fY2 += mnDevOrgY; // fX2, fY2 now in device units
+ fX2 *= static_cast<double>(mnMillX) * 100.0 / static_cast<double>(mnPixX);
+ fY2 *= static_cast<double>(mnMillY) * 100.0 / static_cast<double>(mnPixY);
+ }
+ }
+ break;
+ }
+ fX2 -= mrclFrame.Left();
+ fY2 -= mrclFrame.Top();
+ }
+ return Point(basegfx::fround(fX2), basegfx::fround(fY2));
+ }
+ else
+ return Point();
+ };
+
+ Size MtfTools::ImplMap(const Size& rSz, bool bDoWorldTransform)
+ {
+ if ( mnWinExtX && mnWinExtY )
+ {
+ // #i121382# apply the whole WorldTransform, else a rotation will be misinterpreted
+ double fWidth, fHeight;
+ if (bDoWorldTransform)
+ {
+ fWidth = rSz.Width() * maXForm.eM11 + rSz.Height() * maXForm.eM21;
+ fHeight = rSz.Width() * maXForm.eM12 + rSz.Height() * maXForm.eM22;
+ }
+ else
+ {
+ //take the scale, but not the rotation
+ basegfx::B2DHomMatrix aMatrix(maXForm.eM11, maXForm.eM12, 0,
+ maXForm.eM21, maXForm.eM22, 0);
+ basegfx::B2DTuple aScale, aTranslate;
+ double fRotate, fShearX;
+ if (!aMatrix.decompose(aScale, aTranslate, fRotate, fShearX))
+ {
+ aScale.setX(1.0);
+ aScale.setY(1.0);
+ }
+ fWidth = rSz.Width() * aScale.getX();
+ fHeight = rSz.Height() * aScale.getY();
+ }
+
+ if ( mnGfxMode == GM_COMPATIBLE )
+ {
+ switch( mnMapMode )
+ {
+ case MM_LOENGLISH :
+ {
+ fWidth *= HUNDREDTH_MILLIMETERS_PER_MILLIINCH*10;
+ fHeight*=-HUNDREDTH_MILLIMETERS_PER_MILLIINCH*10;
+ }
+ break;
+ case MM_HIENGLISH :
+ {
+ fWidth *= HUNDREDTH_MILLIMETERS_PER_MILLIINCH;
+ fHeight*=-HUNDREDTH_MILLIMETERS_PER_MILLIINCH;
+ }
+ break;
+ case MM_LOMETRIC :
+ {
+ fWidth *= 10;
+ fHeight*=-10;
+ }
+ break;
+ case MM_HIMETRIC : // in hundredth of millimeters
+ {
+ fHeight *= -1;
+ }
+ break;
+ case MM_TWIPS:
+ {
+ fWidth *= HUNDREDTH_MILLIMETERS_PER_MILLIINCH/MILLIINCH_PER_TWIPS;
+ fHeight*=-HUNDREDTH_MILLIMETERS_PER_MILLIINCH/MILLIINCH_PER_TWIPS;
+ }
+ break;
+ default :
+ {
+ if (mnPixX == 0 || mnPixY == 0)
+ {
+ SAL_WARN("emfio", "invalid scaling factor");
+ return Size();
+ }
+ else
+ {
+ if ( mnMapMode != MM_TEXT )
+ {
+ fWidth /= mnWinExtX;
+ fHeight /= mnWinExtY;
+ fWidth *= mnDevWidth;
+ fHeight *= mnDevHeight;
+ }
+ fWidth *= static_cast<double>(mnMillX) * 100.0 / static_cast<double>(mnPixX);
+ fHeight *= static_cast<double>(mnMillY) * 100.0 / static_cast<double>(mnPixY);
+ }
+ }
+ break;
+ }
+ }
+ return Size(basegfx::fround(fWidth), basegfx::fround(fHeight));
+ }
+ else
+ return Size();
+ }
+
+ tools::Rectangle MtfTools::ImplMap( const tools::Rectangle& rRect )
+ {
+ tools::Rectangle aRect;
+ aRect.SetPos(ImplMap(rRect.TopLeft()));
+ aRect.SaturatingSetSize(ImplMap(rRect.GetSize()));
+ return aRect;
+ }
+
+ void MtfTools::ImplMap( vcl::Font& rFont )
+ {
+ // !!! HACK: we now always set the width to zero because the OS width is interpreted differently;
+ // must later be made portable in SV (KA 1996-02-08)
+ Size aFontSize = ImplMap (rFont.GetFontSize(), false);
+
+ const auto nHeight = aFontSize.Height();
+ if (nHeight < 0)
+ aFontSize.setHeight( o3tl::saturating_toggle_sign(nHeight) );
+
+ rFont.SetFontSize( aFontSize );
+
+ sal_Int32 nResult;
+ const bool bFail = o3tl::checked_multiply(mnWinExtX, mnWinExtY, nResult);
+ if (!bFail && nResult < 0)
+ rFont.SetOrientation( 3600 - rFont.GetOrientation() );
+ }
+
+ tools::Polygon& MtfTools::ImplMap( tools::Polygon& rPolygon )
+ {
+ sal_uInt16 nPoints = rPolygon.GetSize();
+ for ( sal_uInt16 i = 0; i < nPoints; i++ )
+ {
+ rPolygon[ i ] = ImplMap( rPolygon[ i ] );
+ }
+ return rPolygon;
+ }
+
+ void MtfTools::ImplScale( tools::Polygon& rPolygon )
+ {
+ sal_uInt16 nPoints = rPolygon.GetSize();
+ for ( sal_uInt16 i = 0; i < nPoints; i++ )
+ {
+ rPolygon[ i ] = ImplScale( rPolygon[ i ] );
+ }
+ }
+
+ tools::PolyPolygon& MtfTools::ImplScale( tools::PolyPolygon& rPolyPolygon )
+ {
+ sal_uInt16 nPolys = rPolyPolygon.Count();
+ for (sal_uInt16 i = 0; i < nPolys; ++i)
+ {
+ ImplScale(rPolyPolygon[i]);
+ }
+ return rPolyPolygon;
+ }
+
+ tools::PolyPolygon& MtfTools::ImplMap( tools::PolyPolygon& rPolyPolygon )
+ {
+ sal_uInt16 nPolys = rPolyPolygon.Count();
+ for ( sal_uInt16 i = 0; i < nPolys; ImplMap( rPolyPolygon[ i++ ] ) ) ;
+ return rPolyPolygon;
+ }
+
+ void MtfTools::SelectObject( sal_Int32 nIndex )
+ {
+ if ( nIndex & ENHMETA_STOCK_OBJECT )
+ {
+ sal_uInt16 nStockId = static_cast<sal_uInt8>(nIndex);
+ switch( nStockId )
+ {
+ case WHITE_BRUSH :
+ {
+ maFillStyle = WinMtfFillStyle( COL_WHITE );
+ mbFillStyleSelected = true;
+ }
+ break;
+ case LTGRAY_BRUSH :
+ {
+ maFillStyle = WinMtfFillStyle( COL_LIGHTGRAY );
+ mbFillStyleSelected = true;
+ }
+ break;
+ case GRAY_BRUSH :
+ case DKGRAY_BRUSH :
+ {
+ maFillStyle = WinMtfFillStyle( COL_GRAY );
+ mbFillStyleSelected = true;
+ }
+ break;
+ case BLACK_BRUSH :
+ {
+ maFillStyle = WinMtfFillStyle( COL_BLACK );
+ mbFillStyleSelected = true;
+ }
+ break;
+ case NULL_BRUSH :
+ {
+ maFillStyle = WinMtfFillStyle( COL_TRANSPARENT, true );
+ mbFillStyleSelected = true;
+ }
+ break;
+ case WHITE_PEN :
+ {
+ maLineStyle = WinMtfLineStyle( COL_WHITE );
+ }
+ break;
+ case BLACK_PEN :
+ {
+ maLineStyle = WinMtfLineStyle( COL_BLACK );
+ }
+ break;
+ case NULL_PEN :
+ {
+ maLineStyle = WinMtfLineStyle( COL_TRANSPARENT, true );
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ else
+ {
+ nIndex &= 0xffff; // safety check: don't allow index to be > 65535
+
+ GDIObj *pGDIObj = nullptr;
+
+ if ( o3tl::make_unsigned(nIndex) < mvGDIObj.size() )
+ pGDIObj = mvGDIObj[ nIndex ].get();
+
+ if ( pGDIObj )
+ {
+ if (const auto pen = dynamic_cast<WinMtfLineStyle*>(pGDIObj))
+ maLineStyle = *pen;
+ else if (const auto brush = dynamic_cast<WinMtfFillStyle*>(
+ pGDIObj))
+ {
+ maFillStyle = *brush;
+ mbFillStyleSelected = true;
+ }
+ else if (const auto font = dynamic_cast<WinMtfFontStyle*>(
+ pGDIObj))
+ {
+ maFont = font->aFont;
+ }
+ }
+ }
+ }
+
+ void MtfTools::SetTextLayoutMode( ComplexTextLayoutFlags nTextLayoutMode )
+ {
+ mnTextLayoutMode = nTextLayoutMode;
+ }
+
+ void MtfTools::SetBkMode( BkMode nMode )
+ {
+ mnBkMode = nMode;
+ }
+
+ void MtfTools::SetBkColor( const Color& rColor )
+ {
+ maBkColor = rColor;
+ }
+
+ void MtfTools::SetTextColor( const Color& rColor )
+ {
+ maTextColor = rColor;
+ }
+
+ void MtfTools::SetTextAlign( sal_uInt32 nAlign )
+ {
+ mnTextAlign = nAlign;
+ }
+
+ void MtfTools::ImplResizeObjectArry( sal_uInt32 nNewEntrys )
+ {
+ mvGDIObj.resize(nNewEntrys);
+ }
+
+ void MtfTools::ImplDrawClippedPolyPolygon( const tools::PolyPolygon& rPolyPoly )
+ {
+ if ( !rPolyPoly.Count() )
+ return;
+
+ ImplSetNonPersistentLineColorTransparenz();
+ if ( rPolyPoly.Count() == 1 )
+ {
+ if ( rPolyPoly.IsRect() )
+ mpGDIMetaFile->AddAction( new MetaRectAction( rPolyPoly.GetBoundRect() ) );
+ else
+ {
+ tools::Polygon aPoly( rPolyPoly[ 0 ] );
+ sal_uInt16 nCount = aPoly.GetSize();
+ if ( nCount )
+ {
+ if ( aPoly[ nCount - 1 ] != aPoly[ 0 ] )
+ {
+ Point aPoint( aPoly[ 0 ] );
+ aPoly.Insert( nCount, aPoint );
+ }
+ mpGDIMetaFile->AddAction( new MetaPolygonAction( aPoly ) );
+ }
+ }
+ }
+ else
+ mpGDIMetaFile->AddAction( new MetaPolyPolygonAction( rPolyPoly ) );
+ }
+
+ void MtfTools::CreateObject( std::unique_ptr<GDIObj> pObject )
+ {
+ if ( pObject )
+ {
+ const auto pLineStyle = dynamic_cast<WinMtfLineStyle*>(pObject.get());
+ const auto pFontStyle = dynamic_cast<WinMtfFontStyle*>(pObject.get());
+
+ if ( pFontStyle )
+ {
+ if (pFontStyle->aFont.GetFontHeight() == 0)
+ pFontStyle->aFont.SetFontHeight(423);
+ ImplMap(pFontStyle->aFont); // defaulting to 12pt
+ }
+ else if ( pLineStyle )
+ {
+ Size aSize(pLineStyle->aLineInfo.GetWidth(), 0);
+ aSize = ImplMap(aSize);
+ pLineStyle->aLineInfo.SetWidth(aSize.Width());
+ }
+ }
+ std::vector<std::unique_ptr<GDIObj>>::size_type nIndex;
+ for ( nIndex = 0; nIndex < mvGDIObj.size(); nIndex++ )
+ {
+ if ( !mvGDIObj[ nIndex ] )
+ break;
+ }
+ if ( nIndex == mvGDIObj.size() )
+ ImplResizeObjectArry( mvGDIObj.size() + 16 );
+
+ mvGDIObj[ nIndex ] = std::move(pObject);
+ }
+
+ void MtfTools::CreateObjectIndexed( sal_Int32 nIndex, std::unique_ptr<GDIObj> pObject )
+ {
+ if ( ( nIndex & ENHMETA_STOCK_OBJECT ) != 0 )
+ return;
+
+ nIndex &= 0xffff; // safety check: do not allow index to be > 65535
+ if ( pObject )
+ {
+ const auto pLineStyle = dynamic_cast<WinMtfLineStyle*>(pObject.get());
+ const auto pFontStyle = dynamic_cast<WinMtfFontStyle*>(pObject.get());
+ if ( pFontStyle )
+ {
+ if (pFontStyle->aFont.GetFontHeight() == 0)
+ pFontStyle->aFont.SetFontHeight(423);
+ ImplMap(pFontStyle->aFont);
+ }
+ else if ( pLineStyle )
+ {
+ Size aSize(pLineStyle->aLineInfo.GetWidth(), 0);
+ pLineStyle->aLineInfo.SetWidth( ImplMap(aSize).Width() );
+
+ if ( pLineStyle->aLineInfo.GetStyle() == LineStyle::Dash )
+ {
+ aSize.AdjustWidth(1 );
+ long nDotLen = ImplMap( aSize ).Width();
+ pLineStyle->aLineInfo.SetDistance( nDotLen );
+ pLineStyle->aLineInfo.SetDotLen( nDotLen );
+ pLineStyle->aLineInfo.SetDashLen( nDotLen * 3 );
+ }
+ }
+ }
+ if ( o3tl::make_unsigned(nIndex) >= mvGDIObj.size() )
+ ImplResizeObjectArry( nIndex + 16 );
+
+ mvGDIObj[ nIndex ] = std::move(pObject);
+ }
+
+ void MtfTools::CreateObject()
+ {
+ CreateObject(std::make_unique<GDIObj>());
+ }
+
+ void MtfTools::DeleteObject( sal_Int32 nIndex )
+ {
+ if ( ( nIndex & ENHMETA_STOCK_OBJECT ) == 0 )
+ {
+ if ( o3tl::make_unsigned(nIndex) < mvGDIObj.size() )
+ {
+ mvGDIObj[ nIndex ].reset();
+ }
+ }
+ }
+
+ void MtfTools::IntersectClipRect( const tools::Rectangle& rRect )
+ {
+ if (utl::ConfigManager::IsFuzzing())
+ return;
+ mbClipNeedsUpdate=true;
+ if ((rRect.Left()-rRect.Right()==0) && (rRect.Top()-rRect.Bottom()==0))
+ {
+ return; // empty rectangles cause trouble
+ }
+ maClipPath.intersectClipRect( ImplMap( rRect ) );
+ }
+
+ void MtfTools::ExcludeClipRect( const tools::Rectangle& rRect )
+ {
+ if (utl::ConfigManager::IsFuzzing())
+ return;
+ mbClipNeedsUpdate=true;
+ maClipPath.excludeClipRect( ImplMap( rRect ) );
+ }
+
+ void MtfTools::MoveClipRegion( const Size& rSize )
+ {
+ if (utl::ConfigManager::IsFuzzing())
+ return;
+ mbClipNeedsUpdate=true;
+ maClipPath.moveClipRegion( ImplMap( rSize ) );
+ }
+
+ void MtfTools::SetClipPath( const tools::PolyPolygon& rPolyPolygon, sal_Int32 nClippingMode, bool bIsMapped )
+ {
+ if (utl::ConfigManager::IsFuzzing())
+ return;
+ mbClipNeedsUpdate = true;
+ tools::PolyPolygon aPolyPolygon(rPolyPolygon);
+
+ if (!bIsMapped)
+ {
+ if (!mbIsMapDevSet && (mnMapMode == MM_ISOTROPIC || mnMapMode == MM_ANISOTROPIC))
+ aPolyPolygon = ImplScale(aPolyPolygon);
+ else
+ aPolyPolygon = ImplMap(aPolyPolygon);
+ }
+ maClipPath.setClipPath(aPolyPolygon, nClippingMode);
+ }
+
+ void MtfTools::SetDefaultClipPath()
+ {
+ mbClipNeedsUpdate = true;
+ maClipPath.setDefaultClipPath();
+ }
+
+ MtfTools::MtfTools( GDIMetaFile& rGDIMetaFile, SvStream& rStreamWMF)
+ : maPathObj(),
+ maClipPath(),
+ maLatestLineStyle(),
+ maLineStyle(),
+ maNopLineStyle(),
+ maLatestFillStyle(),
+ maFillStyle(),
+ maNopFillStyle(),
+ maLatestFont(),
+ maFont(),
+ mnLatestTextAlign(90),
+ mnTextAlign(TA_LEFT | TA_TOP | TA_NOUPDATECP),
+ maLatestTextColor(),
+ maTextColor(),
+ maLatestBkColor(0x12345678),
+ maBkColor(COL_WHITE),
+ mnLatestTextLayoutMode(ComplexTextLayoutFlags::Default),
+ mnTextLayoutMode(ComplexTextLayoutFlags::Default),
+ mnLatestBkMode(BkMode::NONE),
+ mnBkMode(BkMode::OPAQUE),
+ meLatestRasterOp(RasterOp::Invert),
+ meRasterOp(RasterOp::OverPaint),
+ mvGDIObj(),
+ maActPos(),
+ mnRop(),
+ mvSaveStack(),
+ mnGfxMode(GM_COMPATIBLE),
+ mnMapMode(MM_TEXT),
+ maXForm(),
+ mnDevOrgX(0),
+ mnDevOrgY(0),
+ mnDevWidth(1),
+ mnDevHeight(1),
+ mnWinOrgX(0),
+ mnWinOrgY(0),
+ mnWinExtX(1),
+ mnWinExtY(1),
+ mnPixX(100),
+ mnPixY(100),
+ mnMillX(1),
+ mnMillY(1),
+ mrclFrame(),
+ mrclBounds(),
+ mpGDIMetaFile(&rGDIMetaFile),
+ mpInputStream(&rStreamWMF),
+ mnStartPos(0),
+ mnEndPos(0),
+ maBmpSaveList(),
+ mbNopMode(false),
+ mbFillStyleSelected(false),
+ mbClipNeedsUpdate(true),
+ mbComplexClip(false),
+ mbIsMapWinSet(false),
+ mbIsMapDevSet(false)
+ {
+ SvLockBytes *pLB = mpInputStream->GetLockBytes();
+
+ if (pLB)
+ {
+ pLB->SetSynchronMode();
+ }
+
+ mnStartPos = mpInputStream->Tell();
+ SetDevOrg(Point());
+
+ mpGDIMetaFile->AddAction( new MetaPushAction( PushFlags::CLIPREGION ) ); // The original clipregion has to be on top
+ // of the stack so it can always be restored
+ // this is necessary to be able to support
+ // SetClipRgn( NULL ) and similar ClipRgn actions (SJ)
+
+ maFont.SetFamilyName( "Arial" ); // sj: #i57205#, we do have some scaling problems if using
+ maFont.SetCharSet( RTL_TEXTENCODING_MS_1252 ); // the default font then most times a x11 font is used, we
+ maFont.SetFontHeight( 423 ); // will prevent this defining a font
+
+ maLatestLineStyle.aLineColor = Color( 0x12, 0x34, 0x56 );
+ maLatestFillStyle.aFillColor = Color( 0x12, 0x34, 0x56 );
+
+ mnRop = WMFRasterOp::Black;
+ meRasterOp = RasterOp::OverPaint;
+ mpGDIMetaFile->AddAction( new MetaRasterOpAction( RasterOp::OverPaint ) );
+ }
+
+ MtfTools::~MtfTools() COVERITY_NOEXCEPT_FALSE
+ {
+ mpGDIMetaFile->AddAction( new MetaPopAction() );
+ mpGDIMetaFile->SetPrefMapMode(MapMode(MapUnit::Map100thMM));
+ if ( mrclFrame.IsEmpty() )
+ mpGDIMetaFile->SetPrefSize( Size( mnDevWidth, mnDevHeight ) );
+ else
+ mpGDIMetaFile->SetPrefSize( mrclFrame.GetSize() );
+ }
+
+ void MtfTools::UpdateClipRegion()
+ {
+ if (!mbClipNeedsUpdate)
+ return;
+
+ mbClipNeedsUpdate = false;
+ mbComplexClip = false;
+
+ mpGDIMetaFile->AddAction( new MetaPopAction() ); // taking the original clipregion
+ mpGDIMetaFile->AddAction( new MetaPushAction( PushFlags::CLIPREGION ) );
+
+ // skip for 'no clipping at all' case
+ if( maClipPath.isEmpty() )
+ return;
+
+ const basegfx::B2DPolyPolygon& rClipPoly( maClipPath.getClipPath() );
+
+ mbComplexClip = rClipPoly.count() > 1
+ || !basegfx::utils::isRectangle(rClipPoly);
+
+ static bool bEnableComplexClipViaRegion = getenv("SAL_WMF_COMPLEXCLIP_VIA_REGION") != nullptr;
+
+ if (bEnableComplexClipViaRegion)
+ {
+ //this makes cases like tdf#45820 work in reasonable time, and I feel in theory should
+ //be just fine. In practice I see the output is different so needs work before its the
+ //default, but for file fuzzing it should be good enough
+ if (mbComplexClip)
+ {
+ mpGDIMetaFile->AddAction(
+ new MetaISectRegionClipRegionAction(
+ vcl::Region(rClipPoly)));
+ mbComplexClip = false;
+ }
+ else
+ {
+ mpGDIMetaFile->AddAction(
+ new MetaISectRectClipRegionAction(
+ vcl::unotools::rectangleFromB2DRectangle(
+ rClipPoly.getB2DRange())));
+ }
+ }
+ else
+ {
+ //normal case
+ mpGDIMetaFile->AddAction(
+ new MetaISectRectClipRegionAction(
+ vcl::unotools::rectangleFromB2DRectangle(
+ rClipPoly.getB2DRange())));
+ }
+ }
+
+ void MtfTools::ImplSetNonPersistentLineColorTransparenz()
+ {
+ WinMtfLineStyle aTransparentLine( COL_TRANSPARENT, true );
+ if ( ! ( maLatestLineStyle == aTransparentLine ) )
+ {
+ maLatestLineStyle = aTransparentLine;
+ mpGDIMetaFile->AddAction( new MetaLineColorAction( aTransparentLine.aLineColor, !aTransparentLine.bTransparent ) );
+ }
+ }
+
+ void MtfTools::UpdateLineStyle()
+ {
+ if (!( maLatestLineStyle == maLineStyle ) )
+ {
+ maLatestLineStyle = maLineStyle;
+ mpGDIMetaFile->AddAction( new MetaLineColorAction( maLineStyle.aLineColor, !maLineStyle.bTransparent ) );
+ }
+ }
+
+ void MtfTools::UpdateFillStyle()
+ {
+ if ( !mbFillStyleSelected ) // SJ: #i57205# taking care of bkcolor if no brush is selected
+ maFillStyle = WinMtfFillStyle( maBkColor, mnBkMode == BkMode::Transparent );
+ if (!( maLatestFillStyle == maFillStyle ) )
+ {
+ maLatestFillStyle = maFillStyle;
+ if (maFillStyle.aType == WinMtfFillStyleType::Solid)
+ mpGDIMetaFile->AddAction( new MetaFillColorAction( maFillStyle.aFillColor, !maFillStyle.bTransparent ) );
+ }
+ }
+
+ WMFRasterOp MtfTools::SetRasterOp( WMFRasterOp nRasterOp )
+ {
+ WMFRasterOp nRetROP = mnRop;
+ if ( nRasterOp != mnRop )
+ {
+ mnRop = nRasterOp;
+
+ if ( mbNopMode && ( nRasterOp != WMFRasterOp::Nop ) )
+ { // changing modes from WMFRasterOp::Nop so set pen and brush
+ maFillStyle = maNopFillStyle;
+ maLineStyle = maNopLineStyle;
+ mbNopMode = false;
+ }
+ switch( nRasterOp )
+ {
+ case WMFRasterOp::Not:
+ meRasterOp = RasterOp::Invert;
+ break;
+
+ case WMFRasterOp::XorPen:
+ meRasterOp = RasterOp::Xor;
+ break;
+
+ case WMFRasterOp::Nop:
+ {
+ meRasterOp = RasterOp::OverPaint;
+ if( !mbNopMode )
+ {
+ maNopFillStyle = maFillStyle;
+ maNopLineStyle = maLineStyle;
+ maFillStyle = WinMtfFillStyle( COL_TRANSPARENT, true );
+ maLineStyle = WinMtfLineStyle( COL_TRANSPARENT, true );
+ mbNopMode = true;
+ }
+ }
+ break;
+
+ default:
+ meRasterOp = RasterOp::OverPaint;
+ break;
+ }
+ }
+ if ( nRetROP != nRasterOp )
+ mpGDIMetaFile->AddAction( new MetaRasterOpAction( meRasterOp ) );
+ return nRetROP;
+ };
+
+ void MtfTools::StrokeAndFillPath( bool bStroke, bool bFill )
+ {
+ if ( !maPathObj.Count() )
+ return;
+
+ UpdateClipRegion();
+ UpdateLineStyle();
+ UpdateFillStyle();
+ if ( bFill )
+ {
+ if ( !bStroke )
+ {
+ mpGDIMetaFile->AddAction( new MetaPushAction( PushFlags::LINECOLOR ) );
+ mpGDIMetaFile->AddAction( new MetaLineColorAction( Color(), false ) );
+ }
+ if ( maPathObj.Count() == 1 )
+ mpGDIMetaFile->AddAction( new MetaPolygonAction( maPathObj.GetObject( 0 ) ) );
+ else
+ mpGDIMetaFile->AddAction( new MetaPolyPolygonAction( maPathObj ) );
+
+ if ( !bStroke )
+ mpGDIMetaFile->AddAction( new MetaPopAction() );
+ }
+ else
+ {
+ sal_uInt16 i, nCount = maPathObj.Count();
+ for ( i = 0; i < nCount; i++ )
+ mpGDIMetaFile->AddAction( new MetaPolyLineAction( maPathObj[ i ], maLineStyle.aLineInfo ) );
+ }
+ ClearPath();
+ }
+
+ void MtfTools::DrawPixel( const Point& rSource, const Color& rColor )
+ {
+ mpGDIMetaFile->AddAction( new MetaPixelAction( ImplMap( rSource), rColor ) );
+ }
+
+ void MtfTools::MoveTo( const Point& rPoint, bool bRecordPath )
+ {
+ Point aDest( ImplMap( rPoint ) );
+ if ( bRecordPath )
+ {
+ // fdo#57353 create new subpath for subsequent moves
+ if ( maPathObj.Count() )
+ if ( maPathObj[ maPathObj.Count() - 1 ].GetSize() )
+ maPathObj.Insert( tools::Polygon() );
+ maPathObj.AddPoint( aDest );
+ }
+ maActPos = aDest;
+ }
+
+ void MtfTools::LineTo( const Point& rPoint, bool bRecordPath )
+ {
+ UpdateClipRegion();
+ Point aDest( ImplMap( rPoint ) );
+ if ( bRecordPath )
+ maPathObj.AddPoint( aDest );
+ else
+ {
+ UpdateLineStyle();
+ mpGDIMetaFile->AddAction( new MetaLineAction( maActPos, aDest, maLineStyle.aLineInfo ) );
+ }
+ maActPos = aDest;
+ }
+
+ void MtfTools::DrawRect( const tools::Rectangle& rRect, bool bEdge )
+ {
+ UpdateClipRegion();
+ UpdateFillStyle();
+
+ if ( mbComplexClip )
+ {
+ tools::Polygon aPoly( ImplMap( rRect ) );
+ tools::PolyPolygon aPolyPolyRect( aPoly );
+ tools::PolyPolygon aDest;
+ tools::PolyPolygon(maClipPath.getClipPath()).GetIntersection( aPolyPolyRect, aDest );
+ ImplDrawClippedPolyPolygon( aDest );
+ }
+ else
+ {
+ if ( bEdge )
+ {
+ if ( maLineStyle.aLineInfo.GetWidth() || ( maLineStyle.aLineInfo.GetStyle() == LineStyle::Dash ) )
+ {
+ ImplSetNonPersistentLineColorTransparenz();
+ mpGDIMetaFile->AddAction( new MetaRectAction( ImplMap( rRect ) ) );
+ UpdateLineStyle();
+ mpGDIMetaFile->AddAction( new MetaPolyLineAction( tools::Polygon( ImplMap( rRect ) ),maLineStyle.aLineInfo ) );
+ }
+ else
+ {
+ UpdateLineStyle();
+ mpGDIMetaFile->AddAction( new MetaRectAction( ImplMap( rRect ) ) );
+ }
+ }
+ else
+ {
+ ImplSetNonPersistentLineColorTransparenz();
+ mpGDIMetaFile->AddAction( new MetaRectAction( ImplMap( rRect ) ) );
+ }
+ }
+ }
+
+ void MtfTools::DrawRoundRect( const tools::Rectangle& rRect, const Size& rSize )
+ {
+ UpdateClipRegion();
+ UpdateLineStyle();
+ UpdateFillStyle();
+ mpGDIMetaFile->AddAction( new MetaRoundRectAction( ImplMap( rRect ), labs( ImplMap( rSize ).Width() ), labs( ImplMap( rSize ).Height() ) ) );
+ }
+
+ void MtfTools::DrawEllipse( const tools::Rectangle& rRect )
+ {
+ UpdateClipRegion();
+ UpdateFillStyle();
+
+ if ( maLineStyle.aLineInfo.GetWidth() || ( maLineStyle.aLineInfo.GetStyle() == LineStyle::Dash ) )
+ {
+ Point aCenter( ImplMap( rRect.Center() ) );
+ Size aRad( ImplMap( Size( rRect.GetWidth() / 2, rRect.GetHeight() / 2 ) ) );
+
+ ImplSetNonPersistentLineColorTransparenz();
+ mpGDIMetaFile->AddAction( new MetaEllipseAction( ImplMap( rRect ) ) );
+ UpdateLineStyle();
+ mpGDIMetaFile->AddAction( new MetaPolyLineAction( tools::Polygon( aCenter, aRad.Width(), aRad.Height() ), maLineStyle.aLineInfo ) );
+ }
+ else
+ {
+ UpdateLineStyle();
+ mpGDIMetaFile->AddAction( new MetaEllipseAction( ImplMap( rRect ) ) );
+ }
+ }
+
+ void MtfTools::DrawArc( const tools::Rectangle& rRect, const Point& rStart, const Point& rEnd, bool bTo )
+ {
+ UpdateClipRegion();
+ UpdateLineStyle();
+ UpdateFillStyle();
+
+ tools::Rectangle aRect( ImplMap( rRect ) );
+ Point aStart( ImplMap( rStart ) );
+ Point aEnd( ImplMap( rEnd ) );
+
+ if ( maLineStyle.aLineInfo.GetWidth() || ( maLineStyle.aLineInfo.GetStyle() == LineStyle::Dash ) )
+ {
+ if ( aStart == aEnd )
+ { // SJ: #i53768# if start & end is identical, then we have to draw a full ellipse
+ Point aCenter( aRect.Center() );
+ Size aRad( aRect.GetWidth() / 2, aRect.GetHeight() / 2 );
+
+ mpGDIMetaFile->AddAction( new MetaPolyLineAction( tools::Polygon( aCenter, aRad.Width(), aRad.Height() ), maLineStyle.aLineInfo ) );
+ }
+ else
+ mpGDIMetaFile->AddAction( new MetaPolyLineAction( tools::Polygon( aRect, aStart, aEnd, PolyStyle::Arc ), maLineStyle.aLineInfo ) );
+ }
+ else
+ mpGDIMetaFile->AddAction( new MetaArcAction( aRect, aStart, aEnd ) );
+
+ if ( bTo )
+ maActPos = aEnd;
+ }
+
+ void MtfTools::DrawPie( const tools::Rectangle& rRect, const Point& rStart, const Point& rEnd )
+ {
+ UpdateClipRegion();
+ UpdateFillStyle();
+
+ tools::Rectangle aRect( ImplMap( rRect ) );
+ Point aStart( ImplMap( rStart ) );
+ Point aEnd( ImplMap( rEnd ) );
+
+ if ( maLineStyle.aLineInfo.GetWidth() || ( maLineStyle.aLineInfo.GetStyle() == LineStyle::Dash ) )
+ {
+ ImplSetNonPersistentLineColorTransparenz();
+ mpGDIMetaFile->AddAction( new MetaPieAction( aRect, aStart, aEnd ) );
+ UpdateLineStyle();
+ mpGDIMetaFile->AddAction( new MetaPolyLineAction( tools::Polygon( aRect, aStart, aEnd, PolyStyle::Pie ), maLineStyle.aLineInfo ) );
+ }
+ else
+ {
+ UpdateLineStyle();
+ mpGDIMetaFile->AddAction( new MetaPieAction( aRect, aStart, aEnd ) );
+ }
+ }
+
+ void MtfTools::DrawChord( const tools::Rectangle& rRect, const Point& rStart, const Point& rEnd )
+ {
+ UpdateClipRegion();
+ UpdateFillStyle();
+
+ tools::Rectangle aRect( ImplMap( rRect ) );
+ Point aStart( ImplMap( rStart ) );
+ Point aEnd( ImplMap( rEnd ) );
+
+ if ( maLineStyle.aLineInfo.GetWidth() || ( maLineStyle.aLineInfo.GetStyle() == LineStyle::Dash ) )
+ {
+ ImplSetNonPersistentLineColorTransparenz();
+ mpGDIMetaFile->AddAction( new MetaChordAction( aRect, aStart, aEnd ) );
+ UpdateLineStyle();
+ mpGDIMetaFile->AddAction( new MetaPolyLineAction( tools::Polygon( aRect, aStart, aEnd, PolyStyle::Chord ), maLineStyle.aLineInfo ) );
+ }
+ else
+ {
+ UpdateLineStyle();
+ mpGDIMetaFile->AddAction( new MetaChordAction( aRect, aStart, aEnd ) );
+ }
+ }
+
+ void MtfTools::DrawPolygon( tools::Polygon rPolygon, bool bRecordPath )
+ {
+ UpdateClipRegion();
+ ImplMap( rPolygon );
+ if ( bRecordPath )
+ maPathObj.AddPolygon( rPolygon );
+ else
+ {
+ UpdateFillStyle();
+
+ if ( mbComplexClip )
+ {
+ tools::PolyPolygon aPolyPoly( rPolygon );
+ auto tmp = maClipPath.getClip();
+ tmp.intersectPolyPolygon(aPolyPoly.getB2DPolyPolygon());
+ tools::PolyPolygon aDest(tmp.getClipPoly());
+ ImplDrawClippedPolyPolygon( aDest );
+ }
+ else
+ {
+ if ( maLineStyle.aLineInfo.GetWidth() || ( maLineStyle.aLineInfo.GetStyle() == LineStyle::Dash ) )
+ {
+ sal_uInt16 nCount = rPolygon.GetSize();
+ if ( nCount )
+ {
+ if ( rPolygon[ nCount - 1 ] != rPolygon[ 0 ] )
+ {
+ Point aPoint( rPolygon[ 0 ] );
+ rPolygon.Insert( nCount, aPoint );
+ }
+ }
+ ImplSetNonPersistentLineColorTransparenz();
+ mpGDIMetaFile->AddAction( new MetaPolygonAction( rPolygon ) );
+ UpdateLineStyle();
+ mpGDIMetaFile->AddAction( new MetaPolyLineAction( rPolygon, maLineStyle.aLineInfo ) );
+ }
+ else
+ {
+ UpdateLineStyle();
+
+ if (maLatestFillStyle.aType != WinMtfFillStyleType::Pattern)
+ mpGDIMetaFile->AddAction( new MetaPolygonAction( rPolygon ) );
+ else {
+ SvtGraphicFill aFill( tools::PolyPolygon( rPolygon ),
+ Color(),
+ 0.0,
+ SvtGraphicFill::fillNonZero,
+ SvtGraphicFill::fillTexture,
+ SvtGraphicFill::Transform(),
+ true,
+ SvtGraphicFill::hatchSingle,
+ Color(),
+ SvtGraphicFill::GradientType::Linear,
+ Color(),
+ Color(),
+ 0,
+ Graphic (maLatestFillStyle.aBmp) );
+
+ SvMemoryStream aMemStm;
+
+ WriteSvtGraphicFill( aMemStm, aFill );
+
+ mpGDIMetaFile->AddAction( new MetaCommentAction( "XPATHFILL_SEQ_BEGIN", 0,
+ static_cast<const sal_uInt8*>(aMemStm.GetData()),
+ aMemStm.TellEnd() ) );
+ mpGDIMetaFile->AddAction( new MetaCommentAction( "XPATHFILL_SEQ_END" ) );
+ }
+
+ }
+ }
+ }
+ }
+
+ void MtfTools::DrawPolyPolygon( tools::PolyPolygon& rPolyPolygon, bool bRecordPath )
+ {
+ UpdateClipRegion();
+
+ ImplMap( rPolyPolygon );
+
+ if ( bRecordPath )
+ maPathObj.AddPolyPolygon( rPolyPolygon );
+ else
+ {
+ UpdateFillStyle();
+
+ if ( mbComplexClip )
+ {
+ tools::PolyPolygon aDest;
+ tools::PolyPolygon(maClipPath.getClipPath()).GetIntersection( rPolyPolygon, aDest );
+ ImplDrawClippedPolyPolygon( aDest );
+ }
+ else
+ {
+ UpdateLineStyle();
+ mpGDIMetaFile->AddAction( new MetaPolyPolygonAction( rPolyPolygon ) );
+ if (maLineStyle.aLineInfo.GetWidth() > 0 || maLineStyle.aLineInfo.GetStyle() == LineStyle::Dash)
+ {
+ for (sal_uInt16 nPoly = 0; nPoly < rPolyPolygon.Count(); ++nPoly)
+ {
+ mpGDIMetaFile->AddAction(new MetaPolyLineAction(rPolyPolygon[nPoly], maLineStyle.aLineInfo));
+ }
+ }
+ }
+ }
+ }
+
+ void MtfTools::DrawPolyLine( tools::Polygon rPolygon, bool bTo, bool bRecordPath )
+ {
+ UpdateClipRegion();
+
+ sal_uInt16 nPoints = rPolygon.GetSize();
+ if (nPoints < 1)
+ return;
+
+ ImplMap( rPolygon );
+ if ( bTo )
+ {
+ rPolygon[ 0 ] = maActPos;
+ maActPos = rPolygon[ rPolygon.GetSize() - 1 ];
+ }
+ if ( bRecordPath )
+ maPathObj.AddPolyLine( rPolygon );
+ else
+ {
+ UpdateLineStyle();
+ mpGDIMetaFile->AddAction( new MetaPolyLineAction( rPolygon, maLineStyle.aLineInfo ) );
+ }
+ }
+
+ void MtfTools::DrawPolyBezier( tools::Polygon rPolygon, bool bTo, bool bRecordPath )
+ {
+ sal_uInt16 nPoints = rPolygon.GetSize();
+ if ( !(( nPoints >= 4 ) && ( ( ( nPoints - 4 ) % 3 ) == 0 )) )
+ return;
+
+ UpdateClipRegion();
+
+ ImplMap( rPolygon );
+ if ( bTo )
+ {
+ rPolygon[ 0 ] = maActPos;
+ maActPos = rPolygon[ nPoints - 1 ];
+ }
+ sal_uInt16 i;
+ for ( i = 0; ( i + 2 ) < nPoints; )
+ {
+ rPolygon.SetFlags( i++, PolyFlags::Normal );
+ rPolygon.SetFlags( i++, PolyFlags::Control );
+ rPolygon.SetFlags( i++, PolyFlags::Control );
+ }
+ if ( bRecordPath )
+ maPathObj.AddPolyLine( rPolygon );
+ else
+ {
+ UpdateLineStyle();
+ mpGDIMetaFile->AddAction( new MetaPolyLineAction( rPolygon, maLineStyle.aLineInfo ) );
+ }
+ }
+
+ void MtfTools::DrawText( Point& rPosition, OUString const & rText, long* pDXArry, long* pDYArry, bool bRecordPath, sal_Int32 nGfxMode )
+ {
+ UpdateClipRegion();
+ rPosition = ImplMap( rPosition );
+ sal_Int32 nOldGfxMode = GetGfxMode();
+ SetGfxMode( GM_COMPATIBLE );
+
+ if (pDXArry)
+ {
+ sal_Int32 nSumX = 0, nSumY = 0;
+ for (sal_Int32 i = 0; i < rText.getLength(); i++ )
+ {
+ nSumX += pDXArry[i];
+
+ // #i121382# Map DXArray using WorldTransform
+ const Size aSizeX(ImplMap(Size(nSumX, 0)));
+ const basegfx::B2DVector aVectorX(aSizeX.Width(), aSizeX.Height());
+ pDXArry[i] = basegfx::fround(aVectorX.getLength());
+ pDXArry[i] *= (nSumX >= 0 ? 1 : -1);
+
+ if (pDYArry)
+ {
+ nSumY += pDYArry[i];
+
+ const Size aSizeY(ImplMap(Size(0, nSumY)));
+ const basegfx::B2DVector aVectorY(aSizeY.Width(), aSizeY.Height());
+ // Reverse Y
+ pDYArry[i] = basegfx::fround(aVectorY.getLength());
+ pDYArry[i] *= (nSumY >= 0 ? -1 : 1);
+ }
+ }
+ }
+ if ( mnLatestTextLayoutMode != mnTextLayoutMode )
+ {
+ mnLatestTextLayoutMode = mnTextLayoutMode;
+ mpGDIMetaFile->AddAction( new MetaLayoutModeAction( mnTextLayoutMode ) );
+ }
+ SetGfxMode( nGfxMode );
+ TextAlign eTextAlign;
+ if ( ( mnTextAlign & TA_BASELINE) == TA_BASELINE )
+ eTextAlign = ALIGN_BASELINE;
+ else if( ( mnTextAlign & TA_BOTTOM) == TA_BOTTOM )
+ eTextAlign = ALIGN_BOTTOM;
+ else
+ eTextAlign = ALIGN_TOP;
+ bool bChangeFont = false;
+ if ( mnLatestTextAlign != mnTextAlign )
+ {
+ bChangeFont = true;
+ mnLatestTextAlign = mnTextAlign;
+ mpGDIMetaFile->AddAction( new MetaTextAlignAction( eTextAlign ) );
+ }
+ if ( maLatestTextColor != maTextColor )
+ {
+ bChangeFont = true;
+ maLatestTextColor = maTextColor;
+ mpGDIMetaFile->AddAction( new MetaTextColorAction( maTextColor ) );
+ }
+ bool bChangeFillColor = false;
+ if ( maLatestBkColor != maBkColor )
+ {
+ bChangeFillColor = true;
+ maLatestBkColor = maBkColor;
+ }
+ if ( mnLatestBkMode != mnBkMode )
+ {
+ bChangeFillColor = true;
+ mnLatestBkMode = mnBkMode;
+ }
+ if ( bChangeFillColor )
+ {
+ bChangeFont = true;
+ mpGDIMetaFile->AddAction( new MetaTextFillColorAction( maFont.GetFillColor(), !maFont.IsTransparent() ) );
+ }
+ vcl::Font aTmp( maFont );
+ aTmp.SetColor( maTextColor );
+ aTmp.SetFillColor( maBkColor );
+
+ if( mnBkMode == BkMode::Transparent )
+ aTmp.SetTransparent( true );
+ else
+ aTmp.SetTransparent( false );
+
+ aTmp.SetAlignment( eTextAlign );
+
+ if ( nGfxMode == GM_ADVANCED )
+ {
+ // check whether there is a font rotation applied via transformation
+ Point aP1( ImplMap( Point() ) );
+ Point aP2( ImplMap( Point( 0, 100 ) ) );
+ aP2.AdjustX( -(aP1.X()) );
+ aP2.AdjustY( -(aP1.Y()) );
+ double fX = aP2.X();
+ double fY = aP2.Y();
+ if ( fX )
+ {
+ double fOrientation = acos( fX / sqrt( fX * fX + fY * fY ) ) * 57.29577951308;
+ if ( fY > 0 )
+ fOrientation = 360 - fOrientation;
+ fOrientation += 90;
+ fOrientation *= 10;
+ fOrientation += aTmp.GetOrientation();
+ aTmp.SetOrientation( sal_Int16( fOrientation ) );
+ }
+ }
+
+ if( mnTextAlign & ( TA_UPDATECP | TA_RIGHT_CENTER ) )
+ {
+ // #i117968# VirtualDevice is not thread safe, but filter is used in multithreading
+ SolarMutexGuard aGuard;
+ ScopedVclPtrInstance< VirtualDevice > pVDev;
+ sal_Int32 nTextWidth;
+ Point aActPosDelta;
+ pVDev->SetMapMode( MapMode( MapUnit::Map100thMM ) );
+ pVDev->SetFont( maFont );
+ const sal_uInt32 nLen = pDXArry ? rText.getLength() : 0;
+ if (nLen)
+ {
+ nTextWidth = pVDev->GetTextWidth( OUString(rText[ nLen - 1 ]) );
+ if( nLen > 1 )
+ nTextWidth += pDXArry[ nLen - 2 ];
+ // tdf#39894: We should consider the distance to next character cell origin
+ aActPosDelta.setX( pDXArry[ nLen - 1 ] );
+ if ( pDYArry )
+ {
+ aActPosDelta.setY( pDYArry[ nLen - 1 ] );
+ }
+ }
+ else
+ {
+ nTextWidth = pVDev->GetTextWidth( rText );
+ aActPosDelta.setX( nTextWidth );
+ }
+
+ if( mnTextAlign & TA_UPDATECP )
+ rPosition = maActPos;
+
+ if ( mnTextAlign & TA_RIGHT_CENTER )
+ {
+ Point aDisplacement( ( ( mnTextAlign & TA_RIGHT_CENTER ) == TA_RIGHT ) ? nTextWidth : nTextWidth >> 1, 0 );
+ Point().RotateAround(aDisplacement, maFont.GetOrientation());
+ rPosition -= aDisplacement;
+ }
+
+ if( mnTextAlign & TA_UPDATECP )
+ {
+ Point().RotateAround(aActPosDelta, maFont.GetOrientation());
+ maActPos = rPosition + aActPosDelta;
+ }
+ }
+ if ( bChangeFont || ( maLatestFont != aTmp ) )
+ {
+ maLatestFont = aTmp;
+ mpGDIMetaFile->AddAction( new MetaFontAction( aTmp ) );
+ mpGDIMetaFile->AddAction( new MetaTextAlignAction( aTmp.GetAlignment() ) );
+ mpGDIMetaFile->AddAction( new MetaTextColorAction( aTmp.GetColor() ) );
+ mpGDIMetaFile->AddAction( new MetaTextFillColorAction( aTmp.GetFillColor(), !aTmp.IsTransparent() ) );
+ }
+ if ( bRecordPath )
+ {
+ // TODO
+ }
+ else
+ {
+ if ( pDXArry && pDYArry )
+ {
+ for (sal_Int32 i = 0; i < rText.getLength(); ++i)
+ {
+ Point aCharDisplacement( i ? pDXArry[i-1] : 0, i ? pDYArry[i-1] : 0 );
+ Point().RotateAround(aCharDisplacement, maFont.GetOrientation());
+ mpGDIMetaFile->AddAction( new MetaTextArrayAction( rPosition + aCharDisplacement, OUString( rText[i] ), nullptr, 0, 1 ) );
+ }
+ }
+ else
+ {
+ /* because text without dx array is badly scaled, we
+ will create such an array if necessary */
+ long* pDX = pDXArry;
+ if (!pDXArry)
+ {
+ // #i117968# VirtualDevice is not thread safe, but filter is used in multithreading
+ SolarMutexGuard aGuard;
+ ScopedVclPtrInstance< VirtualDevice > pVDev;
+ pDX = new long[ rText.getLength() ];
+ pVDev->SetMapMode(MapMode(MapUnit::Map100thMM));
+ pVDev->SetFont( maLatestFont );
+ pVDev->GetTextArray( rText, pDX, 0, rText.getLength());
+ }
+ mpGDIMetaFile->AddAction( new MetaTextArrayAction( rPosition, rText, pDX, 0, rText.getLength() ) );
+ if ( !pDXArry ) // this means we have created our own array
+ delete[] pDX; // which must be deleted
+ }
+ }
+ SetGfxMode( nOldGfxMode );
+ }
+
+ void MtfTools::ImplDrawBitmap( const Point& rPos, const Size& rSize, const BitmapEx& rBitmap )
+ {
+ BitmapEx aBmpEx( rBitmap );
+ if ( mbComplexClip )
+ {
+ vcl::bitmap::DrawAndClipBitmap(rPos, rSize, rBitmap, aBmpEx, maClipPath.getClipPath());
+ }
+
+ if ( aBmpEx.IsTransparent() )
+ mpGDIMetaFile->AddAction( new MetaBmpExScaleAction( rPos, rSize, aBmpEx ) );
+ else
+ mpGDIMetaFile->AddAction( new MetaBmpScaleAction( rPos, rSize, aBmpEx.GetBitmap() ) );
+ }
+
+ void MtfTools::ResolveBitmapActions( std::vector<std::unique_ptr<BSaveStruct>>& rSaveList )
+ {
+ UpdateClipRegion();
+
+ size_t nObjects = rSaveList.size();
+ size_t nObjectsLeft = nObjects;
+
+ while ( nObjectsLeft )
+ {
+ size_t i;
+ size_t nObjectsOfSameSize = 0;
+ size_t nObjectStartIndex = nObjects - nObjectsLeft;
+
+ BSaveStruct* pSave = rSaveList[nObjectStartIndex].get();
+ tools::Rectangle aRect( pSave->aOutRect );
+
+ for ( i = nObjectStartIndex; i < nObjects; )
+ {
+ nObjectsOfSameSize++;
+ if ( ++i < nObjects )
+ {
+ pSave = rSaveList[i].get();
+ if ( pSave->aOutRect != aRect )
+ break;
+ }
+ }
+ Point aPos( ImplMap( aRect.TopLeft() ) );
+ Size aSize( ImplMap( aRect.GetSize() ) );
+
+ for ( i = nObjectStartIndex; i < ( nObjectStartIndex + nObjectsOfSameSize ); i++ )
+ {
+ pSave = rSaveList[i].get();
+
+ sal_uInt32 nWinRop = pSave->nWinRop;
+ sal_uInt8 nRasterOperation = static_cast<sal_uInt8>( nWinRop >> 16 );
+
+ sal_uInt32 nUsed = 0;
+ if ( ( nRasterOperation & 0xf ) != ( nRasterOperation >> 4 ) )
+ nUsed |= 1; // pattern is used
+ if ( ( nRasterOperation & 0x33 ) != ( ( nRasterOperation & 0xcc ) >> 2 ) )
+ nUsed |= 2; // source is used
+ if ( ( nRasterOperation & 0xaa ) != ( ( nRasterOperation & 0x55 ) << 1 ) )
+ nUsed |= 4; // destination is used
+
+ if ( (nUsed & 1) && (( nUsed & 2 ) == 0) && nWinRop != PATINVERT )
+ { // patterns aren't well supported yet
+ WMFRasterOp nOldRop = SetRasterOp( WMFRasterOp::NONE ); // in this case nRasterOperation is either 0 or 0xff
+ UpdateFillStyle();
+ DrawRect( aRect, false );
+ SetRasterOp( nOldRop );
+ }
+ else
+ {
+ bool bDrawn = false;
+
+ if ( i == nObjectStartIndex ) // optimizing, sometimes it is possible to create just one transparent bitmap
+ {
+ if ( nObjectsOfSameSize == 2 )
+ {
+ BSaveStruct* pSave2 = rSaveList[i + 1].get();
+ if ( ( pSave->aBmpEx.GetPrefSize() == pSave2->aBmpEx.GetPrefSize() ) &&
+ ( pSave->aBmpEx.GetPrefMapMode() == pSave2->aBmpEx.GetPrefMapMode() ) )
+ {
+ // TODO: Strictly speaking, we should
+ // check whether mask is monochrome, and
+ // whether image is black (upper branch)
+ // or white (lower branch). Otherwise, the
+ // effect is not the same as a masked
+ // bitmap.
+ if ( ( nWinRop == SRCPAINT ) && ( pSave2->nWinRop == SRCAND ) )
+ {
+ Bitmap aMask( pSave->aBmpEx.GetBitmap() ); aMask.Invert();
+ BitmapEx aBmpEx( pSave2->aBmpEx.GetBitmap(), aMask );
+ ImplDrawBitmap( aPos, aSize, aBmpEx );
+ bDrawn = true;
+ i++;
+ }
+ // #i20085# This is just the other way
+ // around as above. Only difference: mask
+ // is inverted
+ else if ( ( nWinRop == SRCAND ) && ( pSave2->nWinRop == SRCPAINT ) )
+ {
+ const Bitmap & rMask( pSave->aBmpEx.GetBitmap() );
+ BitmapEx aBmpEx( pSave2->aBmpEx.GetBitmap(), rMask );
+ ImplDrawBitmap( aPos, aSize, aBmpEx );
+ bDrawn = true;
+ i++;
+ }
+ // tdf#90539
+ else if ( ( nWinRop == SRCAND ) && ( pSave2->nWinRop == SRCINVERT ) )
+ {
+ const Bitmap & rMask( pSave->aBmpEx.GetBitmap() );
+ BitmapEx aBmpEx( pSave2->aBmpEx.GetBitmap(), rMask );
+ ImplDrawBitmap( aPos, aSize, aBmpEx );
+ bDrawn = true;
+ i++;
+ }
+ }
+ }
+ }
+
+ if ( !bDrawn )
+ {
+ Push();
+ WMFRasterOp nOldRop = SetRasterOp( WMFRasterOp::CopyPen );
+ Bitmap aBitmap( pSave->aBmpEx.GetBitmap() );
+ sal_uInt32 nOperation = ( nRasterOperation & 0xf );
+ switch( nOperation )
+ {
+ case 0x1 :
+ case 0xe :
+ {
+ if(pSave->aBmpEx.IsAlpha())
+ {
+ ImplDrawBitmap( aPos, aSize, pSave->aBmpEx );
+ }
+ else
+ {
+ SetRasterOp( WMFRasterOp::XorPen );
+ ImplDrawBitmap( aPos, aSize, BitmapEx(aBitmap) );
+ SetRasterOp( WMFRasterOp::CopyPen );
+ Bitmap aMask( aBitmap );
+ aMask.Invert();
+ BitmapEx aBmpEx( aBitmap, aMask );
+ ImplDrawBitmap( aPos, aSize, aBmpEx );
+ if ( nOperation == 0x1 )
+ {
+ SetRasterOp( WMFRasterOp::Not );
+ DrawRect( aRect, false );
+ }
+ }
+ }
+ break;
+ case 0x7 :
+ case 0x8 :
+ {
+ Bitmap aMask( aBitmap );
+ if ( ( nUsed & 1 ) && ( nRasterOperation & 0xb0 ) == 0xb0 ) // pattern used
+ {
+ aBitmap.Convert( BmpConversion::N24Bit );
+ aBitmap.Erase( maFillStyle.aFillColor );
+ }
+ BitmapEx aBmpEx( aBitmap, aMask );
+ ImplDrawBitmap( aPos, aSize, aBmpEx );
+ if ( nOperation == 0x7 )
+ {
+ SetRasterOp( WMFRasterOp::Not );
+ DrawRect( aRect, false );
+ }
+ }
+ break;
+
+ case 0x4 :
+ case 0xb :
+ {
+ SetRasterOp( WMFRasterOp::Not );
+ DrawRect( aRect, false );
+ SetRasterOp( WMFRasterOp::CopyPen );
+ Bitmap aMask( aBitmap );
+ aBitmap.Invert();
+ BitmapEx aBmpEx( aBitmap, aMask );
+ ImplDrawBitmap( aPos, aSize, aBmpEx );
+ SetRasterOp( WMFRasterOp::XorPen );
+ ImplDrawBitmap( aPos, aSize, BitmapEx(aBitmap) );
+ if ( nOperation == 0xb )
+ {
+ SetRasterOp( WMFRasterOp::Not );
+ DrawRect( aRect, false );
+ }
+ }
+ break;
+
+ case 0x2 :
+ case 0xd :
+ {
+ Bitmap aMask( aBitmap );
+ aMask.Invert();
+ BitmapEx aBmpEx( aBitmap, aMask );
+ ImplDrawBitmap( aPos, aSize, aBmpEx );
+ SetRasterOp( WMFRasterOp::XorPen );
+ ImplDrawBitmap( aPos, aSize, BitmapEx(aBitmap) );
+ if ( nOperation == 0xd )
+ {
+ SetRasterOp( WMFRasterOp::Not );
+ DrawRect( aRect, false );
+ }
+ }
+ break;
+ case 0x6 :
+ case 0x9 :
+ {
+ SetRasterOp( WMFRasterOp::XorPen );
+ ImplDrawBitmap( aPos, aSize, BitmapEx(aBitmap) );
+ if ( nOperation == 0x9 )
+ {
+ SetRasterOp( WMFRasterOp::Not );
+ DrawRect( aRect, false );
+ }
+ }
+ break;
+
+ case 0x0 : // WHITENESS
+ case 0xf : // BLACKNESS
+ { // in this case nRasterOperation is either 0 or 0xff
+ maFillStyle = WinMtfFillStyle( Color( nRasterOperation, nRasterOperation, nRasterOperation ) );
+ UpdateFillStyle();
+ DrawRect( aRect, false );
+ }
+ break;
+
+ case 0x3 : // only source is used
+ case 0xc :
+ {
+ if ( nRasterOperation == 0x33 )
+ aBitmap.Invert();
+ ImplDrawBitmap( aPos, aSize, BitmapEx(aBitmap) );
+ }
+ break;
+
+ case 0x5 : // only destination is used
+ {
+ SetRasterOp( WMFRasterOp::Not );
+ DrawRect( aRect, false );
+ }
+ break;
+
+ case 0xa : // no operation
+ break;
+ }
+ SetRasterOp( nOldRop );
+ Pop();
+ }
+ }
+ }
+ nObjectsLeft -= nObjectsOfSameSize;
+ }
+
+ rSaveList.clear();
+ }
+
+ void MtfTools::SetDevOrg( const Point& rPoint )
+ {
+ mnDevOrgX = rPoint.X();
+ mnDevOrgY = rPoint.Y();
+ }
+
+ void MtfTools::SetDevOrgOffset( sal_Int32 nXAdd, sal_Int32 nYAdd )
+ {
+ mnDevOrgX += nXAdd;
+ mnDevOrgY += nYAdd;
+ }
+
+ void MtfTools::SetDevExt( const Size& rSize ,bool regular)
+ {
+ if ( !(rSize.Width() && rSize.Height()) )
+ return;
+
+ switch( mnMapMode )
+ {
+ case MM_ISOTROPIC :
+ case MM_ANISOTROPIC :
+ {
+ mnDevWidth = rSize.Width();
+ mnDevHeight = rSize.Height();
+ }
+ }
+ if (regular)
+ {
+ mbIsMapDevSet=true;
+ }
+ }
+
+ void MtfTools::ScaleDevExt(double fX, double fY)
+ {
+ mnDevWidth = basegfx::fround(mnDevWidth * fX);
+ mnDevHeight = basegfx::fround(mnDevHeight * fY);
+ }
+
+ void MtfTools::SetWinOrg( const Point& rPoint , bool bIsEMF)
+ {
+ mnWinOrgX = rPoint.X();
+ mnWinOrgY = rPoint.Y();
+ if (bIsEMF)
+ {
+ SetDevByWin();
+ }
+ mbIsMapWinSet=true;
+ }
+
+ void MtfTools::SetWinOrgOffset( sal_Int32 nXAdd, sal_Int32 nYAdd )
+ {
+ mnWinOrgX += nXAdd;
+ mnWinOrgY += nYAdd;
+ }
+
+ void MtfTools::SetDevByWin() //mnWinExt...-stuff has to be assigned before.
+ {
+ if (!mbIsMapDevSet)
+ {
+ if ( mnMapMode == MM_ISOTROPIC ) //TODO: WHAT ABOUT ANISOTROPIC???
+ {
+ sal_Int32 nX, nY;
+ if (o3tl::checked_add(mnWinExtX, mnWinOrgX, nX) || o3tl::checked_sub(mnWinExtY, mnWinOrgY, nY))
+ return;
+ Size aSize(nX >> MS_FIXPOINT_BITCOUNT_28_4, -(nY >> MS_FIXPOINT_BITCOUNT_28_4));
+ SetDevExt(aSize, false);
+ }
+ }
+ }
+
+ void MtfTools::SetWinExt(const Size& rSize, bool bIsEMF)
+ {
+ if (!(rSize.Width() && rSize.Height()))
+ return;
+
+ switch( mnMapMode )
+ {
+ case MM_ISOTROPIC :
+ case MM_ANISOTROPIC :
+ {
+ mnWinExtX = rSize.Width();
+ mnWinExtY = rSize.Height();
+ if (bIsEMF)
+ {
+ SetDevByWin();
+ }
+ mbIsMapWinSet = true;
+ }
+ }
+ }
+
+ void MtfTools::ScaleWinExt(double fX, double fY)
+ {
+ mnWinExtX = basegfx::fround(mnWinExtX * fX);
+ mnWinExtY = basegfx::fround(mnWinExtY * fY);
+ }
+
+ void MtfTools::SetrclBounds( const tools::Rectangle& rRect )
+ {
+ mrclBounds = rRect;
+ }
+
+ void MtfTools::SetrclFrame( const tools::Rectangle& rRect )
+ {
+ mrclFrame = rRect;
+ }
+
+ void MtfTools::SetRefPix( const Size& rSize )
+ {
+ mnPixX = rSize.Width();
+ mnPixY = rSize.Height();
+ }
+
+ void MtfTools::SetRefMill( const Size& rSize )
+ {
+ mnMillX = rSize.Width();
+ mnMillY = rSize.Height();
+ }
+
+ void MtfTools::SetMapMode( sal_uInt32 nMapMode )
+ {
+ mnMapMode = nMapMode;
+ if ( nMapMode == MM_TEXT && !mbIsMapWinSet )
+ {
+ mnWinExtX = mnDevWidth;
+ mnWinExtY = mnDevHeight;
+ }
+ else if ( mnMapMode == MM_HIMETRIC )
+ {
+ sal_Int32 nWinExtX, nWinExtY;
+ if (o3tl::checked_multiply<sal_Int32>(mnMillX, 100, nWinExtX) ||
+ o3tl::checked_multiply<sal_Int32>(mnMillY, 100, nWinExtY))
+ {
+ return;
+ }
+ mnWinExtX = nWinExtX;
+ mnWinExtY = nWinExtY;
+ }
+ }
+
+ void MtfTools::SetWorldTransform( const XForm& rXForm )
+ {
+ maXForm.eM11 = rXForm.eM11;
+ maXForm.eM12 = rXForm.eM12;
+ maXForm.eM21 = rXForm.eM21;
+ maXForm.eM22 = rXForm.eM22;
+ maXForm.eDx = rXForm.eDx;
+ maXForm.eDy = rXForm.eDy;
+ }
+
+ void MtfTools::ModifyWorldTransform( const XForm& rXForm, sal_uInt32 nMode )
+ {
+ switch( nMode )
+ {
+ case MWT_IDENTITY :
+ {
+ maXForm.eM11 = maXForm.eM22 = 1.0f;
+ maXForm.eM12 = maXForm.eM21 = maXForm.eDx = maXForm.eDy = 0.0f;
+ break;
+ }
+
+ case MWT_RIGHTMULTIPLY :
+ case MWT_LEFTMULTIPLY :
+ {
+ const XForm* pLeft;
+ const XForm* pRight;
+
+ if ( nMode == MWT_LEFTMULTIPLY )
+ {
+ pLeft = &rXForm;
+ pRight = &maXForm;
+ }
+ else
+ {
+ pLeft = &maXForm;
+ pRight = &rXForm;
+ }
+
+ float aF[3][3];
+ float bF[3][3];
+ float cF[3][3];
+
+ aF[0][0] = pLeft->eM11;
+ aF[0][1] = pLeft->eM12;
+ aF[0][2] = 0;
+ aF[1][0] = pLeft->eM21;
+ aF[1][1] = pLeft->eM22;
+ aF[1][2] = 0;
+ aF[2][0] = pLeft->eDx;
+ aF[2][1] = pLeft->eDy;
+ aF[2][2] = 1;
+
+ bF[0][0] = pRight->eM11;
+ bF[0][1] = pRight->eM12;
+ bF[0][2] = 0;
+ bF[1][0] = pRight->eM21;
+ bF[1][1] = pRight->eM22;
+ bF[1][2] = 0;
+ bF[2][0] = pRight->eDx;
+ bF[2][1] = pRight->eDy;
+ bF[2][2] = 1;
+
+ int i, j, k;
+ for ( i = 0; i < 3; i++ )
+ {
+ for ( j = 0; j < 3; j++ )
+ {
+ cF[i][j] = 0;
+ for ( k = 0; k < 3; k++ )
+ cF[i][j] += aF[i][k] * bF[k][j];
+ }
+ }
+ maXForm.eM11 = cF[0][0];
+ maXForm.eM12 = cF[0][1];
+ maXForm.eM21 = cF[1][0];
+ maXForm.eM22 = cF[1][1];
+ maXForm.eDx = cF[2][0];
+ maXForm.eDy = cF[2][1];
+ break;
+ }
+ case MWT_SET:
+ {
+ SetWorldTransform(rXForm);
+ break;
+ }
+ }
+ }
+
+ void MtfTools::Push() // !! to be able to access the original ClipRegion it
+ { // is not allowed to use the MetaPushAction()
+ UpdateClipRegion(); // (the original clip region is on top of the stack) (SJ)
+ auto pSave = std::make_shared<SaveStruct>();
+
+ pSave->aLineStyle = maLineStyle;
+ pSave->aFillStyle = maFillStyle;
+
+ pSave->aFont = maFont;
+ pSave->aTextColor = maTextColor;
+ pSave->nTextAlign = mnTextAlign;
+ pSave->nTextLayoutMode = mnTextLayoutMode;
+ pSave->nMapMode = mnMapMode;
+ pSave->nGfxMode = mnGfxMode;
+ pSave->nBkMode = mnBkMode;
+ pSave->aBkColor = maBkColor;
+ pSave->bFillStyleSelected = mbFillStyleSelected;
+
+ pSave->aActPos = maActPos;
+ pSave->aXForm = maXForm;
+ pSave->eRasterOp = meRasterOp;
+
+ pSave->nWinOrgX = mnWinOrgX;
+ pSave->nWinOrgY = mnWinOrgY;
+ pSave->nWinExtX = mnWinExtX;
+ pSave->nWinExtY = mnWinExtY;
+ pSave->nDevOrgX = mnDevOrgX;
+ pSave->nDevOrgY = mnDevOrgY;
+ pSave->nDevWidth = mnDevWidth;
+ pSave->nDevHeight = mnDevHeight;
+
+ pSave->maPathObj = maPathObj;
+ pSave->maClipPath = maClipPath;
+
+ SAL_INFO("emfio", "\t\t GfxMode: " << mnGfxMode);
+ SAL_INFO("emfio", "\t\t MapMode: " << mnMapMode);
+ SAL_INFO("emfio", "\t\t WinOrg: " << mnWinOrgX << ", " << mnWinOrgY);
+ SAL_INFO("emfio", "\t\t WinExt: " << mnWinExtX << " x " << mnWinExtY);
+ SAL_INFO("emfio", "\t\t DevOrg: " << mnDevOrgX << ", " << mnDevOrgY);
+ SAL_INFO("emfio", "\t\t DevWidth/Height: " << mnDevWidth << " x " << mnDevHeight);
+ mvSaveStack.push_back( pSave );
+ }
+
+ void MtfTools::Pop()
+ {
+ // Get the latest data from the stack
+ if( mvSaveStack.empty() )
+ return;
+
+ // Backup the current data on the stack
+ std::shared_ptr<SaveStruct>& pSave( mvSaveStack.back() );
+
+ maLineStyle = pSave->aLineStyle;
+ maFillStyle = pSave->aFillStyle;
+
+ maFont = pSave->aFont;
+ maTextColor = pSave->aTextColor;
+ mnTextAlign = pSave->nTextAlign;
+ mnTextLayoutMode = pSave->nTextLayoutMode;
+ mnBkMode = pSave->nBkMode;
+ mnGfxMode = pSave->nGfxMode;
+ mnMapMode = pSave->nMapMode;
+ maBkColor = pSave->aBkColor;
+ mbFillStyleSelected = pSave->bFillStyleSelected;
+
+ maActPos = pSave->aActPos;
+ maXForm = pSave->aXForm;
+ meRasterOp = pSave->eRasterOp;
+
+ mnWinOrgX = pSave->nWinOrgX;
+ mnWinOrgY = pSave->nWinOrgY;
+ mnWinExtX = pSave->nWinExtX;
+ mnWinExtY = pSave->nWinExtY;
+ mnDevOrgX = pSave->nDevOrgX;
+ mnDevOrgY = pSave->nDevOrgY;
+ mnDevWidth = pSave->nDevWidth;
+ mnDevHeight = pSave->nDevHeight;
+
+ maPathObj = pSave->maPathObj;
+ if ( ! ( maClipPath == pSave->maClipPath ) )
+ {
+ maClipPath = pSave->maClipPath;
+ mbClipNeedsUpdate = true;
+ }
+ if ( meLatestRasterOp != meRasterOp )
+ {
+ mpGDIMetaFile->AddAction( new MetaRasterOpAction( meRasterOp ) );
+ meLatestRasterOp = meRasterOp;
+ }
+
+ SAL_INFO("emfio", "\t\t GfxMode: " << mnGfxMode);
+ SAL_INFO("emfio", "\t\t MapMode: " << mnMapMode);
+ SAL_INFO("emfio", "\t\t WinOrg: " << mnWinOrgX << ", " << mnWinOrgY);
+ SAL_INFO("emfio", "\t\t WinExt: " << mnWinExtX << " x " << mnWinExtY);
+ SAL_INFO("emfio", "\t\t DevOrg: " << mnDevOrgX << ", " << mnDevOrgY);
+ SAL_INFO("emfio", "\t\t DevWidth/Height: " << mnDevWidth << " x " << mnDevHeight);
+ mvSaveStack.pop_back();
+ }
+
+ void MtfTools::AddFromGDIMetaFile( GDIMetaFile& rGDIMetaFile )
+ {
+ rGDIMetaFile.Play( *mpGDIMetaFile );
+ }
+
+ void MtfTools::PassEMFPlusHeaderInfo()
+ {
+ EMFP_DEBUG(printf ("\t\t\tadd EMF_PLUS header info\n"));
+
+ SvMemoryStream mem;
+ sal_Int32 nLeft, nRight, nTop, nBottom;
+
+ nLeft = mrclFrame.Left();
+ nTop = mrclFrame.Top();
+ nRight = mrclFrame.Right();
+ nBottom = mrclFrame.Bottom();
+
+ // emf header info
+ mem.WriteInt32( nLeft ).WriteInt32( nTop ).WriteInt32( nRight ).WriteInt32( nBottom );
+ mem.WriteInt32( mnPixX ).WriteInt32( mnPixY ).WriteInt32( mnMillX ).WriteInt32( mnMillY );
+
+ float one, zero;
+
+ one = 1;
+ zero = 0;
+
+ // add transformation matrix to be used in vcl's metaact.cxx for
+ // rotate and scale operations
+ mem.WriteFloat( one ).WriteFloat( zero ).WriteFloat( zero ).WriteFloat( one ).WriteFloat( zero ).WriteFloat( zero );
+
+ // need to flush the stream, otherwise GetEndOfData will return 0
+ // on windows where the function parameters are probably resolved in reverse order
+ mem.Flush();
+
+ mpGDIMetaFile->AddAction( new MetaCommentAction( "EMF_PLUS_HEADER_INFO", 0, static_cast<const sal_uInt8*>(mem.GetData()), mem.GetEndOfData() ) );
+ mpGDIMetaFile->UseCanvas( true );
+ }
+
+ void MtfTools::PassEMFPlus( void const * pBuffer, sal_uInt32 nLength )
+ {
+ EMFP_DEBUG(printf ("\t\t\tadd EMF_PLUS comment length %04x\n",(unsigned int) nLength));
+ mpGDIMetaFile->AddAction( new MetaCommentAction( "EMF_PLUS", 0, static_cast<const sal_uInt8*>(pBuffer), nLength ) );
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/emfio/source/reader/wmfreader.cxx b/emfio/source/reader/wmfreader.cxx
new file mode 100644
index 000000000..aa1c2be7a
--- /dev/null
+++ b/emfio/source/reader/wmfreader.cxx
@@ -0,0 +1,1871 @@
+/* -*- 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 .
+ */
+
+#include <wmfreader.hxx>
+#include <emfreader.hxx>
+
+#include <memory>
+#include <optional>
+#include <o3tl/safeint.hxx>
+#include <rtl/crc.h>
+#include <rtl/tencinfo.h>
+#include <sal/log.hxx>
+#include <osl/endian.h>
+#include <vcl/gdimtf.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/dibtools.hxx>
+#include <vcl/outdev.hxx>
+#include <vcl/wmfexternal.hxx>
+#include <tools/fract.hxx>
+#include <vcl/bitmapaccess.hxx>
+#include <vcl/BitmapTools.hxx>
+#include <osl/thread.h>
+
+// MS Windows defines
+#define W_META_SETBKCOLOR 0x0201
+#define W_META_SETBKMODE 0x0102
+#define W_META_SETMAPMODE 0x0103
+#define W_META_SETROP2 0x0104
+#define W_META_SETRELABS 0x0105
+#define W_META_SETPOLYFILLMODE 0x0106
+#define W_META_SETSTRETCHBLTMODE 0x0107
+#define W_META_SETTEXTCHAREXTRA 0x0108
+#define W_META_SETTEXTCOLOR 0x0209
+#define W_META_SETTEXTJUSTIFICATION 0x020A
+#define W_META_SETWINDOWORG 0x020B
+#define W_META_SETWINDOWEXT 0x020C
+#define W_META_SETVIEWPORTORG 0x020D
+#define W_META_SETVIEWPORTEXT 0x020E
+#define W_META_OFFSETWINDOWORG 0x020F
+#define W_META_SCALEWINDOWEXT 0x0410
+#define W_META_OFFSETVIEWPORTORG 0x0211
+#define W_META_SCALEVIEWPORTEXT 0x0412
+#define W_META_LINETO 0x0213
+#define W_META_MOVETO 0x0214
+#define W_META_EXCLUDECLIPRECT 0x0415
+#define W_META_INTERSECTCLIPRECT 0x0416
+#define W_META_ARC 0x0817
+#define W_META_ELLIPSE 0x0418
+#define W_META_FLOODFILL 0x0419
+#define W_META_PIE 0x081A
+#define W_META_RECTANGLE 0x041B
+#define W_META_ROUNDRECT 0x061C
+#define W_META_PATBLT 0x061D
+#define W_META_SAVEDC 0x001E
+#define W_META_SETPIXEL 0x041F
+#define W_META_OFFSETCLIPRGN 0x0220
+#define W_META_TEXTOUT 0x0521
+#define W_META_BITBLT 0x0922
+#define W_META_STRETCHBLT 0x0B23
+#define W_META_POLYGON 0x0324
+#define W_META_POLYLINE 0x0325
+#define W_META_ESCAPE 0x0626
+#define W_META_RESTOREDC 0x0127
+#define W_META_FILLREGION 0x0228
+#define W_META_FRAMEREGION 0x0429
+#define W_META_INVERTREGION 0x012A
+#define W_META_PAINTREGION 0x012B
+#define W_META_SELECTCLIPREGION 0x012C
+#define W_META_SELECTOBJECT 0x012D
+#define W_META_SETTEXTALIGN 0x012E
+#define W_META_DRAWTEXT 0x062F
+#define W_META_CHORD 0x0830
+#define W_META_SETMAPPERFLAGS 0x0231
+#define W_META_EXTTEXTOUT 0x0a32
+#define W_META_SETDIBTODEV 0x0d33
+#define W_META_SELECTPALETTE 0x0234
+#define W_META_REALIZEPALETTE 0x0035
+#define W_META_ANIMATEPALETTE 0x0436
+#define W_META_SETPALENTRIES 0x0037
+#define W_META_POLYPOLYGON 0x0538
+#define W_META_RESIZEPALETTE 0x0139
+#define W_META_DIBBITBLT 0x0940
+#define W_META_DIBSTRETCHBLT 0x0b41
+#define W_META_DIBCREATEPATTERNBRUSH 0x0142
+#define W_META_STRETCHDIB 0x0f43
+#define W_META_EXTFLOODFILL 0x0548
+#define W_META_RESETDC 0x014C
+#define W_META_STARTDOC 0x014D
+#define W_META_STARTPAGE 0x004F
+#define W_META_ENDPAGE 0x0050
+#define W_META_ABORTDOC 0x0052
+#define W_META_ENDDOC 0x005E
+#define W_META_DELETEOBJECT 0x01f0
+#define W_META_CREATEPALETTE 0x00f7
+#define W_META_CREATEBRUSH 0x00F8
+#define W_META_CREATEPATTERNBRUSH 0x01F9
+#define W_META_CREATEPENINDIRECT 0x02FA
+#define W_META_CREATEFONTINDIRECT 0x02FB
+#define W_META_CREATEBRUSHINDIRECT 0x02FC
+#define W_META_CREATEBITMAPINDIRECT 0x02FD
+#define W_META_CREATEBITMAP 0x06FE
+#define W_META_CREATEREGION 0x06FF
+
+namespace
+{
+ void GetWinExtMax(const Point& rSource, tools::Rectangle& rPlaceableBound, const sal_Int16 nMapMode)
+ {
+ Point aSource(rSource);
+ if (nMapMode == MM_HIMETRIC)
+ aSource.setY( -rSource.Y() );
+ if (aSource.X() < rPlaceableBound.Left())
+ rPlaceableBound.SetLeft( aSource.X() );
+ if (aSource.X() > rPlaceableBound.Right())
+ rPlaceableBound.SetRight( aSource.X() );
+ if (aSource.Y() < rPlaceableBound.Top())
+ rPlaceableBound.SetTop( aSource.Y() );
+ if (aSource.Y() > rPlaceableBound.Bottom())
+ rPlaceableBound.SetBottom( aSource.Y() );
+ }
+
+ void GetWinExtMax(const tools::Rectangle& rSource, tools::Rectangle& rPlaceableBound, const sal_Int16 nMapMode)
+ {
+ GetWinExtMax(rSource.TopLeft(), rPlaceableBound, nMapMode);
+ GetWinExtMax(rSource.BottomRight(), rPlaceableBound, nMapMode);
+ }
+
+}
+
+namespace emfio
+{
+ inline Point WmfReader::ReadPoint()
+ {
+ short nX = 0, nY = 0;
+ mpInputStream->ReadInt16( nX ).ReadInt16( nY );
+ return Point( nX, nY );
+ }
+
+ inline Point WmfReader::ReadYX()
+ {
+ short nX = 0, nY = 0;
+ mpInputStream->ReadInt16( nY ).ReadInt16( nX );
+ return Point( nX, nY );
+ }
+
+ tools::Rectangle WmfReader::ReadRectangle()
+ {
+ Point aBR, aTL;
+ aBR = ReadYX();
+ aTL = ReadYX();
+ aBR.AdjustX( -1 );
+ aBR.AdjustY( -1 );
+ if (aTL.X() > aBR.X() || aTL.Y() > aBR.Y())
+ {
+ SAL_WARN("vcl.wmf", "broken rectangle");
+ return tools::Rectangle::Justify(aTL, aBR);
+ }
+ return tools::Rectangle( aTL, aBR );
+ }
+
+ Size WmfReader::ReadYXExt()
+ {
+ short nW=0, nH=0;
+ mpInputStream->ReadInt16( nH ).ReadInt16( nW );
+ return Size( nW, nH );
+ }
+
+ void WmfReader::ReadRecordParams( sal_uInt16 nFunc )
+ {
+ switch( nFunc )
+ {
+ case W_META_SETBKCOLOR:
+ {
+ SetBkColor( ReadColor() );
+ }
+ break;
+
+ case W_META_SETBKMODE:
+ {
+ sal_uInt16 nDat = 0;
+ mpInputStream->ReadUInt16( nDat );
+ SetBkMode( static_cast<BkMode>(nDat) );
+ }
+ break;
+
+ // !!!
+ case W_META_SETMAPMODE:
+ {
+ sal_Int16 nMapMode = 0;
+ mpInputStream->ReadInt16( nMapMode );
+ SetMapMode( nMapMode );
+ }
+ break;
+
+ case W_META_SETROP2:
+ {
+ sal_uInt16 nROP2 = 0;
+ mpInputStream->ReadUInt16( nROP2 );
+ SetRasterOp( static_cast<WMFRasterOp>(nROP2) );
+ }
+ break;
+
+ case W_META_SETTEXTCOLOR:
+ {
+ SetTextColor( ReadColor() );
+ }
+ break;
+
+ case W_META_SETWINDOWORG:
+ {
+ SetWinOrg( ReadYX() );
+ }
+ break;
+
+ case W_META_SETWINDOWEXT:
+ {
+ short nWidth = 0, nHeight = 0;
+ mpInputStream->ReadInt16( nHeight ).ReadInt16( nWidth );
+ SetWinExt( Size( nWidth, nHeight ) );
+ }
+ break;
+
+ case W_META_OFFSETWINDOWORG:
+ {
+ short nXAdd = 0, nYAdd = 0;
+ mpInputStream->ReadInt16( nYAdd ).ReadInt16( nXAdd );
+ SetWinOrgOffset( nXAdd, nYAdd );
+ }
+ break;
+
+ case W_META_SCALEWINDOWEXT:
+ {
+ short nXNum = 0, nXDenom = 0, nYNum = 0, nYDenom = 0;
+ mpInputStream->ReadInt16( nYDenom ).ReadInt16( nYNum ).ReadInt16( nXDenom ).ReadInt16( nXNum );
+ if (!nYDenom || !nXDenom)
+ {
+ mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
+ break;
+ }
+ ScaleWinExt( static_cast<double>(nXNum) / nXDenom, static_cast<double>(nYNum) / nYDenom );
+ }
+ break;
+
+ case W_META_SETVIEWPORTORG:
+ case W_META_SETVIEWPORTEXT:
+ break;
+
+ case W_META_OFFSETVIEWPORTORG:
+ {
+ short nXAdd = 0, nYAdd = 0;
+ mpInputStream->ReadInt16( nYAdd ).ReadInt16( nXAdd );
+ SetDevOrgOffset( nXAdd, nYAdd );
+ }
+ break;
+
+ case W_META_SCALEVIEWPORTEXT:
+ {
+ short nXNum = 0, nXDenom = 0, nYNum = 0, nYDenom = 0;
+ mpInputStream->ReadInt16( nYDenom ).ReadInt16( nYNum ).ReadInt16( nXDenom ).ReadInt16( nXNum );
+ if (!nYDenom || !nXDenom)
+ {
+ mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
+ break;
+ }
+ ScaleDevExt( static_cast<double>(nXNum) / nXDenom, static_cast<double>(nYNum) / nYDenom );
+ }
+ break;
+
+ case W_META_LINETO:
+ {
+ LineTo( ReadYX() );
+ }
+ break;
+
+ case W_META_MOVETO:
+ {
+ MoveTo( ReadYX() );
+ }
+ break;
+
+ case W_META_INTERSECTCLIPRECT:
+ {
+ IntersectClipRect( ReadRectangle() );
+ }
+ break;
+
+ case W_META_RECTANGLE:
+ {
+ DrawRect( ReadRectangle() );
+ }
+ break;
+
+ case W_META_ROUNDRECT:
+ {
+ Size aSize( ReadYXExt() );
+ DrawRoundRect( ReadRectangle(), Size( aSize.Width() / 2, aSize.Height() / 2 ) );
+ }
+ break;
+
+ case W_META_ELLIPSE:
+ {
+ DrawEllipse( ReadRectangle() );
+ }
+ break;
+
+ case W_META_ARC:
+ {
+ Point aEnd( ReadYX() );
+ Point aStart( ReadYX() );
+ tools::Rectangle aRect( ReadRectangle() );
+ aRect.Justify();
+ DrawArc( aRect, aStart, aEnd );
+ }
+ break;
+
+ case W_META_PIE:
+ {
+ Point aEnd( ReadYX() );
+ Point aStart( ReadYX() );
+ tools::Rectangle aRect( ReadRectangle() );
+ aRect.Justify();
+
+ // #i73608# OutputDevice deviates from WMF
+ // semantics. start==end means full ellipse here.
+ if( aStart == aEnd )
+ DrawEllipse( aRect );
+ else
+ DrawPie( aRect, aStart, aEnd );
+ }
+ break;
+
+ case W_META_CHORD:
+ {
+ Point aEnd( ReadYX() );
+ Point aStart( ReadYX() );
+ tools::Rectangle aRect( ReadRectangle() );
+ aRect.Justify();
+ DrawChord( aRect, aStart, aEnd );
+ }
+ break;
+
+ case W_META_POLYGON:
+ {
+ bool bRecordOk = true;
+
+ sal_uInt16 nPoints(0);
+ mpInputStream->ReadUInt16(nPoints);
+
+ if (nPoints > mpInputStream->remainingSize() / (2 * sizeof(sal_uInt16)))
+ {
+ bRecordOk = false;
+ }
+ else
+ {
+ tools::Polygon aPoly(nPoints);
+ for (sal_uInt16 i(0); i < nPoints && mpInputStream->good(); ++i)
+ aPoly[ i ] = ReadPoint();
+ DrawPolygon(aPoly, false/*bRecordPath*/);
+ }
+
+ SAL_WARN_IF(!bRecordOk, "vcl.wmf", "polygon record has more points than we can handle");
+
+ bRecordOk &= mpInputStream->good();
+
+ if (!bRecordOk)
+ {
+ mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
+ break;
+ }
+ }
+ break;
+
+ case W_META_POLYPOLYGON:
+ {
+ sal_uInt16 nPolyCount(0);
+ // Number of polygons:
+ mpInputStream->ReadUInt16( nPolyCount );
+ if (nPolyCount && mpInputStream->good())
+ {
+ bool bRecordOk = true;
+ if (nPolyCount > mpInputStream->remainingSize() / sizeof(sal_uInt16))
+ {
+ break;
+ }
+
+ // Number of points of each polygon. Determine total number of points
+ std::unique_ptr<sal_uInt16[]> xPolygonPointCounts(new sal_uInt16[nPolyCount]);
+ sal_uInt16* pnPoints = xPolygonPointCounts.get();
+ tools::PolyPolygon aPolyPoly(nPolyCount);
+ sal_uInt16 nPoints = 0;
+ for (sal_uInt16 a = 0; a < nPolyCount && mpInputStream->good(); ++a)
+ {
+ mpInputStream->ReadUInt16( pnPoints[a] );
+
+ if (pnPoints[a] > SAL_MAX_UINT16 - nPoints)
+ {
+ bRecordOk = false;
+ break;
+ }
+
+ nPoints += pnPoints[a];
+ }
+
+ SAL_WARN_IF(!bRecordOk, "vcl.wmf", "polypolygon record has more polygons than we can handle");
+
+ bRecordOk &= mpInputStream->good();
+
+ if (!bRecordOk)
+ {
+ mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
+ break;
+ }
+
+ // Polygon points are:
+ for (sal_uInt16 a = 0; a < nPolyCount && mpInputStream->good(); ++a)
+ {
+ const sal_uInt16 nPointCount(pnPoints[a]);
+
+ if (nPointCount > mpInputStream->remainingSize() / (2 * sizeof(sal_uInt16)))
+ {
+ bRecordOk = false;
+ break;
+ }
+
+ std::unique_ptr<Point[]> xPolygonPoints(new Point[nPointCount]);
+ Point* pPtAry = xPolygonPoints.get();
+
+ for(sal_uInt16 b(0); b < nPointCount && mpInputStream->good(); ++b)
+ {
+ pPtAry[b] = ReadPoint();
+ }
+
+ aPolyPoly.Insert( tools::Polygon(nPointCount, pPtAry) );
+ }
+
+ bRecordOk &= mpInputStream->good();
+
+ if (!bRecordOk)
+ {
+ mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
+ break;
+ }
+
+ DrawPolyPolygon( aPolyPoly );
+ }
+ }
+ break;
+
+ case W_META_POLYLINE:
+ {
+ bool bRecordOk = true;
+
+ sal_uInt16 nPoints(0);
+ mpInputStream->ReadUInt16(nPoints);
+
+ if (nPoints > mpInputStream->remainingSize() / (2 * sizeof(sal_uInt16)))
+ {
+ bRecordOk = false;
+ }
+ else
+ {
+ tools::Polygon aPoly(nPoints);
+ for (sal_uInt16 i(0); i < nPoints && mpInputStream->good(); ++i)
+ aPoly[ i ] = ReadPoint();
+ DrawPolyLine( aPoly );
+ }
+
+ SAL_WARN_IF(!bRecordOk, "vcl.wmf", "polyline record has more points than we can handle");
+
+ bRecordOk &= mpInputStream->good();
+
+ if (!bRecordOk)
+ {
+ mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
+ break;
+ }
+ }
+ break;
+
+ case W_META_SAVEDC:
+ {
+ Push();
+ }
+ break;
+
+ case W_META_RESTOREDC:
+ {
+ Pop();
+ }
+ break;
+
+ case W_META_SETPIXEL:
+ {
+ const Color aColor = ReadColor();
+ DrawPixel( ReadYX(), aColor );
+ }
+ break;
+
+ case W_META_OFFSETCLIPRGN:
+ {
+ MoveClipRegion( ReadYXExt() );
+ }
+ break;
+
+ case W_META_TEXTOUT:
+ {
+ //record is Recordsize, RecordFunction, StringLength, <String>, YStart, XStart
+ const sal_uInt32 nNonStringLen = sizeof(sal_uInt32) + 4 * sizeof(sal_uInt16);
+ const sal_uInt32 nRecSize = mnRecSize * 2;
+
+ if (nRecSize < nNonStringLen)
+ {
+ SAL_WARN("vcl.wmf", "W_META_TEXTOUT too short");
+ break;
+ }
+
+ sal_uInt16 nLength = 0;
+ mpInputStream->ReadUInt16(nLength);
+ sal_uInt16 nStoredLength = (nLength + 1) &~ 1;
+
+ if (nRecSize - nNonStringLen < nStoredLength)
+ {
+ SAL_WARN("vcl.wmf", "W_META_TEXTOUT too short, truncating string");
+ nLength = nStoredLength = nRecSize - nNonStringLen;
+ }
+
+ if (nLength)
+ {
+ std::vector<char> aChars(nStoredLength);
+ nLength = std::min<sal_uInt16>(nLength, mpInputStream->ReadBytes(aChars.data(), aChars.size()));
+ OUString aText(aChars.data(), nLength, GetCharSet());
+ Point aPosition( ReadYX() );
+ DrawText( aPosition, aText );
+ }
+ }
+ break;
+
+ case W_META_EXTTEXTOUT:
+ {
+ //record is Recordsize, RecordFunction, Y, X, StringLength, options, maybe rectangle, <String>
+ sal_uInt32 nNonStringLen = sizeof(sal_uInt32) + 5 * sizeof(sal_uInt16);
+ const sal_uInt32 nRecSize = mnRecSize * 2;
+
+ if (nRecSize < nNonStringLen)
+ {
+ SAL_WARN("vcl.wmf", "W_META_EXTTEXTOUT too short");
+ break;
+ }
+
+ auto nRecordPos = mpInputStream->Tell() - 6;
+ Point aPosition = ReadYX();
+ sal_uInt16 nLen = 0, nOptions = 0;
+ mpInputStream->ReadUInt16( nLen ).ReadUInt16( nOptions );
+
+ if (nOptions & ETO_CLIPPED)
+ {
+ nNonStringLen += 2 * sizeof(sal_uInt16);
+
+ if (nRecSize < nNonStringLen)
+ {
+ SAL_WARN("vcl.wmf", "W_META_TEXTOUT too short");
+ break;
+ }
+
+ ReadPoint();
+ ReadPoint();
+ SAL_WARN("vcl.wmf", "clipping unsupported");
+ }
+
+ ComplexTextLayoutFlags nTextLayoutMode = ComplexTextLayoutFlags::Default;
+ if ( nOptions & ETO_RTLREADING )
+ nTextLayoutMode = ComplexTextLayoutFlags::BiDiRtl | ComplexTextLayoutFlags::TextOriginLeft;
+ SetTextLayoutMode( nTextLayoutMode );
+ SAL_WARN_IF( ( nOptions & ( ETO_PDY | ETO_GLYPH_INDEX ) ) != 0, "vcl.wmf", "SJ: ETO_PDY || ETO_GLYPH_INDEX in WMF" );
+
+ // output only makes sense if the text contains characters
+ if (nLen)
+ {
+ sal_Int32 nOriginalTextLen = nLen;
+ sal_Int32 nOriginalBlockLen = ( nOriginalTextLen + 1 ) &~ 1;
+
+ auto nMaxStreamPos = nRecordPos + nRecSize;
+ auto nRemainingSize = std::min(mpInputStream->remainingSize(), nMaxStreamPos - mpInputStream->Tell());
+ if (nRemainingSize < o3tl::make_unsigned(nOriginalBlockLen))
+ {
+ SAL_WARN("vcl.wmf", "exttextout record claimed more data than the stream can provide");
+ nOriginalTextLen = nOriginalBlockLen = nRemainingSize;
+ }
+
+ std::unique_ptr<char[]> pChar(new char[nOriginalBlockLen]);
+ mpInputStream->ReadBytes(pChar.get(), nOriginalBlockLen);
+ OUString aText(pChar.get(), nOriginalTextLen, GetCharSet()); // after this conversion the text may contain
+ sal_Int32 nNewTextLen = aText.getLength(); // less character (japanese version), so the
+ // dxAry will not fit
+ if ( nNewTextLen )
+ {
+ std::unique_ptr<long[]> pDXAry, pDYAry;
+ auto nDxArySize = nMaxStreamPos - mpInputStream->Tell();
+ auto nDxAryEntries = nDxArySize >> 1;
+ bool bUseDXAry = false;
+
+ if ( ( ( nDxAryEntries % nOriginalTextLen ) == 0 ) && ( nNewTextLen <= nOriginalTextLen ) )
+ {
+ sal_Int32 i; // needed just outside the for
+ pDXAry.reset(new long[ nNewTextLen ]);
+ if ( nOptions & ETO_PDY )
+ {
+ pDYAry.reset(new long[ nNewTextLen ]);
+ }
+ for (i = 0; i < nNewTextLen; i++ )
+ {
+ if ( mpInputStream->Tell() >= nMaxStreamPos )
+ break;
+ sal_Int32 nDxCount = 1;
+ if ( nNewTextLen != nOriginalTextLen )
+ {
+ sal_Unicode cUniChar = aText[i];
+ OString aTmp(&cUniChar, 1, GetCharSet());
+ if ( aTmp.getLength() > 1 )
+ {
+ nDxCount = aTmp.getLength();
+ }
+ }
+
+ sal_Int16 nDx = 0, nDy = 0;
+ while ( nDxCount-- )
+ {
+ if ( ( mpInputStream->Tell() + 2 ) > nMaxStreamPos )
+ break;
+ sal_Int16 nDxTmp = 0;
+ mpInputStream->ReadInt16(nDxTmp);
+ nDx += nDxTmp;
+ if ( nOptions & ETO_PDY )
+ {
+ if ( ( mpInputStream->Tell() + 2 ) > nMaxStreamPos )
+ break;
+ sal_Int16 nDyTmp = 0;
+ mpInputStream->ReadInt16(nDyTmp);
+ nDy += nDyTmp;
+ }
+ }
+
+ pDXAry[ i ] = nDx;
+ if ( nOptions & ETO_PDY )
+ {
+ pDYAry[i] = nDy;
+ }
+ }
+ if ( i == nNewTextLen )
+ bUseDXAry = true;
+ }
+ if ( pDXAry && bUseDXAry )
+ DrawText( aPosition, aText, pDXAry.get(), pDYAry.get() );
+ else
+ DrawText( aPosition, aText );
+ }
+ }
+ }
+ break;
+
+ case W_META_SELECTOBJECT:
+ {
+ sal_Int16 nObjIndex = 0;
+ mpInputStream->ReadInt16( nObjIndex );
+ SelectObject( nObjIndex );
+ }
+ break;
+
+ case W_META_SETTEXTALIGN:
+ {
+ sal_uInt16 nAlign = 0;
+ mpInputStream->ReadUInt16( nAlign );
+ SetTextAlign( nAlign );
+ }
+ break;
+
+ case W_META_BITBLT:
+ {
+ // 0-3 : nWinROP #93454#
+ // 4-5 : y offset of source bitmap
+ // 6-7 : x offset of source bitmap
+ // 8-9 : used height of source bitmap
+ // 10-11 : used width of source bitmap
+ // 12-13 : destination position y (in pixel)
+ // 14-15 : destination position x (in pixel)
+ // 16-17 : don't know
+ // 18-19 : Width Bitmap in Pixel
+ // 20-21 : Height Bitmap in Pixel
+ // 22-23 : bytes per scanline
+ // 24 : planes
+ // 25 : bitcount
+
+ sal_Int32 nWinROP = 0;
+ sal_uInt16 nSx = 0, nSy = 0, nSxe = 0, nSye = 0, nDontKnow = 0, nWidth = 0, nHeight = 0, nBytesPerScan = 0;
+ sal_uInt8 nPlanes, nBitCount;
+
+ mpInputStream->ReadInt32( nWinROP )
+ .ReadUInt16( nSy ).ReadUInt16( nSx ).ReadUInt16( nSye ).ReadUInt16( nSxe );
+ Point aPoint( ReadYX() );
+ mpInputStream->ReadUInt16( nDontKnow ).ReadUInt16( nWidth ).ReadUInt16( nHeight ).ReadUInt16( nBytesPerScan ).ReadUChar( nPlanes ).ReadUChar( nBitCount );
+
+ bool bOk = nWidth && nHeight && nPlanes == 1 && nBitCount == 1 && nBytesPerScan != 0;
+ if (bOk)
+ {
+ // must be enough data to fulfil the request
+ bOk = nBytesPerScan <= mpInputStream->remainingSize() / nHeight;
+ }
+ if (bOk)
+ {
+ // scanline must be large enough to provide all pixels
+ bOk = nBytesPerScan >= nWidth / 8;
+ }
+ if (bOk)
+ {
+ vcl::bitmap::RawBitmap aBmp( Size( nWidth, nHeight ), 24 );
+ for (sal_uInt16 y = 0; y < nHeight && mpInputStream->good(); ++y)
+ {
+ sal_uInt16 x = 0;
+ for (sal_uInt16 scan = 0; scan < nBytesPerScan; scan++ )
+ {
+ sal_Int8 nEightPixels = 0;
+ mpInputStream->ReadSChar( nEightPixels );
+ for (sal_Int8 i = 7; i >= 0; i-- )
+ {
+ if ( x < nWidth )
+ {
+ aBmp.SetPixel( y, x, ((nEightPixels>>i)&1) ? COL_BLACK : COL_WHITE );
+ }
+ x++;
+ }
+ }
+ }
+ BitmapEx aBitmap = vcl::bitmap::CreateFromData(std::move(aBmp));
+ if ( nSye && nSxe &&
+ ( nSx + nSxe <= nWidth ) &&
+ ( nSy + nSye <= nHeight ) )
+ {
+ tools::Rectangle aCropRect( Point( nSx, nSy ), Size( nSxe, nSye ) );
+ aBitmap.Crop( aCropRect );
+ }
+ tools::Rectangle aDestRect( aPoint, Size( nSxe, nSye ) );
+ maBmpSaveList.emplace_back(new BSaveStruct(aBitmap, aDestRect, nWinROP));
+ }
+ }
+ break;
+
+ case W_META_STRETCHBLT:
+ case W_META_DIBBITBLT:
+ case W_META_DIBSTRETCHBLT:
+ case W_META_STRETCHDIB:
+ {
+ sal_Int32 nWinROP = 0;
+ sal_uInt16 nSx = 0, nSy = 0, nSxe = 0, nSye = 0, nUsage = 0;
+ Bitmap aBmp;
+
+ mpInputStream->ReadInt32( nWinROP );
+
+ if( nFunc == W_META_STRETCHDIB )
+ mpInputStream->ReadUInt16( nUsage );
+
+ // nSye and nSxe is the number of pixels that has to been used
+ // If they are set to zero, it is as indicator not to scale the bitmap later
+
+ if( nFunc == W_META_STRETCHDIB || nFunc == W_META_STRETCHBLT || nFunc == W_META_DIBSTRETCHBLT )
+ mpInputStream->ReadUInt16( nSye ).ReadUInt16( nSxe );
+
+ // nSy and nx is the offset of the first pixel
+ mpInputStream->ReadUInt16( nSy ).ReadUInt16( nSx );
+
+ if( nFunc == W_META_STRETCHDIB || nFunc == W_META_DIBBITBLT || nFunc == W_META_DIBSTRETCHBLT )
+ {
+ if ( nWinROP == PATCOPY )
+ mpInputStream->ReadUInt16( nUsage ); // i don't know anything of this parameter, so it's called nUsage
+ // DrawRect( Rectangle( ReadYX(), aDestSize ), false );
+
+ Size aDestSize( ReadYXExt() );
+ if ( aDestSize.Width() && aDestSize.Height() ) // #92623# do not try to read buggy bitmaps
+ {
+ tools::Rectangle aDestRect( ReadYX(), aDestSize );
+ if ( nWinROP != PATCOPY )
+ ReadDIB(aBmp, *mpInputStream, false);
+
+ // test if it is sensible to crop
+ if ( nSye && nSxe &&
+ ( nSx + nSxe <= aBmp.GetSizePixel().Width() ) &&
+ ( nSy + nSye <= aBmp.GetSizePixel().Height() ) )
+ {
+ tools::Rectangle aCropRect( Point( nSx, nSy ), Size( nSxe, nSye ) );
+ aBmp.Crop( aCropRect );
+ }
+ maBmpSaveList.emplace_back(new BSaveStruct(aBmp, aDestRect, nWinROP));
+ }
+ }
+ }
+ break;
+
+ case W_META_DIBCREATEPATTERNBRUSH:
+ {
+ Bitmap aBmp;
+ sal_uInt32 nRed = 0, nGreen = 0, nBlue = 0, nCount = 1;
+ sal_uInt16 nFunction = 0;
+
+ mpInputStream->ReadUInt16( nFunction ).ReadUInt16( nFunction );
+
+ ReadDIB(aBmp, *mpInputStream, false);
+ if ( !!aBmp )
+ {
+ Bitmap::ScopedReadAccess pBmp(aBmp);
+ for ( long y = 0; y < pBmp->Height(); y++ )
+ {
+ for ( long x = 0; x < pBmp->Width(); x++ )
+ {
+ const BitmapColor aColor( pBmp->GetColor( y, x ) );
+
+ nRed += aColor.GetRed();
+ nGreen += aColor.GetGreen();
+ nBlue += aColor.GetBlue();
+ }
+ }
+ nCount = pBmp->Height() * pBmp->Width();
+ if ( !nCount )
+ nCount++;
+ }
+ Color aColor( static_cast<sal_uInt8>( nRed / nCount ), static_cast<sal_uInt8>( nGreen / nCount ), static_cast<sal_uInt8>( nBlue / nCount ) );
+ CreateObject(std::make_unique<WinMtfFillStyle>( aColor, false ));
+ }
+ break;
+
+ case W_META_DELETEOBJECT:
+ {
+ sal_Int16 nIndex = 0;
+ mpInputStream->ReadInt16( nIndex );
+ DeleteObject( nIndex );
+ }
+ break;
+
+ case W_META_CREATEPALETTE:
+ {
+ CreateObject();
+ }
+ break;
+
+ case W_META_CREATEBRUSH:
+ {
+ CreateObject(std::make_unique<WinMtfFillStyle>( COL_WHITE, false ));
+ }
+ break;
+
+ case W_META_CREATEPATTERNBRUSH:
+ {
+ CreateObject(std::make_unique<WinMtfFillStyle>( COL_WHITE, false ));
+ }
+ break;
+
+ case W_META_CREATEPENINDIRECT:
+ {
+ LineInfo aLineInfo;
+ sal_uInt16 nStyle = 0;
+ sal_uInt16 nWidth = 0;
+ sal_uInt16 nHeight = 0;
+
+ mpInputStream->ReadUInt16(nStyle);
+ mpInputStream->ReadUInt16(nWidth);
+ mpInputStream->ReadUInt16(nHeight);
+
+ if (nWidth > 0)
+ aLineInfo.SetWidth(nWidth);
+
+ bool bTransparent = false;
+
+ switch( nStyle & 0xFF )
+ {
+ 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 :
+ bTransparent = true;
+ aLineInfo.SetStyle( LineStyle::NONE );
+ break;
+ default :
+ case PS_INSIDEFRAME :
+ case PS_SOLID :
+ aLineInfo.SetStyle( LineStyle::Solid );
+ }
+ switch( nStyle & 0xF00 )
+ {
+ 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 );
+ }
+ switch( nStyle & 0xF000 )
+ {
+ case PS_JOIN_ROUND :
+ aLineInfo.SetLineJoin ( basegfx::B2DLineJoin::Round );
+ break;
+ case PS_JOIN_MITER :
+ aLineInfo.SetLineJoin ( basegfx::B2DLineJoin::Miter );
+ break;
+ case PS_JOIN_BEVEL :
+ aLineInfo.SetLineJoin ( basegfx::B2DLineJoin::Bevel );
+ break;
+ default :
+ aLineInfo.SetLineJoin ( basegfx::B2DLineJoin::NONE );
+ }
+ CreateObject(std::make_unique<WinMtfLineStyle>( ReadColor(), aLineInfo, bTransparent ));
+ }
+ break;
+
+ case W_META_CREATEBRUSHINDIRECT:
+ {
+ sal_uInt16 nStyle = 0;
+ mpInputStream->ReadUInt16( nStyle );
+ CreateObject(std::make_unique<WinMtfFillStyle>( ReadColor(), ( nStyle == BS_HOLLOW ) ));
+ }
+ break;
+
+ case W_META_CREATEFONTINDIRECT:
+ {
+ Size aFontSize;
+ char lfFaceName[LF_FACESIZE+1];
+ sal_Int16 lfEscapement = 0;
+ sal_Int16 lfOrientation = 0;
+ sal_Int16 lfWeight = 0;
+
+ LOGFONTW aLogFont;
+ aFontSize = ReadYXExt();
+ mpInputStream->ReadInt16( lfEscapement );
+ mpInputStream->ReadInt16( lfOrientation );
+ mpInputStream->ReadInt16( lfWeight );
+ mpInputStream->ReadUChar( aLogFont.lfItalic );
+ mpInputStream->ReadUChar( aLogFont.lfUnderline );
+ mpInputStream->ReadUChar( aLogFont.lfStrikeOut );
+ mpInputStream->ReadUChar( aLogFont.lfCharSet );
+ mpInputStream->ReadUChar( aLogFont.lfOutPrecision );
+ mpInputStream->ReadUChar( aLogFont.lfClipPrecision );
+ mpInputStream->ReadUChar( aLogFont.lfQuality );
+ mpInputStream->ReadUChar( aLogFont.lfPitchAndFamily );
+ size_t nRet = mpInputStream->ReadBytes( lfFaceName, LF_FACESIZE );
+ lfFaceName[nRet] = 0;
+ aLogFont.lfWidth = aFontSize.Width();
+ aLogFont.lfHeight = aFontSize.Height();
+ aLogFont.lfEscapement = lfEscapement;
+ aLogFont.lfOrientation = lfOrientation;
+ aLogFont.lfWeight = lfWeight;
+
+ rtl_TextEncoding eCharSet;
+ if ( ( aLogFont.lfCharSet == OEM_CHARSET ) || ( aLogFont.lfCharSet == DEFAULT_CHARSET ) )
+ eCharSet = osl_getThreadTextEncoding();
+ else
+ eCharSet = rtl_getTextEncodingFromWindowsCharset( aLogFont.lfCharSet );
+ if ( eCharSet == RTL_TEXTENCODING_DONTKNOW )
+ eCharSet = osl_getThreadTextEncoding();
+ if ( eCharSet == RTL_TEXTENCODING_SYMBOL )
+ eCharSet = RTL_TEXTENCODING_MS_1252;
+ aLogFont.alfFaceName = OUString( lfFaceName, strlen(lfFaceName), eCharSet );
+
+ CreateObject(std::make_unique<WinMtfFontStyle>( aLogFont ));
+ }
+ break;
+
+ case W_META_CREATEBITMAPINDIRECT:
+ {
+ CreateObject();
+ }
+ break;
+
+ case W_META_CREATEBITMAP:
+ {
+ CreateObject();
+ }
+ break;
+
+ case W_META_CREATEREGION:
+ {
+ CreateObject();
+ }
+ break;
+
+ case W_META_EXCLUDECLIPRECT :
+ {
+ ExcludeClipRect( ReadRectangle() );
+ }
+ break;
+
+ case W_META_PATBLT:
+ {
+ sal_uInt32 nROP = 0;
+ WMFRasterOp nOldROP = WMFRasterOp::NONE;
+ mpInputStream->ReadUInt32( nROP );
+ Size aSize = ReadYXExt();
+ nOldROP = SetRasterOp( static_cast<WMFRasterOp>(nROP) );
+ DrawRect( tools::Rectangle( ReadYX(), aSize ), false );
+ SetRasterOp( nOldROP );
+ }
+ break;
+
+ case W_META_SELECTCLIPREGION:
+ {
+ sal_Int16 nObjIndex = 0;
+ mpInputStream->ReadInt16( nObjIndex );
+ if ( !nObjIndex )
+ {
+ tools::PolyPolygon aEmptyPolyPoly;
+ SetClipPath( aEmptyPolyPoly, RGN_COPY, true );
+ }
+ }
+ break;
+
+ case W_META_ESCAPE :
+ {
+ // mnRecSize has been checked previously to be greater than 3
+ sal_uInt64 nMetaRecSize = static_cast< sal_uInt64 >(mnRecSize - 2 ) * 2;
+ sal_uInt64 nMetaRecEndPos = mpInputStream->Tell() + nMetaRecSize;
+
+ // taking care that mnRecSize does not exceed the maximal stream position
+ if ( nMetaRecEndPos > mnEndPos )
+ {
+ mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
+ break;
+ }
+ if (mnRecSize >= 4 ) // minimal escape length
+ {
+ sal_uInt16 nMode = 0, nLen = 0;
+ mpInputStream->ReadUInt16( nMode )
+ .ReadUInt16( nLen );
+ if ( ( nMode == W_MFCOMMENT ) && ( nLen >= 4 ) )
+ {
+ sal_uInt32 nNewMagic = 0; // we have to read int32 for
+ mpInputStream->ReadUInt32( nNewMagic ); // META_ESCAPE_ENHANCED_METAFILE CommentIdentifier
+
+ if( nNewMagic == 0x2c2a4f4f && nLen >= 14 )
+ {
+ sal_uInt16 nMagic2 = 0;
+ mpInputStream->ReadUInt16( nMagic2 );
+ if( nMagic2 == 0x0a ) // 2nd half of magic
+ { // continue with private escape
+ sal_uInt32 nCheck = 0, nEsc = 0;
+ mpInputStream->ReadUInt32( nCheck )
+ .ReadUInt32( nEsc );
+
+ sal_uInt32 nEscLen = nLen - 14;
+ if ( nEscLen <= (mnRecSize * 2 ) )
+ {
+ #ifdef OSL_BIGENDIAN
+ sal_uInt32 nTmp = OSL_SWAPDWORD( nEsc );
+ sal_uInt32 nCheckSum = rtl_crc32( 0, &nTmp, 4 );
+ #else
+ sal_uInt32 nCheckSum = rtl_crc32( 0, &nEsc, 4 );
+ #endif
+ std::unique_ptr<sal_Int8[]> pData;
+
+ if ( ( static_cast< sal_uInt64 >( nEscLen ) + mpInputStream->Tell() ) > nMetaRecEndPos )
+ {
+ mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
+ break;
+ }
+ if ( nEscLen > 0 )
+ {
+ pData.reset(new sal_Int8[ nEscLen ]);
+ mpInputStream->ReadBytes(pData.get(), nEscLen);
+ nCheckSum = rtl_crc32( nCheckSum, pData.get(), nEscLen );
+ }
+ if ( nCheck == nCheckSum )
+ {
+ switch( nEsc )
+ {
+ case PRIVATE_ESCAPE_UNICODE :
+ {
+ // we will use text instead of polygons only if we have the correct font
+ if ( Application::GetDefaultDevice()->IsFontAvailable( GetFont().GetFamilyName() ) )
+ {
+ Point aPt;
+ OUString aString;
+ sal_uInt32 nStringLen, nDXCount;
+ std::unique_ptr<long[]> pDXAry;
+ SvMemoryStream aMemoryStream( nEscLen );
+ aMemoryStream.WriteBytes(pData.get(), nEscLen);
+ aMemoryStream.Seek( STREAM_SEEK_TO_BEGIN );
+ sal_Int32 nTmpX(0), nTmpY(0);
+ aMemoryStream.ReadInt32( nTmpX )
+ .ReadInt32( nTmpY )
+ .ReadUInt32( nStringLen );
+ aPt.setX( nTmpX );
+ aPt.setY( nTmpY );
+
+ if ( ( static_cast< sal_uInt64 >( nStringLen ) * sizeof( sal_Unicode ) ) < ( nEscLen - aMemoryStream.Tell() ) )
+ {
+
+ aString = read_uInt16s_ToOUString(aMemoryStream, nStringLen);
+ aMemoryStream.ReadUInt32( nDXCount );
+ if ( ( static_cast< sal_uInt64 >( nDXCount ) * sizeof( sal_Int32 ) ) >= ( nEscLen - aMemoryStream.Tell() ) )
+ nDXCount = 0;
+ if ( nDXCount )
+ pDXAry.reset(new long[ nDXCount ]);
+ for (sal_uInt32 i = 0; i < nDXCount; i++ )
+ {
+ sal_Int32 val;
+ aMemoryStream.ReadInt32( val);
+ pDXAry[ i ] = val;
+ }
+ aMemoryStream.ReadUInt32(mnSkipActions);
+ DrawText( aPt, aString, pDXAry.get() );
+ }
+ }
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ else if ( (nNewMagic == static_cast< sal_uInt32 >(0x43464D57)) && (nLen >= 34) && ( static_cast<sal_Int32>(nLen + 10) <= static_cast<sal_Int32>(mnRecSize * 2) ))
+ {
+ sal_uInt32 nComType = 0, nVersion = 0, nFlags = 0, nComRecCount = 0,
+ nCurRecSize = 0, nRemainingSize = 0, nEMFTotalSize = 0;
+ sal_uInt16 nCheck = 0;
+
+ mpInputStream->ReadUInt32( nComType ).ReadUInt32( nVersion ).ReadUInt16( nCheck ).ReadUInt32( nFlags )
+ .ReadUInt32( nComRecCount ).ReadUInt32( nCurRecSize )
+ .ReadUInt32( nRemainingSize ).ReadUInt32( nEMFTotalSize ); // the nRemainingSize is not mentioned in MSDN documentation
+ // but it seems to be required to read in data produced by OLE
+
+ if( nComType == 0x01 && nVersion == 0x10000 && nComRecCount )
+ {
+ if( !mnEMFRec)
+ { // first EMF comment
+ mnEMFRecCount = nComRecCount;
+ mnEMFSize = nEMFTotalSize;
+ if (mnEMFSize > mpInputStream->remainingSize())
+ {
+ SAL_WARN("vcl.wmf", "emf size claims to be larger than remaining data");
+ mpEMFStream.reset();
+ }
+ else
+ mpEMFStream = std::make_unique<SvMemoryStream>(mnEMFSize, 0);
+ }
+ else if( (mnEMFRecCount != nComRecCount ) || (mnEMFSize != nEMFTotalSize ) ) // add additional checks here
+ {
+ // total records should be the same as in previous comments
+ mnEMFRecCount = 0xFFFFFFFF;
+ mpEMFStream.reset();
+ }
+ mnEMFRec++;
+
+ if (mpEMFStream && nCurRecSize + 34 > nLen)
+ {
+ mnEMFRecCount = 0xFFFFFFFF;
+ mpEMFStream.reset();
+ }
+
+ if (mpEMFStream && nCurRecSize > mpInputStream->remainingSize())
+ {
+ SAL_WARN("vcl.wmf", "emf record size claims to be larger than remaining data");
+ mnEMFRecCount = 0xFFFFFFFF;
+ mpEMFStream.reset();
+ }
+
+ if (mpEMFStream)
+ {
+ std::vector<sal_Int8> aBuf(nCurRecSize);
+ sal_uInt32 nCount = mpInputStream->ReadBytes(aBuf.data(), nCurRecSize);
+ if( nCount == nCurRecSize )
+ mpEMFStream->WriteBytes(aBuf.data(), nCount);
+ }
+ }
+ }
+ }
+ }
+ }
+ break;
+
+ case W_META_SETRELABS:
+ case W_META_SETPOLYFILLMODE:
+ case W_META_SETSTRETCHBLTMODE:
+ case W_META_SETTEXTCHAREXTRA:
+ case W_META_SETTEXTJUSTIFICATION:
+ case W_META_FLOODFILL :
+ case W_META_FILLREGION:
+ case W_META_FRAMEREGION:
+ case W_META_INVERTREGION:
+ case W_META_PAINTREGION:
+ case W_META_DRAWTEXT:
+ case W_META_SETMAPPERFLAGS:
+ case W_META_SETDIBTODEV:
+ case W_META_SELECTPALETTE:
+ case W_META_REALIZEPALETTE:
+ case W_META_ANIMATEPALETTE:
+ case W_META_SETPALENTRIES:
+ case W_META_RESIZEPALETTE:
+ case W_META_EXTFLOODFILL:
+ case W_META_RESETDC:
+ case W_META_STARTDOC:
+ case W_META_STARTPAGE:
+ case W_META_ENDPAGE:
+ case W_META_ABORTDOC:
+ case W_META_ENDDOC:
+ break;
+ }
+ }
+
+ static const long aMaxWidth = 1024;
+
+ bool WmfReader::ReadHeader()
+ {
+ sal_uInt64 const nStrmPos = mpInputStream->Tell();
+
+ sal_uInt32 nPlaceableMetaKey(0);
+ // if available read the METAFILEHEADER
+ mpInputStream->ReadUInt32( nPlaceableMetaKey );
+ if (!mpInputStream->good())
+ return false;
+
+ tools::Rectangle aPlaceableBound;
+
+ bool bPlaceable = nPlaceableMetaKey == 0x9ac6cdd7L;
+
+ SAL_INFO("vcl.wmf", "Placeable: \"" << (bPlaceable ? "yes" : "no") << "\"");
+
+ if (bPlaceable)
+ {
+ //TODO do some real error handling here
+ sal_Int16 nVal;
+
+ // Skip reserved bytes
+ mpInputStream->SeekRel(2);
+
+ // BoundRect
+ mpInputStream->ReadInt16( nVal );
+ aPlaceableBound.SetLeft( nVal );
+ mpInputStream->ReadInt16( nVal );
+ aPlaceableBound.SetTop( nVal );
+ mpInputStream->ReadInt16( nVal );
+ aPlaceableBound.SetRight( nVal );
+ mpInputStream->ReadInt16( nVal );
+ aPlaceableBound.SetBottom( nVal );
+
+ // inch
+ mpInputStream->ReadUInt16( mnUnitsPerInch );
+
+ // reserved
+ mpInputStream->SeekRel( 4 );
+
+ // Skip and don't check the checksum
+ mpInputStream->SeekRel( 2 );
+ }
+ else
+ {
+ mnUnitsPerInch = 96;
+
+ if (mpExternalHeader != nullptr
+ && mpExternalHeader->xExt > 0
+ && mpExternalHeader->yExt > 0
+ && (mpExternalHeader->mapMode == MM_ISOTROPIC || mpExternalHeader->mapMode == MM_ANISOTROPIC))
+ {
+ // #n417818#: If we have an external header then overwrite the bounds!
+ tools::Rectangle aExtRect(0, 0,
+ static_cast<double>(mpExternalHeader->xExt) * 567 * mnUnitsPerInch / 1440000,
+ static_cast<double>(mpExternalHeader->yExt) * 567 * mnUnitsPerInch / 1440000);
+ aPlaceableBound = aExtRect;
+
+ SAL_INFO("vcl.wmf", "External header size "
+ " t: " << aPlaceableBound.Left() << " l: " << aPlaceableBound.Top()
+ << " b: " << aPlaceableBound.Right() << " r: " << aPlaceableBound.Bottom());
+
+ SetMapMode(mpExternalHeader->mapMode);
+ }
+ else
+ {
+ mpInputStream->Seek(nStrmPos + 18); // set the streampos to the start of the metaactions
+ GetPlaceableBound(aPlaceableBound, mpInputStream);
+
+ // The image size is not known so normalize the calculated bounds so that the
+ // resulting image is not too big
+ const double fMaxWidth = static_cast<double>(aMaxWidth);
+ if (aPlaceableBound.GetWidth() > aMaxWidth)
+ {
+ double fRatio = aPlaceableBound.GetWidth() / fMaxWidth;
+
+ aPlaceableBound = tools::Rectangle(
+ aPlaceableBound.Left() / fRatio,
+ aPlaceableBound.Top() / fRatio,
+ aPlaceableBound.Right() / fRatio,
+ aPlaceableBound.Bottom() / fRatio);
+
+ SAL_INFO("vcl.wmf", "Placeable bounds "
+ " t: " << aPlaceableBound.Left() << " l: " << aPlaceableBound.Top()
+ << " b: " << aPlaceableBound.Right() << " r: " << aPlaceableBound.Bottom());
+ }
+ }
+
+ mpInputStream->Seek( nStrmPos );
+ }
+
+ SetWinOrg( aPlaceableBound.TopLeft() );
+ Size aWMFSize( labs( aPlaceableBound.GetWidth() ), labs( aPlaceableBound.GetHeight() ) );
+ SetWinExt( aWMFSize );
+
+ SAL_INFO("vcl.wmf", "WMF size w: " << aWMFSize.Width() << " h: " << aWMFSize.Height());
+
+ Size aDevExt( 10000, 10000 );
+ if( ( labs( aWMFSize.Width() ) > 1 ) && ( labs( aWMFSize.Height() ) > 1 ) )
+ {
+ const Fraction aFrac( 1, mnUnitsPerInch);
+ MapMode aWMFMap( MapUnit::MapInch, Point(), aFrac, aFrac );
+ Size aSize100(OutputDevice::LogicToLogic(aWMFSize, aWMFMap, MapMode(MapUnit::Map100thMM)));
+ aDevExt = Size( labs( aSize100.Width() ), labs( aSize100.Height() ) );
+ }
+ SetDevExt( aDevExt );
+
+ SAL_INFO("vcl.wmf", "Dev size w: " << aDevExt.Width() << " h: " << aDevExt.Height());
+
+ // read the METAHEADER
+ sal_uInt32 nMetaKey(0);
+ mpInputStream->ReadUInt32( nMetaKey ); // type and headersize
+ if (!mpInputStream->good())
+ return false;
+ if (nMetaKey != 0x00090001)
+ {
+ sal_uInt16 aNextWord(0);
+ mpInputStream->ReadUInt16( aNextWord );
+ if (nMetaKey != 0x10000 || aNextWord != 0x09)
+ {
+ mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
+ return false;
+ }
+ }
+
+ mpInputStream->SeekRel( 2 ); // Version (of Windows)
+ mpInputStream->SeekRel( 4 ); // Size (of file in words)
+ mpInputStream->SeekRel( 2 ); // NoObjects (maximum number of simultaneous objects)
+ mpInputStream->SeekRel( 4 ); // MaxRecord (size of largest record in words)
+ mpInputStream->SeekRel( 2 ); // NoParameters (Unused
+
+ return mpInputStream->good();
+ }
+
+ void WmfReader::ReadWMF()
+ {
+ sal_uInt16 nFunction;
+
+ mnSkipActions = 0;
+
+ mpEMFStream.reset();
+ mnEMFRecCount = 0;
+ mnEMFRec = 0;
+ mnEMFSize = 0;
+
+ SetMapMode( MM_ANISOTROPIC );
+ SetWinOrg( Point() );
+ SetWinExt( Size( 1, 1 ) );
+ SetDevExt( Size( 10000, 10000 ) );
+
+ mnEndPos=mpInputStream->TellEnd();
+ mpInputStream->Seek( mnStartPos );
+
+ if ( ReadHeader( ) )
+ {
+ auto nPos = mpInputStream->Tell();
+
+ if( mnEndPos - mnStartPos )
+ {
+ bool bEMFAvailable = false;
+ while( true )
+ {
+ mpInputStream->ReadUInt32(mnRecSize).ReadUInt16( nFunction );
+
+ if (
+ !mpInputStream->good() ||
+ (mnRecSize < 3) ||
+ (mnRecSize == 3 && nFunction == 0)
+ )
+ {
+ if( mpInputStream->eof() )
+ mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
+
+ break;
+ }
+
+ const sal_uInt32 nAvailableBytes = mnEndPos - nPos;
+ const sal_uInt32 nMaxPossibleRecordSize = nAvailableBytes/2;
+ if (mnRecSize > nMaxPossibleRecordSize)
+ {
+ mpInputStream->SetError(SVSTREAM_FILEFORMAT_ERROR);
+ break;
+ }
+
+ if ( !bEMFAvailable )
+ {
+ if( !maBmpSaveList.empty()
+ && ( nFunction != W_META_STRETCHDIB )
+ && ( nFunction != W_META_DIBBITBLT )
+ && ( nFunction != W_META_DIBSTRETCHBLT )
+ )
+ {
+ ResolveBitmapActions( maBmpSaveList );
+ }
+
+ if ( !mnSkipActions)
+ ReadRecordParams( nFunction );
+ else
+ mnSkipActions--;
+
+ if(mpEMFStream && mnEMFRecCount == mnEMFRec)
+ {
+ GDIMetaFile aMeta;
+ mpEMFStream->Seek( 0 );
+ std::unique_ptr<EmfReader> pEMFReader(std::make_unique<EmfReader>( *mpEMFStream, aMeta ));
+ bEMFAvailable = pEMFReader->ReadEnhWMF();
+ pEMFReader.reset(); // destroy first!!!
+
+ if( bEMFAvailable )
+ {
+ AddFromGDIMetaFile( aMeta );
+ SetrclFrame( tools::Rectangle( Point(0, 0), aMeta.GetPrefSize()));
+
+ // the stream needs to be set to the wmf end position,
+ // otherwise the GfxLink that is created will be incorrect
+ // (leading to graphic loss after swapout/swapin).
+ // so we will proceed normally, but are ignoring further wmf
+ // records
+ }
+ else
+ {
+ // something went wrong
+ // continue with WMF, don't try this again
+ mpEMFStream.reset();
+ }
+ }
+ }
+
+ nPos += mnRecSize * 2;
+ mpInputStream->Seek(nPos);
+ }
+ }
+ else
+ mpInputStream->SetError( SVSTREAM_GENERALERROR );
+
+ if( !mpInputStream->GetError() && !maBmpSaveList.empty() )
+ ResolveBitmapActions( maBmpSaveList );
+ }
+ if ( mpInputStream->GetError() )
+ mpInputStream->Seek( mnStartPos );
+ }
+
+ void WmfReader::GetPlaceableBound( tools::Rectangle& rPlaceableBound, SvStream* pStm )
+ {
+ bool bRet = true;
+
+ tools::Rectangle aBound;
+ aBound.SetLeft( RECT_MAX );
+ aBound.SetTop( RECT_MAX );
+ aBound.SetRight( RECT_MIN );
+ aBound.SetBottom( RECT_MIN );
+ bool bBoundsDetermined = false;
+
+ auto nPos = pStm->Tell();
+ auto nEnd = nPos + pStm->remainingSize();
+
+ Point aWinOrg(0,0);
+ std::optional<Size> aWinExt;
+
+ Point aViewportOrg(0,0);
+ std::optional<Size> aViewportExt;
+
+ if (nEnd - nPos)
+ {
+ sal_Int16 nMapMode = MM_ANISOTROPIC;
+ sal_uInt16 nFunction;
+ sal_uInt32 nRSize;
+
+ while( bRet )
+ {
+ pStm->ReadUInt32( nRSize ).ReadUInt16( nFunction );
+
+ if( pStm->GetError() )
+ {
+ bRet = false;
+ break;
+ }
+ else if ( nRSize==3 && nFunction==0 )
+ {
+ break;
+ }
+ else if ( nRSize < 3 || pStm->eof() )
+ {
+ pStm->SetError( SVSTREAM_FILEFORMAT_ERROR );
+ bRet = false;
+ break;
+ }
+ switch( nFunction )
+ {
+ case W_META_SETWINDOWORG:
+ {
+ aWinOrg = ReadYX();
+ }
+ break;
+
+ case W_META_SETWINDOWEXT:
+ {
+ sal_Int16 nWidth(0), nHeight(0);
+ pStm->ReadInt16(nHeight);
+ pStm->ReadInt16(nWidth);
+ aWinExt = Size(nWidth, nHeight);
+ }
+ break;
+
+ case W_META_SETVIEWPORTORG:
+ {
+ aViewportOrg = ReadYX();
+ }
+ break;
+
+ case W_META_SETVIEWPORTEXT:
+ {
+ sal_Int16 nWidth(0), nHeight(0);
+ pStm->ReadInt16(nHeight);
+ pStm->ReadInt16(nWidth);
+ aViewportExt = Size(nWidth, nHeight);
+ }
+ break;
+
+ case W_META_SETMAPMODE :
+ pStm->ReadInt16( nMapMode );
+ break;
+
+ case W_META_MOVETO:
+ case W_META_LINETO:
+ GetWinExtMax( ReadYX(), aBound, nMapMode );
+ bBoundsDetermined = true;
+ break;
+
+ case W_META_RECTANGLE:
+ case W_META_INTERSECTCLIPRECT:
+ case W_META_EXCLUDECLIPRECT :
+ case W_META_ELLIPSE:
+ GetWinExtMax( ReadRectangle(), aBound, nMapMode );
+ bBoundsDetermined = true;
+ break;
+
+ case W_META_ROUNDRECT:
+ ReadYXExt(); // size
+ GetWinExtMax( ReadRectangle(), aBound, nMapMode );
+ bBoundsDetermined = true;
+ break;
+
+ case W_META_ARC:
+ case W_META_PIE:
+ case W_META_CHORD:
+ ReadYX(); // end
+ ReadYX(); // start
+ GetWinExtMax( ReadRectangle(), aBound, nMapMode );
+ bBoundsDetermined = true;
+ break;
+
+ case W_META_POLYGON:
+ {
+ bool bRecordOk = true;
+
+ sal_uInt16 nPoints(0);
+ pStm->ReadUInt16( nPoints );
+
+ if (nPoints > pStm->remainingSize() / (2 * sizeof(sal_uInt16)))
+ {
+ bRecordOk = false;
+ }
+ else
+ {
+ for(sal_uInt16 i = 0; i < nPoints; i++ )
+ {
+ GetWinExtMax( ReadPoint(), aBound, nMapMode );
+ bBoundsDetermined = true;
+ }
+ }
+
+ SAL_WARN_IF(!bRecordOk, "vcl.wmf", "polyline record claimed more points than the stream can provide");
+
+ if (!bRecordOk)
+ {
+ pStm->SetError( SVSTREAM_FILEFORMAT_ERROR );
+ bRet = false;
+ break;
+ }
+ }
+ break;
+
+ case W_META_POLYPOLYGON:
+ {
+ bool bRecordOk = true;
+ sal_uInt16 nPoly(0), nPoints(0);
+ pStm->ReadUInt16(nPoly);
+ if (nPoly > pStm->remainingSize() / sizeof(sal_uInt16))
+ {
+ bRecordOk = false;
+ }
+ else
+ {
+ for(sal_uInt16 i = 0; i < nPoly; i++ )
+ {
+ sal_uInt16 nP = 0;
+ pStm->ReadUInt16( nP );
+ if (nP > SAL_MAX_UINT16 - nPoints)
+ {
+ bRecordOk = false;
+ break;
+ }
+ nPoints += nP;
+ }
+ }
+
+ SAL_WARN_IF(!bRecordOk, "vcl.wmf", "polypolygon record has more polygons than we can handle");
+
+ bRecordOk = bRecordOk && pStm->good();
+
+ if (!bRecordOk)
+ {
+ pStm->SetError( SVSTREAM_FILEFORMAT_ERROR );
+ bRet = false;
+ break;
+ }
+
+ if (nPoints > pStm->remainingSize() / (2 * sizeof(sal_uInt16)))
+ {
+ bRecordOk = false;
+ }
+ else
+ {
+ for (sal_uInt16 i = 0; i < nPoints; i++ )
+ {
+ GetWinExtMax( ReadPoint(), aBound, nMapMode );
+ bBoundsDetermined = true;
+ }
+ }
+
+ SAL_WARN_IF(!bRecordOk, "vcl.wmf", "polypolygon record claimed more points than the stream can provide");
+
+ bRecordOk &= pStm->good();
+
+ if (!bRecordOk)
+ {
+ pStm->SetError( SVSTREAM_FILEFORMAT_ERROR );
+ bRet = false;
+ break;
+ }
+ }
+ break;
+
+ case W_META_POLYLINE:
+ {
+ bool bRecordOk = true;
+
+ sal_uInt16 nPoints(0);
+ pStm->ReadUInt16(nPoints);
+ if (nPoints > pStm->remainingSize() / (2 * sizeof(sal_uInt16)))
+ {
+ bRecordOk = false;
+ }
+ else
+ {
+ for (sal_uInt16 i = 0; i < nPoints; ++i)
+ {
+ GetWinExtMax( ReadPoint(), aBound, nMapMode );
+ bBoundsDetermined = true;
+ }
+ }
+
+ SAL_WARN_IF(!bRecordOk, "vcl.wmf", "polyline record claimed more points than the stream can provide");
+
+ if (!bRecordOk)
+ {
+ pStm->SetError( SVSTREAM_FILEFORMAT_ERROR );
+ bRet = false;
+ break;
+ }
+ }
+ break;
+
+ case W_META_SETPIXEL:
+ {
+ ReadColor();
+ GetWinExtMax( ReadYX(), aBound, nMapMode );
+ bBoundsDetermined = true;
+ }
+ break;
+
+ case W_META_TEXTOUT:
+ {
+ sal_uInt16 nLength;
+ pStm->ReadUInt16( nLength );
+ // todo: we also have to take care of the text width
+ if ( nLength )
+ {
+ pStm->SeekRel( ( nLength + 1 ) &~ 1 );
+ GetWinExtMax( ReadYX(), aBound, nMapMode );
+ bBoundsDetermined = true;
+ }
+ }
+ break;
+
+ case W_META_EXTTEXTOUT:
+ {
+ sal_uInt16 nLen, nOptions;
+ Point aPosition = ReadYX();
+ pStm->ReadUInt16( nLen ).ReadUInt16( nOptions );
+ // todo: we also have to take care of the text width
+ if( nLen )
+ {
+ GetWinExtMax( aPosition, aBound, nMapMode );
+ bBoundsDetermined = true;
+ }
+ }
+ break;
+ case W_META_BITBLT:
+ case W_META_STRETCHBLT:
+ case W_META_DIBBITBLT:
+ case W_META_DIBSTRETCHBLT:
+ case W_META_STRETCHDIB:
+ {
+ sal_Int32 nWinROP;
+ sal_uInt16 nSx, nSy, nUsage;
+ pStm->ReadInt32( nWinROP );
+
+ if( nFunction == W_META_STRETCHDIB )
+ pStm->ReadUInt16( nUsage );
+
+ // nSye and nSxe is the number of pixels that has to been used
+ if( nFunction == W_META_STRETCHDIB || nFunction == W_META_STRETCHBLT || nFunction == W_META_DIBSTRETCHBLT )
+ {
+ sal_uInt16 nSxe, nSye;
+ pStm->ReadUInt16( nSye ).ReadUInt16( nSxe );
+ }
+
+ // nSy and nx is the offset of the first pixel
+ pStm->ReadUInt16( nSy ).ReadUInt16( nSx );
+
+ if( nFunction == W_META_STRETCHDIB || nFunction == W_META_DIBBITBLT || nFunction == W_META_DIBSTRETCHBLT )
+ {
+ if ( nWinROP == PATCOPY )
+ pStm->ReadUInt16( nUsage ); // i don't know anything of this parameter, so it's called nUsage
+ // DrawRect( Rectangle( ReadYX(), aDestSize ), false );
+
+ Size aDestSize( ReadYXExt() );
+ if ( aDestSize.Width() && aDestSize.Height() ) // #92623# do not try to read buggy bitmaps
+ {
+ tools::Rectangle aDestRect( ReadYX(), aDestSize );
+ GetWinExtMax( aDestRect, aBound, nMapMode );
+ bBoundsDetermined = true;
+ }
+ }
+ }
+ break;
+
+ case W_META_PATBLT:
+ {
+ sal_uInt32 nROP;
+ pStm->ReadUInt32( nROP );
+ Size aSize = ReadYXExt();
+ GetWinExtMax( tools::Rectangle( ReadYX(), aSize ), aBound, nMapMode );
+ bBoundsDetermined = true;
+ }
+ break;
+ }
+
+ const auto nAvailableBytes = nEnd - nPos;
+ const auto nMaxPossibleRecordSize = nAvailableBytes/2;
+ if (nRSize <= nMaxPossibleRecordSize)
+ {
+ nPos += nRSize * 2;
+ pStm->Seek(nPos);
+ }
+ else
+ {
+ pStm->SetError( SVSTREAM_FILEFORMAT_ERROR );
+ bRet = false;
+ }
+ }
+ }
+ else
+ {
+ pStm->SetError( SVSTREAM_GENERALERROR );
+ bRet = false;
+ }
+
+ if (!bRet)
+ return;
+
+ if (aWinExt)
+ {
+ rPlaceableBound = tools::Rectangle(aWinOrg, *aWinExt);
+ SAL_INFO("vcl.wmf", "Window dimension "
+ " t: " << rPlaceableBound.Left() << " l: " << rPlaceableBound.Top()
+ << " b: " << rPlaceableBound.Right() << " r: " << rPlaceableBound.Bottom());
+ }
+ else if (aViewportExt)
+ {
+ rPlaceableBound = tools::Rectangle(aViewportOrg, *aViewportExt);
+ SAL_INFO("vcl.wmf", "Viewport dimension "
+ " t: " << rPlaceableBound.Left() << " l: " << rPlaceableBound.Top()
+ << " b: " << rPlaceableBound.Right() << " r: " << rPlaceableBound.Bottom());
+ }
+ else if (bBoundsDetermined)
+ {
+ rPlaceableBound = aBound;
+ SAL_INFO("vcl.wmf", "Determined dimension "
+ " t: " << rPlaceableBound.Left() << " l: " << rPlaceableBound.Top()
+ << " b: " << rPlaceableBound.Right() << " r: " << rPlaceableBound.Bottom());
+ }
+ else
+ {
+ rPlaceableBound.SetLeft( 0 );
+ rPlaceableBound.SetTop( 0 );
+ rPlaceableBound.SetRight( aMaxWidth );
+ rPlaceableBound.SetBottom( aMaxWidth );
+ SAL_INFO("vcl.wmf", "Default dimension "
+ " t: " << rPlaceableBound.Left() << " l: " << rPlaceableBound.Top()
+ << " b: " << rPlaceableBound.Right() << " r: " << rPlaceableBound.Bottom());
+ }
+ }
+
+ WmfReader::WmfReader(SvStream& rStreamWMF, GDIMetaFile& rGDIMetaFile, const WmfExternal* pExternalHeader)
+ : MtfTools(rGDIMetaFile, rStreamWMF)
+ , mnUnitsPerInch(96)
+ , mnRecSize(0)
+ , mpEMFStream()
+ , mnEMFRecCount(0)
+ , mnEMFRec(0)
+ , mnEMFSize(0)
+ , mnSkipActions(0)
+ , mpExternalHeader(pExternalHeader)
+ {
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-27 12:55:40 +0000