summaryrefslogtreecommitdiffstats
path: root/emfio/source/reader/wmfreader.cxx
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
commited5640d8b587fbcfed7dd7967f3de04b37a76f26 (patch)
tree7a5f7c6c9d02226d7471cb3cc8fbbf631b415303 /emfio/source/reader/wmfreader.cxx
parentInitial commit. (diff)
downloadlibreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.tar.xz
libreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.zip
Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--emfio/source/reader/wmfreader.cxx2015
1 files changed, 2015 insertions, 0 deletions
diff --git a/emfio/source/reader/wmfreader.cxx b/emfio/source/reader/wmfreader.cxx
new file mode 100644
index 000000000..bb79033a3
--- /dev/null
+++ b/emfio/source/reader/wmfreader.cxx
@@ -0,0 +1,2015 @@
+/* -*- 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 <cstdlib>
+#include <memory>
+#include <optional>
+#include <o3tl/safeint.hxx>
+#include <o3tl/unit_conversion.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/BitmapReadAccess.hxx>
+#include <vcl/BitmapTools.hxx>
+#include <osl/thread.h>
+
+namespace
+{
+ // MS Windows defines
+ enum WMFRecords
+ {
+ W_META_EOF = 0x0000,
+ W_META_SETBKCOLOR = 0x0201,
+ W_META_SETBKMODE = 0x0102,
+ W_META_SETMAPMODE = 0x0103,
+ W_META_SETROP2 = 0x0104,
+ W_META_SETRELABS = 0x0105,
+ W_META_SETPOLYFILLMODE = 0x0106,
+ W_META_SETSTRETCHBLTMODE = 0x0107,
+ W_META_SETTEXTCHAREXTRA = 0x0108,
+ W_META_SETTEXTCOLOR = 0x0209,
+ W_META_SETTEXTJUSTIFICATION = 0x020A,
+ W_META_SETWINDOWORG = 0x020B,
+ W_META_SETWINDOWEXT = 0x020C,
+ W_META_SETVIEWPORTORG = 0x020D,
+ W_META_SETVIEWPORTEXT = 0x020E,
+ W_META_OFFSETWINDOWORG = 0x020F,
+ W_META_SCALEWINDOWEXT = 0x0410,
+ W_META_OFFSETVIEWPORTORG = 0x0211,
+ W_META_SCALEVIEWPORTEXT = 0x0412,
+ W_META_LINETO = 0x0213,
+ W_META_MOVETO = 0x0214,
+ W_META_EXCLUDECLIPRECT = 0x0415,
+ W_META_INTERSECTCLIPRECT = 0x0416,
+ W_META_ARC = 0x0817,
+ W_META_ELLIPSE = 0x0418,
+ W_META_FLOODFILL = 0x0419,
+ W_META_PIE = 0x081A,
+ W_META_RECTANGLE = 0x041B,
+ W_META_ROUNDRECT = 0x061C,
+ W_META_PATBLT = 0x061D,
+ W_META_SAVEDC = 0x001E,
+ W_META_SETPIXEL = 0x041F,
+ W_META_OFFSETCLIPRGN = 0x0220,
+ W_META_TEXTOUT = 0x0521,
+ W_META_BITBLT = 0x0922,
+ W_META_STRETCHBLT = 0x0B23,
+ W_META_POLYGON = 0x0324,
+ W_META_POLYLINE = 0x0325,
+ W_META_ESCAPE = 0x0626,
+ W_META_RESTOREDC = 0x0127,
+ W_META_FILLREGION = 0x0228,
+ W_META_FRAMEREGION = 0x0429,
+ W_META_INVERTREGION = 0x012A,
+ W_META_PAINTREGION = 0x012B,
+ W_META_SELECTCLIPREGION = 0x012C,
+ W_META_SELECTOBJECT = 0x012D,
+ W_META_SETTEXTALIGN = 0x012E,
+ W_META_DRAWTEXT = 0x062F,
+ W_META_CHORD = 0x0830,
+ W_META_SETMAPPERFLAGS = 0x0231,
+ W_META_EXTTEXTOUT = 0x0a32,
+ W_META_SETDIBTODEV = 0x0d33,
+ W_META_SELECTPALETTE = 0x0234,
+ W_META_REALIZEPALETTE = 0x0035,
+ W_META_ANIMATEPALETTE = 0x0436,
+ W_META_SETPALENTRIES = 0x0037,
+ W_META_POLYPOLYGON = 0x0538,
+ W_META_RESIZEPALETTE = 0x0139,
+ W_META_DIBBITBLT = 0x0940,
+ W_META_DIBSTRETCHBLT = 0x0b41,
+ W_META_DIBCREATEPATTERNBRUSH = 0x0142,
+ W_META_STRETCHDIB = 0x0f43,
+ W_META_EXTFLOODFILL = 0x0548,
+ W_META_RESETDC = 0x014C,
+ W_META_STARTDOC = 0x014D,
+ W_META_STARTPAGE = 0x004F,
+ W_META_ENDPAGE = 0x0050,
+ W_META_ABORTDOC = 0x0052,
+ W_META_ENDDOC = 0x005E,
+ W_META_DELETEOBJECT = 0x01f0,
+ W_META_CREATEPALETTE = 0x00f7,
+ W_META_CREATEBRUSH = 0x00F8,
+ W_META_CREATEPATTERNBRUSH = 0x01F9,
+ W_META_CREATEPENINDIRECT = 0x02FA,
+ W_META_CREATEFONTINDIRECT = 0x02FB,
+ W_META_CREATEBRUSHINDIRECT = 0x02FC,
+ W_META_CREATEBITMAPINDIRECT = 0x02FD,
+ W_META_CREATEBITMAP = 0x06FE,
+ W_META_CREATEREGION = 0x06FF
+ };
+
+ void GetWinExtMax(const Point& rSource, tools::Rectangle& rPlaceableBound, emfio::MappingMode eMapMode)
+ {
+ Point aSource(rSource);
+ if (eMapMode == emfio::MappingMode::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, emfio::MappingMode nMapMode)
+ {
+ GetWinExtMax(rSource.TopLeft(), rPlaceableBound, nMapMode);
+ GetWinExtMax(rSource.BottomRight(), rPlaceableBound, nMapMode);
+ }
+
+ const char *
+ record_type_name(sal_uInt16 nRecType)
+ {
+ #ifndef SAL_LOG_INFO
+ (void) nRecType;
+ return "";
+ #else
+ switch( nRecType )
+ {
+ case W_META_SETBKCOLOR: return "META_SETBKCOLOR";
+ case W_META_SETBKMODE: return "META_SETBKMODE";
+ case W_META_SETMAPMODE: return "META_SETMAPMODE";
+ case W_META_SETROP2: return "META_SETROP2";
+ case W_META_SETRELABS: return "META_SETRELABS";
+ case W_META_SETPOLYFILLMODE: return "META_SETPOLYFILLMODE";
+ case W_META_SETSTRETCHBLTMODE: return "META_SETSTRETCHBLTMODE";
+ case W_META_SETTEXTCHAREXTRA: return "META_SETTEXTCHAREXTRA";
+ case W_META_SETTEXTCOLOR: return "META_SETTEXTCOLOR";
+ case W_META_SETTEXTJUSTIFICATION: return "META_SETTEXTJUSTIFICATION";
+ case W_META_SETWINDOWORG: return "META_SETWINDOWORG";
+ case W_META_SETWINDOWEXT: return "META_SETWINDOWEXT";
+ case W_META_SETVIEWPORTORG: return "META_SETVIEWPORTORG";
+ case W_META_SETVIEWPORTEXT: return "META_SETVIEWPORTEXT";
+ case W_META_OFFSETWINDOWORG: return "META_OFFSETWINDOWORG";
+ case W_META_SCALEWINDOWEXT: return "META_SCALEWINDOWEXT";
+ case W_META_OFFSETVIEWPORTORG: return "META_OFFSETVIEWPORTORG";
+ case W_META_SCALEVIEWPORTEXT: return "META_SCALEVIEWPORTEXT";
+ case W_META_LINETO: return "META_LINETO";
+ case W_META_MOVETO: return "META_MOVETO";
+ case W_META_EXCLUDECLIPRECT: return "META_EXCLUDECLIPRECT";
+ case W_META_INTERSECTCLIPRECT: return "META_INTERSECTCLIPRECT";
+ case W_META_ARC: return "META_ARC";
+ case W_META_ELLIPSE: return "META_ELLIPSE";
+ case W_META_FLOODFILL: return "META_FLOODFILL";
+ case W_META_PIE: return "META_PIE";
+ case W_META_RECTANGLE: return "META_RECTANGLE";
+ case W_META_ROUNDRECT: return "META_ROUNDRECT";
+ case W_META_PATBLT: return "META_PATBLT";
+ case W_META_SAVEDC: return "META_SAVEDC";
+ case W_META_SETPIXEL: return "META_SETPIXEL";
+ case W_META_OFFSETCLIPRGN: return "META_OFFSETCLIPRGN";
+ case W_META_TEXTOUT: return "META_TEXTOUT";
+ case W_META_BITBLT: return "META_BITBLT";
+ case W_META_STRETCHBLT: return "META_STRETCHBLT";
+ case W_META_POLYGON: return "META_POLYGON";
+ case W_META_POLYLINE: return "META_POLYLINE";
+ case W_META_ESCAPE: return "META_ESCAPE";
+ case W_META_RESTOREDC: return "META_RESTOREDC";
+ case W_META_FILLREGION: return "META_FILLREGION";
+ case W_META_FRAMEREGION: return "META_FRAMEREGION";
+ case W_META_INVERTREGION: return "META_INVERTREGION";
+ case W_META_PAINTREGION: return "META_PAINTREGION";
+ case W_META_SELECTCLIPREGION: return "META_SELECTCLIPREGION";
+ case W_META_SELECTOBJECT: return "META_SELECTOBJECT";
+ case W_META_SETTEXTALIGN: return "META_SETTEXTALIGN";
+ case W_META_DRAWTEXT: return "META_DRAWTEXT";
+ case W_META_CHORD: return "META_CHORD";
+ case W_META_SETMAPPERFLAGS: return "META_SETMAPPERFLAGS";
+ case W_META_EXTTEXTOUT: return "META_EXTTEXTOUT";
+ case W_META_SETDIBTODEV: return "META_SETDIBTODEV";
+ case W_META_SELECTPALETTE: return "META_SELECTPALETTE";
+ case W_META_REALIZEPALETTE: return "META_REALIZEPALETTE";
+ case W_META_ANIMATEPALETTE: return "META_ANIMATEPALETTE";
+ case W_META_SETPALENTRIES: return "META_SETPALENTRIES";
+ case W_META_POLYPOLYGON: return "META_POLYPOLYGON";
+ case W_META_RESIZEPALETTE: return "META_RESIZEPALETTE";
+ case W_META_DIBBITBLT: return "META_DIBBITBLT";
+ case W_META_DIBSTRETCHBLT: return "META_DIBSTRETCHBLT";
+ case W_META_DIBCREATEPATTERNBRUSH: return "META_DIBCREATEPATTERNBRUSH";
+ case W_META_STRETCHDIB: return "META_STRETCHDIB";
+ case W_META_EXTFLOODFILL: return "META_EXTFLOODFILL";
+ case W_META_RESETDC: return "META_RESETDC";
+ case W_META_STARTDOC: return "META_STARTDOC";
+ case W_META_STARTPAGE: return "META_STARTPAGE";
+ case W_META_ENDPAGE: return "META_ENDPAGE";
+ case W_META_ABORTDOC: return "META_ABORTDOC";
+ case W_META_ENDDOC: return "META_ENDDOC";
+ case W_META_DELETEOBJECT: return "META_DELETEOBJECT";
+ case W_META_CREATEPALETTE: return "META_CREATEPALETTE";
+ case W_META_CREATEBRUSH: return "META_CREATEBRUSH";
+ case W_META_CREATEPATTERNBRUSH: return "META_CREATEPATTERNBRUSH";
+ case W_META_CREATEPENINDIRECT: return "META_CREATEPENINDIRECT";
+ case W_META_CREATEFONTINDIRECT: return "META_CREATEFONTINDIRECT";
+ case W_META_CREATEBRUSHINDIRECT: return "META_CREATEBRUSHINDIRECT";
+ case W_META_CREATEBITMAPINDIRECT: return "META_CREATEBITMAPINDIRECT";
+ case W_META_CREATEBITMAP: return "META_CREATEBITMAP";
+ case W_META_CREATEREGION: return "META_CREATEREGION";
+ 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, sal_uInt32(nRecType));
+ return buffer;
+ }
+ #endif
+ }
+
+}
+
+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("emfio", "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_uInt32 nRecordSize, sal_uInt16 nFunc )
+ {
+ SAL_INFO("emfio", "\t" << record_type_name(nFunc));
+ switch( nFunc )
+ {
+ case W_META_SETBKCOLOR:
+ {
+ SetBkColor( ReadColor() );
+ }
+ break;
+
+ case W_META_SETBKMODE:
+ {
+ sal_uInt16 nDat = 0;
+ mpInputStream->ReadUInt16( nDat );
+ SetBkMode( static_cast<BackgroundMode>(nDat) );
+ }
+ break;
+
+ // !!!
+ case W_META_SETMAPMODE:
+ {
+ sal_Int16 nMapMode = 0;
+ mpInputStream->ReadInt16( nMapMode );
+ SetMapMode( static_cast<MappingMode>(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(std::move(aPoly), false/*bRecordPath*/);
+ }
+
+ SAL_WARN_IF(!bRecordOk, "emfio", "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, "emfio", "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( std::move(aPoly) );
+ }
+
+ SAL_WARN_IF(!bRecordOk, "emfio", "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:
+ {
+ sal_Int16 nSavedDC(0);
+ mpInputStream->ReadInt16( nSavedDC );
+ SAL_INFO( "emfio", "\t\t SavedDC: " << nSavedDC );
+ Pop( nSavedDC );
+ }
+ 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("emfio", "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("emfio", "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("emfio", "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 );
+ SAL_INFO( "emfio", "\t\t\t Pos: " << aPosition.getX() << ":" << aPosition.getY() << " String Length: " << nLen << " Options: " << nOptions );
+ tools::Rectangle aRect;
+ if ( ( nOptions & ETO_CLIPPED ) || ( nOptions & ETO_OPAQUE ) )
+ {
+ nNonStringLen += 2 * sizeof(sal_uInt16);
+
+ if (nRecSize < nNonStringLen)
+ {
+ SAL_WARN("emfio", "W_META_TEXTOUT too short");
+ break;
+ }
+ const Point aTopLeft = ReadPoint();
+ const Point aBottomRight = ReadPoint();
+ aRect = tools::Rectangle( aTopLeft, aBottomRight );
+ if ( nOptions & ETO_OPAQUE )
+ DrawRectWithBGColor( aRect );
+ SAL_INFO( "emfio", "\t\t\t Rectangle : " << aTopLeft.getX() << ":" << aTopLeft.getY() << ", " << aBottomRight.getX() << ":" << aBottomRight.getY() );
+ }
+
+ vcl::text::ComplexTextLayoutFlags nTextLayoutMode = vcl::text::ComplexTextLayoutFlags::Default;
+ if ( nOptions & ETO_RTLREADING )
+ nTextLayoutMode = vcl::text::ComplexTextLayoutFlags::BiDiRtl | vcl::text::ComplexTextLayoutFlags::TextOriginLeft;
+ SetTextLayoutMode( nTextLayoutMode );
+ SAL_WARN_IF( ( nOptions & ( ETO_PDY | ETO_GLYPH_INDEX ) ) != 0, "emfio", "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("emfio", "exttextout record claimed more data than the stream can provide");
+ nOriginalTextLen = nOriginalBlockLen = nRemainingSize;
+ }
+
+ std::vector<char> pChar(nOriginalBlockLen);
+ mpInputStream->ReadBytes(pChar.data(), nOriginalBlockLen);
+ OUString aText(pChar.data(), 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 )
+ {
+ if ( nOptions & ETO_CLIPPED )
+ {
+ Push(); // Save the current clip. It will be restored after text drawing
+ IntersectClipRect( aRect );
+ }
+ SAL_INFO( "emfio", "\t\t\t Text : " << aText );
+ std::vector<sal_Int32> aDXAry;
+ std::unique_ptr<tools::Long[]> 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
+ aDXAry.resize( nNewTextLen );
+ if ( nOptions & ETO_PDY )
+ {
+ pDYAry.reset(new tools::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;
+ }
+ }
+
+ aDXAry[ i ] = nDx;
+ if ( nOptions & ETO_PDY )
+ {
+ pDYAry[i] = nDy;
+ }
+ }
+ if ( i == nNewTextLen )
+ bUseDXAry = true;
+ }
+ if ( bUseDXAry )
+ DrawText( aPosition, aText, &aDXAry, pDYAry.get() );
+ else
+ DrawText( aPosition, aText );
+ if ( nOptions & ETO_CLIPPED )
+ Pop();
+ }
+ }
+ }
+ break;
+
+ case W_META_SELECTOBJECT:
+ case W_META_SELECTPALETTE:
+ {
+ sal_uInt16 nObjIndex = 0;
+ mpInputStream->ReadUInt16( nObjIndex );
+ SelectObject( nObjIndex );
+ }
+ break;
+
+ case W_META_SETTEXTALIGN:
+ {
+ sal_uInt16 nAlign = 0;
+ mpInputStream->ReadUInt16( nAlign );
+ SetTextAlign( nAlign );
+ }
+ break;
+
+ case W_META_BITBLT:
+ case W_META_STRETCHBLT:
+ {
+ sal_uInt32 nRasterOperation = 0;
+ sal_Int16 nSrcHeight = 0, nSrcWidth = 0, nYSrc, nXSrc, nSye, nSxe, nBitmapType, nWidth, nHeight, nBytesPerScan;
+ sal_uInt8 nPlanes, nBitCount;
+ const bool bNoSourceBitmap = ( nRecordSize == ( static_cast< sal_uInt32 >( nFunc ) >> 8 ) + 3 );
+
+ mpInputStream->ReadUInt32( nRasterOperation );
+ SAL_INFO("emfio", "\t\t Raster operation: 0x" << std::hex << nRasterOperation << std::dec << ", No source bitmap: " << bNoSourceBitmap);
+
+ if( nFunc == W_META_STRETCHBLT )
+ mpInputStream->ReadInt16( nSrcHeight ).ReadInt16( nSrcWidth );
+
+ mpInputStream->ReadInt16( nYSrc ).ReadInt16( nXSrc );
+ if ( bNoSourceBitmap )
+ mpInputStream->SeekRel( 2 ); // Skip Reserved 2 bytes (it must be ignored)
+ mpInputStream->ReadInt16( nSye ).ReadInt16( nSxe );
+ Point aPoint( ReadYX() ); // The upper-left corner of the destination rectangle.
+ mpInputStream->ReadInt16( nBitmapType ).ReadInt16( nWidth ).ReadInt16( nHeight ).ReadInt16( nBytesPerScan ).ReadUChar( nPlanes ).ReadUChar( nBitCount );
+
+ SAL_INFO("emfio", "\t\t Bitmap type:" << nBitmapType << " Width:" << nWidth << " Height:" << nHeight << " WidthBytes:" << nBytesPerScan << " Planes: " << static_cast< sal_uInt16 >( nPlanes ) << " BitCount: " << static_cast< sal_uInt16 >( nBitCount ) );
+ if (!mpInputStream->good() || bNoSourceBitmap || nBitCount == 4 || nBitCount == 8 || nPlanes != 1)
+ {
+ SAL_WARN("emfio", "\t\t TODO The unsupported Bitmap record. Please fill a bug.");
+ break;
+ }
+ const vcl::PixelFormat ePixelFormat = vcl::bitDepthToPixelFormat( nBitCount );
+ bool bOk = nWidth > 0 && nHeight > 0 && nBytesPerScan > 0 && ePixelFormat != vcl::PixelFormat::INVALID;
+ if (bOk)
+ {
+ // must be enough data to fulfil the request
+ bOk = o3tl::make_unsigned( nBytesPerScan ) <= mpInputStream->remainingSize() / nHeight;
+ }
+ if (bOk)
+ {
+ // scanline must be large enough to provide all pixels
+ bOk = nBytesPerScan >= nWidth * nBitCount / 8;
+ }
+ if (bOk)
+ {
+ std::unique_ptr< sal_uInt8[] > pData;
+ pData.reset( new sal_uInt8[ nHeight * nBytesPerScan ] );
+ mpInputStream->ReadBytes( pData.get(), nHeight * nBytesPerScan );
+ BitmapEx aBitmap = vcl::bitmap::CreateFromData( pData.get(), nWidth, nHeight, nBytesPerScan, ePixelFormat, true );
+ if ( nSye && nSxe &&
+ ( nXSrc + nSxe <= nWidth ) &&
+ ( nYSrc + nSye <= nHeight ) )
+ {
+ tools::Rectangle aCropRect( Point( nXSrc, nYSrc ), Size( nSxe, nSye ) );
+ aBitmap.Crop( aCropRect );
+ }
+ tools::Rectangle aDestRect( aPoint, Size( nSxe, nSye ) );
+ maBmpSaveList.emplace_back(aBitmap, aDestRect, nRasterOperation);
+ }
+ }
+ break;
+
+ case W_META_DIBBITBLT:
+ case W_META_DIBSTRETCHBLT:
+ case W_META_STRETCHDIB:
+ {
+ sal_uInt32 nRasterOperation = 0;
+ sal_uInt16 nColorUsage = 0;
+ sal_Int16 nSrcHeight = 0, nSrcWidth = 0, nYSrc = 0, nXSrc = 0;
+ Bitmap aBmp;
+ const bool bNoSourceBitmap = ( nFunc != W_META_STRETCHDIB ) && ( nRecordSize == ( ( static_cast< sal_uInt32 >( nFunc ) >> 8 ) + 3 ) );
+
+ mpInputStream->ReadUInt32( nRasterOperation );
+ SAL_INFO("emfio", "\t\t Raster operation: 0x" << std::hex << nRasterOperation << std::dec << ", No source bitmap: " << bNoSourceBitmap);
+ if( nFunc == W_META_STRETCHDIB )
+ mpInputStream->ReadUInt16( nColorUsage );
+
+ // nSrcHeight and nSrcWidth 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_DIBSTRETCHBLT ||
+ nFunc == W_META_STRETCHDIB )
+ mpInputStream->ReadInt16( nSrcHeight ).ReadInt16( nSrcWidth );
+
+ // nYSrc and nXSrc is the offset of the first pixel
+ mpInputStream->ReadInt16( nYSrc ).ReadInt16( nXSrc );
+
+ if ( bNoSourceBitmap )
+ mpInputStream->SeekRel( 2 ); // Skip Reserved 2 bytes (it must be ignored)
+
+ Size aDestSize( ReadYXExt() );
+ if ( aDestSize.Width() && aDestSize.Height() ) // #92623# do not try to read buggy bitmaps
+ {
+ tools::Rectangle aDestRect( ReadYX(), aDestSize );
+ if ( !bNoSourceBitmap )
+ {
+ // tdf#142625 Read the DIBHeader and check if bitmap is supported
+ // If bitmap is not supported don't run ReadDIB, as it will interrupt image processing
+ const auto nOldPos(mpInputStream->Tell());
+ sal_uInt32 nHeaderSize(0);
+ mpInputStream->ReadUInt32( nHeaderSize );
+ if ( nHeaderSize == 0xC ) // BitmapCoreHeader
+ mpInputStream->SeekRel( 6 ); // skip Width (16), Height (16), Planes (16)
+ else
+ mpInputStream->SeekRel( 10 ); // skip Width (32), Height (32), Planes (16)
+ sal_uInt16 nBitCount(0);
+ mpInputStream->ReadUInt16( nBitCount );
+ if ( nBitCount == 0 ) // TODO Undefined BitCount (JPEG/PNG), which are not supported
+ break;
+ mpInputStream->Seek(nOldPos);
+
+ if ( !ReadDIB( aBmp, *mpInputStream, false ) )
+ SAL_WARN( "emfio", "\tTODO Read DIB failed. Interrupting processing whole image. Please report bug report." );
+ }
+ // test if it is sensible to crop
+ if ( nSrcHeight && nSrcWidth &&
+ ( nXSrc + nSrcWidth <= aBmp.GetSizePixel().Width() ) &&
+ ( nYSrc + nSrcHeight <= aBmp.GetSizePixel().Height() ) )
+ {
+ tools::Rectangle aCropRect( Point( nXSrc, nYSrc ), Size( nSrcWidth, nSrcHeight ) );
+ aBmp.Crop( aCropRect );
+ }
+
+ maBmpSaveList.emplace_back(aBmp, aDestRect, nRasterOperation);
+ }
+ }
+ break;
+
+ case W_META_DIBCREATEPATTERNBRUSH:
+ {
+ Bitmap aBmp;
+ sal_uInt32 nRed(0), nGreen(0), nBlue(0), nCount(1);
+ sal_uInt16 nStyle(0), nColorUsage(0);
+
+ mpInputStream->ReadUInt16( nStyle ).ReadUInt16( nColorUsage );
+ BrushStyle eStyle = static_cast<BrushStyle>(nStyle);
+ SAL_INFO( "emfio", "\t\t Style:" << nStyle << ", ColorUsage: " << nColorUsage );
+ if ( eStyle == BrushStyle::BS_PATTERN ) // TODO tdf#142625 Add support for pattern
+ {
+ SAL_WARN( "emfio", "\tTODO: Pattern brush style is not supported." );
+ CreateObject();
+ break;
+ }
+ if ( !ReadDIB( aBmp, *mpInputStream, false ) )
+ SAL_WARN( "emfio", "\tTODO Read DIB failed. Interrupting processing whole image. Please report bug report." );
+ if ( !aBmp.IsEmpty() )
+ {
+ Bitmap::ScopedReadAccess pBmp(aBmp);
+ for ( tools::Long y = 0; y < pBmp->Height(); y++ )
+ {
+ for ( tools::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_uInt16 nIndex = 0;
+ mpInputStream->ReadUInt16( nIndex );
+ DeleteObject( nIndex );
+ }
+ break;
+
+ case W_META_CREATEPALETTE:
+ {
+ sal_uInt16 nStart = 0;
+ sal_uInt16 nNumberOfEntries = 0;
+ mpInputStream->ReadUInt16( nStart );
+ mpInputStream->ReadUInt16( nNumberOfEntries );
+
+ SAL_INFO("emfio", "\t\t Start 0x" << std::hex << nStart << std::dec << ", Number of entries: " << nNumberOfEntries);
+ sal_uInt32 nPalleteEntry;
+ std::vector< Color > aPaletteColors;
+ for (sal_uInt16 i = 0; i < nNumberOfEntries; ++i)
+ {
+ //PALETTEENTRY: Values, Blue, Green, Red
+ mpInputStream->ReadUInt32( nPalleteEntry );
+ SAL_INFO("emfio", "\t\t " << i << ". Palette entry: " << std::setw(10) << std::showbase <<std::hex << nPalleteEntry << std::dec );
+ aPaletteColors.push_back(Color(static_cast<sal_uInt8>(nPalleteEntry), static_cast<sal_uInt8>(nPalleteEntry >> 8), static_cast<sal_uInt8>(nPalleteEntry >> 16)));
+ }
+ CreateObject(std::make_unique<WinMtfPalette>( aPaletteColors ));
+ }
+ break;
+
+ case W_META_CREATEBRUSH:
+ {
+ SAL_WARN( "emfio", "TODO: Not implemented. Please fill the bug report" );
+ CreateObject(std::make_unique<WinMtfFillStyle>( COL_WHITE, false ));
+ }
+ break;
+
+ case W_META_CREATEPATTERNBRUSH:
+ {
+ SAL_WARN( "emfio", "TODO: Not implemented. Please fill the bug report" );
+ 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);
+ CreateObject(std::make_unique<WinMtfLineStyle>(ReadColor(), nStyle, nWidth));
+ }
+ break;
+
+ case W_META_CREATEBRUSHINDIRECT:
+ {
+ sal_uInt16 nBrushStyle = 0;
+ mpInputStream->ReadUInt16( nBrushStyle );
+ BrushStyle eBrushStyle = static_cast<BrushStyle>(nBrushStyle);
+ CreateObject(std::make_unique<WinMtfFillStyle>( ReadColor(), ( eBrushStyle == BrushStyle::BS_NULL ) ));
+ SAL_WARN_IF( (eBrushStyle != BrushStyle::BS_SOLID) && (eBrushStyle != BrushStyle::BS_NULL), "emfio", "TODO: Brush style not implemented. Please fill the bug report" );
+ }
+ 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:
+ {
+ SAL_WARN( "emfio", "TODO: W_META_CREATEBITMAPINDIRECT is not implemented. Please fill the bug report" );
+ CreateObject();
+ }
+ break;
+
+ case W_META_CREATEBITMAP:
+ {
+ SAL_WARN( "emfio", "TODO: W_META_CREATEBITMAP is not implemented. Please fill the bug report" );
+ CreateObject();
+ }
+ break;
+
+ case W_META_CREATEREGION:
+ {
+ SAL_WARN( "emfio", "TODO: W_META_CREATEREGION is not implemented. Please fill the bug report" );
+ CreateObject();
+ }
+ break;
+
+ case W_META_EXCLUDECLIPRECT :
+ {
+ SAL_WARN( "emfio", "TODO: Not working correctly. Please fill the bug report" );
+ ExcludeClipRect( ReadRectangle() );
+ }
+ break;
+
+ case W_META_PATBLT:
+ {
+ sal_uInt32 nROP = 0;
+ mpInputStream->ReadUInt32( nROP );
+ Size aSize = ReadYXExt();
+ WMFRasterOp nOldROP = SetRasterOp( static_cast<WMFRasterOp>(nROP) );
+ DrawRect( tools::Rectangle( ReadYX(), aSize ), false );
+ SetRasterOp( nOldROP );
+ }
+ break;
+
+ case W_META_SELECTCLIPREGION:
+ {
+ sal_uInt16 nObjIndex = 0;
+ mpInputStream->ReadUInt16( nObjIndex );
+ SAL_WARN( "emfio", "TODO: W_META_SELECTCLIPREGION is not implemented. Please fill the bug report" );
+ if ( !nObjIndex )
+ {
+ tools::PolyPolygon aEmptyPolyPoly;
+ SetClipPath( aEmptyPolyPoly, RegionMode::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;
+ sal_uInt32 nStringLen, nDXCount;
+ std::vector<sal_Int32> aDXAry;
+ 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() ) )
+ {
+ OUString 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 )
+ aDXAry.resize(nDXCount);
+ for (sal_uInt32 i = 0; i < nDXCount; i++ )
+ {
+ sal_Int32 val;
+ aMemoryStream.ReadInt32( val);
+ aDXAry[ i ] = val;
+ }
+ aMemoryStream.ReadUInt32(mnSkipActions);
+ DrawText( aPt, aString, aDXAry.empty() ? nullptr : &aDXAry );
+ }
+ }
+ }
+ 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("emfio", "emf size claims to be larger than remaining data");
+ mpEMFStream.reset();
+ }
+ else
+ mpEMFStream = std::vector<sal_uInt8>();
+ }
+ 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("emfio", "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->insert(mpEMFStream->end(), aBuf.begin(), aBuf.end());
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ 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_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:
+ {
+ SAL_WARN("emfio", "TODO: WMF record not implemented: " << record_type_name(nFunc));
+ }
+ break;
+
+ default:
+ {
+ SAL_WARN("emfio", "Unknown Meta Action: 0x" << std::hex << nFunc << std::dec);
+ }
+ }
+
+ // tdf#127471
+ maScaledFontHelper.applyAlternativeFontScale();
+ }
+
+ const tools::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;
+
+ mbPlaceable = nPlaceableMetaKey == 0x9ac6cdd7L;
+
+ SAL_INFO("emfio", "Placeable: \"" << (mbPlaceable ? "yes" : "no") << "\"");
+
+ if (mbPlaceable)
+ {
+ //TODO do some real error handling here
+ sal_Int16 nVal(0);
+
+ // Skip reserved bytes
+ mpInputStream->SeekRel(2);
+
+ // BoundRect
+ // These are simply ignored for now
+ 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 );
+
+ // Skip wmf header
+ mpInputStream->Seek( nStrmPos + 40 ); // set the streampos to the start of the metaactions
+ GetPlaceableBound( aPlaceableBound, mpInputStream );
+ // Go back to the place after placeable header
+ mpInputStream->Seek( nStrmPos + 22);
+ }
+ else
+ {
+ // Default is 1440, but it is set to 96 to show the wmf larger
+ mnUnitsPerInch = 96;
+
+ if (mpExternalHeader != nullptr
+ && mpExternalHeader->xExt > 0
+ && mpExternalHeader->yExt > 0
+ && (mpExternalHeader->mapMode == MappingMode::MM_ISOTROPIC || mpExternalHeader->mapMode == MappingMode::MM_ANISOTROPIC))
+ {
+ // #n417818#: If we have an external header then overwrite the bounds!
+ tools::Rectangle aExtRect(0, 0,
+ o3tl::convert(mpExternalHeader->xExt, o3tl::Length::mm100, o3tl::Length::px),
+ o3tl::convert(mpExternalHeader->yExt, o3tl::Length::mm100, o3tl::Length::px));
+ aPlaceableBound = aExtRect;
+
+ SAL_INFO("emfio", "External header size "
+ " left: " << aPlaceableBound.Left() << " top: " << aPlaceableBound.Top()
+ << " right: " << aPlaceableBound.Right() << " bottom: " << aPlaceableBound.Bottom());
+
+ SetMapMode(static_cast<MappingMode>(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
+ if (aPlaceableBound.GetWidth() > aMaxWidth)
+ {
+ const double fMaxWidth = static_cast<double>(aMaxWidth);
+ double fRatio = aPlaceableBound.GetWidth() / fMaxWidth;
+
+ // changing mnUnitsPerInch as a tool to scale wmf
+ mnUnitsPerInch *= fRatio;
+
+ SAL_INFO("emfio", "Placeable bounds "
+ " left: " << aPlaceableBound.Left() << " top: " << aPlaceableBound.Top()
+ << " right: " << aPlaceableBound.Right() << " bottom: " << aPlaceableBound.Bottom());
+ }
+ }
+
+ mpInputStream->Seek( nStrmPos );
+ }
+
+ SetWinOrg( aPlaceableBound.TopLeft() );
+ Size aWMFSize(
+ std::abs( aPlaceableBound.GetWidth() ), std::abs( aPlaceableBound.GetHeight() ) );
+ SetWinExt( aWMFSize );
+
+ SAL_INFO("emfio", "WMF size w: " << aWMFSize.Width() << " h: " << aWMFSize.Height());
+
+ Size aDevExt( 10000, 10000 );
+ if( ( std::abs( aWMFSize.Width() ) > 1 ) && ( std::abs( 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( std::abs( aSize100.Width() ), std::abs( aSize100.Height() ) );
+ }
+ SetDevExt( aDevExt );
+
+ SAL_INFO("emfio", "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( MappingMode::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( !mpInputStream->eof() )
+ {
+ mpInputStream->ReadUInt32(mnRecSize).ReadUInt16( nFunction );
+
+ if (
+ !mpInputStream->good() ||
+ (mnRecSize < 3) ||
+ (mnRecSize == 3 && nFunction == W_META_EOF)
+ )
+ {
+ 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( mnRecSize, nFunction );
+ else
+ mnSkipActions--;
+
+ if(mpEMFStream && mnEMFRecCount == mnEMFRec)
+ {
+ GDIMetaFile aMeta;
+ SvMemoryStream aStream(mpEMFStream->data(), mpEMFStream->size(), StreamMode::STD_READ);
+ std::unique_ptr<EmfReader> pEMFReader(std::make_unique<EmfReader>(aStream, aMeta));
+ pEMFReader->SetEnableEMFPlus(mbEnableEMFPlus);
+ 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;
+
+ MappingMode eMapMode = MappingMode::MM_ANISOTROPIC;
+
+ if (nEnd - nPos)
+ {
+ sal_uInt16 nFunction;
+ sal_uInt32 nRSize;
+
+ while( bRet )
+ {
+ pStm->ReadUInt32( nRSize ).ReadUInt16( nFunction );
+
+ if( pStm->GetError() )
+ {
+ bRet = false;
+ break;
+ }
+ else if (pStm->eof() || nRSize < 3)
+ {
+ pStm->SetError( SVSTREAM_FILEFORMAT_ERROR );
+ bRet = false;
+ break;
+ }
+ else if ( nRSize == 3 && nFunction == W_META_EOF )
+ {
+ break;
+ }
+ switch( nFunction )
+ {
+ case W_META_EOF:
+ {
+ return;
+ }
+
+ 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 :
+ {
+ sal_Int16 nMapMode(0);
+ pStm->ReadInt16( nMapMode );
+ eMapMode = static_cast<MappingMode>(nMapMode);
+ }
+ break;
+
+ case W_META_MOVETO:
+ case W_META_LINETO:
+ {
+ GetWinExtMax( ReadYX(), aBound, eMapMode );
+ bBoundsDetermined = true;
+ }
+ break;
+
+ case W_META_RECTANGLE:
+ case W_META_INTERSECTCLIPRECT:
+ case W_META_EXCLUDECLIPRECT :
+ case W_META_ELLIPSE:
+ {
+ GetWinExtMax( ReadRectangle(), aBound, eMapMode );
+ bBoundsDetermined = true;
+ }
+ break;
+
+ case W_META_ROUNDRECT:
+ {
+ ReadYXExt(); // size
+ GetWinExtMax( ReadRectangle(), aBound, eMapMode );
+ bBoundsDetermined = true;
+ }
+ break;
+
+ case W_META_ARC:
+ case W_META_PIE:
+ case W_META_CHORD:
+ {
+ ReadYX(); // end
+ ReadYX(); // start
+ GetWinExtMax( ReadRectangle(), aBound, eMapMode );
+ 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, eMapMode );
+ bBoundsDetermined = true;
+ }
+ }
+
+ bRecordOk &= pStm->good();
+
+ SAL_WARN_IF(!bRecordOk, "emfio", "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, "emfio", "polypolygon record has more polygons than we can handle");
+
+ 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, eMapMode );
+ bBoundsDetermined = true;
+ }
+ }
+
+ SAL_WARN_IF(!bRecordOk, "emfio", "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, eMapMode );
+ bBoundsDetermined = true;
+ }
+ }
+
+ SAL_WARN_IF(!bRecordOk, "emfio", "polyline 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_SETPIXEL:
+ {
+ ReadColor();
+ GetWinExtMax( ReadYX(), aBound, eMapMode );
+ bBoundsDetermined = true;
+ }
+ break;
+
+ case W_META_TEXTOUT:
+ {
+ sal_uInt16 nLength(0);
+ pStm->ReadUInt16( nLength );
+ // todo: we also have to take care of the text width
+ if ( nLength )
+ {
+ pStm->SeekRel( ( nLength + 1 ) &~ 1 );
+ GetWinExtMax( ReadYX(), aBound, eMapMode );
+ bBoundsDetermined = true;
+ }
+ }
+ break;
+
+ case W_META_EXTTEXTOUT:
+ {
+ sal_uInt16 nLen(0), 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, eMapMode );
+ bBoundsDetermined = true;
+ }
+ }
+ break;
+ case W_META_BITBLT:
+ case W_META_DIBBITBLT:
+ case W_META_DIBSTRETCHBLT:
+ case W_META_STRETCHBLT:
+ case W_META_STRETCHDIB:
+ {
+ sal_uInt32 nRasterOperation;
+ sal_Int16 nYSrc, nXSrc;
+ sal_uInt16 nColorUsage;
+ pStm->ReadUInt32( nRasterOperation );
+
+ if( nFunction == W_META_STRETCHDIB )
+ pStm->ReadUInt16( nColorUsage );
+
+ if( nFunction == W_META_DIBSTRETCHBLT ||
+ nFunction == W_META_STRETCHBLT ||
+ nFunction == W_META_STRETCHDIB )
+ {
+ sal_Int16 nSrcHeight, nSrcWidth;
+ pStm->ReadInt16( nSrcHeight ).ReadInt16( nSrcWidth );
+ }
+
+ // nYSrc and nXSrc is the offset of the first pixel
+ pStm->ReadInt16( nYSrc ).ReadInt16( nXSrc );
+
+ const bool bNoSourceBitmap = ( nFunction != W_META_STRETCHDIB ) && ( nRSize == ( ( static_cast< sal_uInt32 >( nFunction ) >> 8 ) + 3 ) );
+ if ( bNoSourceBitmap )
+ mpInputStream->SeekRel( 2 ); // Skip Reserved 2 bytes (it must be ignored)
+
+ Size aDestSize( ReadYXExt() );
+ if ( aDestSize.Width() && aDestSize.Height() ) // #92623# do not try to read buggy bitmaps
+ {
+ tools::Rectangle aDestRect( ReadYX(), aDestSize );
+ GetWinExtMax( aDestRect, aBound, eMapMode );
+ bBoundsDetermined = true;
+ }
+ }
+ break;
+
+ case W_META_PATBLT:
+ {
+ sal_uInt32 nROP(0);
+ pStm->ReadUInt32( nROP );
+ Size aSize = ReadYXExt();
+ GetWinExtMax( tools::Rectangle( ReadYX(), aSize ), aBound, eMapMode );
+ 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);
+ if (mbPlaceable && eMapMode == MM_ANISOTROPIC)
+ {
+ // It seems that (in MM_ANISOTROPIC WMFs) the "inch" field (PPI) in META_PLACEABLE is
+ // ignored and instead competitor office suites decide what it should be arbitrarily
+ // Could have to do with MM_ANISOTROPICs definition:
+ // Logical units are mapped to arbitrary units with arbitrarily scaled axes.
+ // The issue is that when PPI is bigger than the window size, the image appears
+ // tiny (smaller than an inch squared).
+ // A solution is to scale PPI down in such images to an arbitrary amount that makes
+ // the image visible:
+ auto nWidth = rPlaceableBound.GetWidth();
+ auto nHeight = rPlaceableBound.GetHeight();
+ if (mnUnitsPerInch > nWidth && mnUnitsPerInch > nHeight)
+ mnUnitsPerInch = std::max(nWidth, nHeight);
+ }
+ SAL_INFO("emfio", "Window dimension "
+ " left: " << rPlaceableBound.Left() << " top: " << rPlaceableBound.Top()
+ << " right: " << rPlaceableBound.Right() << " bottom: " << rPlaceableBound.Bottom());
+ }
+ else if (aViewportExt)
+ {
+ rPlaceableBound = tools::Rectangle(aViewportOrg, *aViewportExt);
+ SAL_INFO("emfio", "Viewport dimension "
+ " left: " << rPlaceableBound.Left() << " top: " << rPlaceableBound.Top()
+ << " right: " << rPlaceableBound.Right() << " bottom: " << rPlaceableBound.Bottom());
+ }
+ else if (bBoundsDetermined)
+ {
+ rPlaceableBound = aBound;
+ SAL_INFO("emfio", "Determined dimension "
+ " left: " << rPlaceableBound.Left() << " top: " << rPlaceableBound.Top()
+ << " right: " << rPlaceableBound.Right() << " bottom: " << rPlaceableBound.Bottom());
+ }
+ else
+ {
+ rPlaceableBound.SetLeft( 0 );
+ rPlaceableBound.SetTop( 0 );
+ rPlaceableBound.SetRight( aMaxWidth );
+ rPlaceableBound.SetBottom( aMaxWidth );
+ SAL_INFO("emfio", "Default dimension "
+ " left: " << rPlaceableBound.Left() << " top: " << rPlaceableBound.Top()
+ << " right: " << rPlaceableBound.Right() << " bottom: " << rPlaceableBound.Bottom());
+ }
+ }
+
+ WmfReader::WmfReader(SvStream& rStreamWMF, GDIMetaFile& rGDIMetaFile, const WmfExternal* pExternalHeader)
+ : MtfTools(rGDIMetaFile, rStreamWMF)
+ , mnUnitsPerInch(96)
+ , mnRecSize(0)
+ , mbPlaceable(false)
+ , 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-13 11:49:30 +0000