?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tdf#154285 Check upper bound of arguments in SbRtl_Minute function
[LibreOffice.git] / vcl / source / gdi / mtfxmldump.cxx
blob2fa6052567f77ed38914ff5a1cb03fce4e891491
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 */
9
10 #include <vcl/mtfxmldump.hxx>
11 #include <tools/XmlWriter.hxx>
12 #include <tools/fract.hxx>
13
14 #include <vcl/metaact.hxx>
15 #include <vcl/outdev.hxx>
16 #include <vcl/bitmap.hxx>
17 #include <vcl/BitmapReadAccess.hxx>
18
19 #include <rtl/string.hxx>
20 #include <rtl/ustrbuf.hxx>
21
22 #include <comphelper/hash.hxx>
23
24 #include <sstream>
25
26 namespace
27 {
28
29 OUString collectPushFlags(vcl::PushFlags nFlags)
30 {
31 if ((nFlags & vcl::PushFlags::ALL) == vcl::PushFlags::ALL)
32 return u"PushAll"_ustr;
33 else if ((nFlags & PUSH_ALLFONT) == PUSH_ALLFONT)
34 return u"PushAllFont"_ustr;
35
36 std::vector<std::u16string_view> aStrings;
37
38 if (nFlags & vcl::PushFlags::LINECOLOR)
39 aStrings.emplace_back(u"PushLineColor");
40 if (nFlags & vcl::PushFlags::FILLCOLOR)
41 aStrings.emplace_back(u"PushFillColor");
42 if (nFlags & vcl::PushFlags::FONT)
43 aStrings.emplace_back(u"PushFont");
44 if (nFlags & vcl::PushFlags::TEXTCOLOR)
45 aStrings.emplace_back(u"PushTextColor");
46 if (nFlags & vcl::PushFlags::MAPMODE)
47 aStrings.emplace_back(u"PushMapMode");
48 if (nFlags & vcl::PushFlags::CLIPREGION)
49 aStrings.emplace_back(u"PushClipRegion");
50 if (nFlags & vcl::PushFlags::RASTEROP)
51 aStrings.emplace_back(u"PushRasterOp");
52 if (nFlags & vcl::PushFlags::TEXTFILLCOLOR)
53 aStrings.emplace_back(u"PushTextFillColor");
54 if (nFlags & vcl::PushFlags::TEXTALIGN)
55 aStrings.emplace_back(u"PushTextAlign");
56 if (nFlags & vcl::PushFlags::REFPOINT)
57 aStrings.emplace_back(u"PushRefPoint");
58 if (nFlags & vcl::PushFlags::TEXTLINECOLOR)
59 aStrings.emplace_back(u"PushTextLineColor");
60 if (nFlags & vcl::PushFlags::TEXTLAYOUTMODE)
61 aStrings.emplace_back(u"PushTextLayoutMode");
62 if (nFlags & vcl::PushFlags::TEXTLANGUAGE)
63 aStrings.emplace_back(u"PushTextLanguage");
64 if (nFlags & vcl::PushFlags::OVERLINECOLOR)
65 aStrings.emplace_back(u"PushOverlineColor");
66
67 if (aStrings.empty())
68 return EMPTY_OUSTRING;
69
70 OUStringBuffer aStringBuffer;
71
72 aStringBuffer.append(aStrings[0]);
73 for (size_t i = 1; i < aStrings.size(); ++i)
74 {
75 aStringBuffer.append(u", "_ustr + aStrings[i]);
76 }
77 return aStringBuffer.makeStringAndClear();
78 }
79
80 OUString convertDrawTextFlagsToString(DrawTextFlags eDrawTextFlags)
81 {
82 std::vector<std::u16string_view> aStrings;
83 if (eDrawTextFlags & DrawTextFlags::Disable)
84 aStrings.emplace_back(u"Disable");
85 if (eDrawTextFlags & DrawTextFlags::Mnemonic)
86 aStrings.emplace_back(u"Mnemonic");
87 if (eDrawTextFlags & DrawTextFlags::Mono)
88 aStrings.emplace_back(u"Mono");
89 if (eDrawTextFlags & DrawTextFlags::Clip)
90 aStrings.emplace_back(u"Clip");
91 if (eDrawTextFlags & DrawTextFlags::Left)
92 aStrings.emplace_back(u"Left");
93 if (eDrawTextFlags & DrawTextFlags::Center)
94 aStrings.emplace_back(u"Center");
95 if (eDrawTextFlags & DrawTextFlags::Right)
96 aStrings.emplace_back(u"Right");
97 if (eDrawTextFlags & DrawTextFlags::Top)
98 aStrings.emplace_back(u"Top");
99 if (eDrawTextFlags & DrawTextFlags::VCenter)
100 aStrings.emplace_back(u"VCenter");
101 if (eDrawTextFlags & DrawTextFlags::Bottom)
102 aStrings.emplace_back(u"Bottom");
103 if (eDrawTextFlags & DrawTextFlags::EndEllipsis)
104 aStrings.emplace_back(u"EndEllipsis");
105 if (eDrawTextFlags & DrawTextFlags::PathEllipsis)
106 aStrings.emplace_back(u"PathEllipsis");
107 if (eDrawTextFlags & DrawTextFlags::MultiLine)
108 aStrings.emplace_back(u"MultiLine");
109 if (eDrawTextFlags & DrawTextFlags::WordBreak)
110 aStrings.emplace_back(u"WordBreak");
111 if (eDrawTextFlags & DrawTextFlags::NewsEllipsis)
112 aStrings.emplace_back(u"NewsEllipsis");
113 if (eDrawTextFlags & DrawTextFlags::WordBreakHyphenation)
114 aStrings.emplace_back(u"WordBreakHyphenation");
115 if (eDrawTextFlags & DrawTextFlags::CenterEllipsis)
116 aStrings.emplace_back(u"CenterEllipsis");
117
118 if (aStrings.empty())
119 return u"None"_ustr;
120
121 OUStringBuffer aStringBuffer;
122
123 aStringBuffer.append(aStrings[0]);
124 for (size_t i = 1; i < aStrings.size(); ++i)
125 {
126 aStringBuffer.append(u" "_ustr + aStrings[i]);
127 }
128 return aStringBuffer.makeStringAndClear();
129 };
130
131 OUString convertRopToString(RasterOp eRop)
132 {
133 switch (eRop)
134 {
135 case RasterOp::OverPaint: return u"overpaint"_ustr;
136 case RasterOp::Xor: return u"xor"_ustr;
137 case RasterOp::N0: return u"0"_ustr;
138 case RasterOp::N1: return u"1"_ustr;
139 case RasterOp::Invert: return u"invert"_ustr;
140 }
141 return OUString();
142 }
143
144 OUString convertTextAlignToString(TextAlign eAlign)
145 {
146 switch (eAlign)
147 {
148 case ALIGN_BASELINE: return u"baseline"_ustr;
149 case ALIGN_BOTTOM: return u"bottom"_ustr;
150 case ALIGN_TOP: return u"top"_ustr;
151 case TextAlign_FORCE_EQUAL_SIZE: return u"equalsize"_ustr;
152 }
153 return OUString();
154 }
155
156 OUString convertColorToString(Color aColor)
157 {
158 OUString aRGBString = aColor.AsRGBHexString();
159 return "#" + aRGBString;
160 }
161
162 OUString convertLineStyleToString(LineStyle eAlign)
163 {
164 switch (eAlign)
165 {
166 case LineStyle::NONE: return u"none"_ustr;
167 case LineStyle::Solid: return u"solid"_ustr;
168 case LineStyle::Dash: return u"dash"_ustr;
169 default: break;
170 }
171 return OUString();
172 }
173
174 OUString convertLineJoinToString(basegfx::B2DLineJoin eJoin)
175 {
176 switch (eJoin)
177 {
178 default:
179 case basegfx::B2DLineJoin::NONE: return u"none"_ustr;
180 case basegfx::B2DLineJoin::Bevel: return u"bevel"_ustr;
181 case basegfx::B2DLineJoin::Miter: return u"miter"_ustr;
182 case basegfx::B2DLineJoin::Round: return u"round"_ustr;
183 }
184 }
185
186 OUString convertLineCapToString(css::drawing::LineCap eCap)
187 {
188 switch (eCap)
189 {
190 default:
191 case css::drawing::LineCap_BUTT: return u"butt"_ustr;
192 case css::drawing::LineCap_ROUND: return u"round"_ustr;
193 case css::drawing::LineCap_SQUARE: return u"square"_ustr;
194 }
195 }
196
197 OUString convertPolygonFlags(PolyFlags eFlags)
198 {
199 switch (eFlags)
200 {
201 default:
202 case PolyFlags::Normal: return u"normal"_ustr;
203 case PolyFlags::Control: return u"control"_ustr;
204 case PolyFlags::Smooth: return u"smooth"_ustr;
205 case PolyFlags::Symmetric: return u"symmetric"_ustr;
206 }
207 }
208
209 OUString convertFontWeightToString(FontWeight eFontWeight)
210 {
211 switch (eFontWeight)
212 {
213 case WEIGHT_DONTKNOW: return u"unknown"_ustr;
214 case WEIGHT_THIN: return u"thin"_ustr;
215 case WEIGHT_ULTRALIGHT: return u"ultralight"_ustr;
216 case WEIGHT_LIGHT: return u"light"_ustr;
217 case WEIGHT_SEMILIGHT: return u"semilight"_ustr;
218 case WEIGHT_NORMAL: return u"normal"_ustr;
219 case WEIGHT_MEDIUM: return u"medium"_ustr;
220 case WEIGHT_SEMIBOLD: return u"semibold"_ustr;
221 case WEIGHT_BOLD: return u"bold"_ustr;
222 case WEIGHT_ULTRABOLD: return u"ultrabold"_ustr;
223 case WEIGHT_BLACK: return u"black"_ustr;
224 case FontWeight_FORCE_EQUAL_SIZE: return u"equalsize"_ustr;
225 }
226 return OUString();
227 }
228
229 OUString convertFontStrikeoutToString(FontStrikeout eFontStrikeout)
230 {
231 switch (eFontStrikeout)
232 {
233 case STRIKEOUT_NONE: return u"none"_ustr;
234 case STRIKEOUT_SINGLE: return u"single"_ustr;
235 case STRIKEOUT_DOUBLE: return u"double"_ustr;
236 case STRIKEOUT_DONTKNOW: return u"dontknow"_ustr;
237 case STRIKEOUT_BOLD: return u"bold"_ustr;
238 case STRIKEOUT_SLASH: return u"slash"_ustr;
239 case STRIKEOUT_X: return u"x"_ustr;
240 case FontStrikeout_FORCE_EQUAL_SIZE: return u"equalsize"_ustr;
241 }
242 return OUString();
243 }
244
245 OUString convertFontLineStyleToString(FontLineStyle eFontLineStyle)
246 {
247 switch (eFontLineStyle)
248 {
249 case LINESTYLE_NONE: return u"none"_ustr;
250 case LINESTYLE_SINGLE: return u"single"_ustr;
251 case LINESTYLE_DOUBLE: return u"double"_ustr;
252 case LINESTYLE_DOTTED: return u"dotted"_ustr;
253 case LINESTYLE_DONTKNOW: return u"dontknow"_ustr;
254 case LINESTYLE_DASH: return u"dash"_ustr;
255 case LINESTYLE_LONGDASH: return u"longdash"_ustr;
256 case LINESTYLE_DASHDOT: return u"dashdot"_ustr;
257 case LINESTYLE_DASHDOTDOT: return u"dashdotdot"_ustr;
258 case LINESTYLE_SMALLWAVE: return u"smallwave"_ustr;
259 case LINESTYLE_WAVE: return u"wave"_ustr;
260 case LINESTYLE_DOUBLEWAVE: return u"doublewave"_ustr;
261 case LINESTYLE_BOLD: return u"bold"_ustr;
262 case LINESTYLE_BOLDDOTTED: return u"bolddotted"_ustr;
263 case LINESTYLE_BOLDDASH: return u"bolddash"_ustr;
264 case LINESTYLE_BOLDLONGDASH: return u"boldlongdash"_ustr;
265 case LINESTYLE_BOLDDASHDOT: return u"bolddashdot"_ustr;
266 case LINESTYLE_BOLDDASHDOTDOT: return u"bolddashdotdot"_ustr;
267 case LINESTYLE_BOLDWAVE: return u"boldwave"_ustr;
268 case FontLineStyle_FORCE_EQUAL_SIZE: return u"equalsize"_ustr;
269 }
270 return OUString();
271 }
272
273 OString convertLineStyleToString(const MetaActionType nActionType)
274 {
275 switch (nActionType)
276 {
277 case MetaActionType::NONE: return "null"_ostr;
278 case MetaActionType::PIXEL: return "pixel"_ostr;
279 case MetaActionType::POINT: return "point"_ostr;
280 case MetaActionType::LINE: return "line"_ostr;
281 case MetaActionType::RECT: return "rect"_ostr;
282 case MetaActionType::ROUNDRECT: return "roundrect"_ostr;
283 case MetaActionType::ELLIPSE: return "ellipse"_ostr;
284 case MetaActionType::ARC: return "arc"_ostr;
285 case MetaActionType::PIE: return "pie"_ostr;
286 case MetaActionType::CHORD: return "chord"_ostr;
287 case MetaActionType::POLYLINE: return "polyline"_ostr;
288 case MetaActionType::POLYGON: return "polygon"_ostr;
289 case MetaActionType::POLYPOLYGON: return "polypolygon"_ostr;
290 case MetaActionType::TEXT: return "text"_ostr;
291 case MetaActionType::TEXTARRAY: return "textarray"_ostr;
292 case MetaActionType::STRETCHTEXT: return "stretchtext"_ostr;
293 case MetaActionType::TEXTRECT: return "textrect"_ostr;
294 case MetaActionType::TEXTLINE: return "textline"_ostr;
295 case MetaActionType::BMP: return "bmp"_ostr;
296 case MetaActionType::BMPSCALE: return "bmpscale"_ostr;
297 case MetaActionType::BMPSCALEPART: return "bmpscalepart"_ostr;
298 case MetaActionType::BMPEX: return "bmpex"_ostr;
299 case MetaActionType::BMPEXSCALE: return "bmpexscale"_ostr;
300 case MetaActionType::BMPEXSCALEPART: return "bmpexscalepart"_ostr;
301 case MetaActionType::MASK: return "mask"_ostr;
302 case MetaActionType::MASKSCALE: return "maskscale"_ostr;
303 case MetaActionType::MASKSCALEPART: return "maskscalepart"_ostr;
304 case MetaActionType::GRADIENT: return "gradient"_ostr;
305 case MetaActionType::GRADIENTEX: return "gradientex"_ostr;
306 case MetaActionType::HATCH: return "hatch"_ostr;
307 case MetaActionType::WALLPAPER: return "wallpaper"_ostr;
308 case MetaActionType::CLIPREGION: return "clipregion"_ostr;
309 case MetaActionType::ISECTRECTCLIPREGION: return "sectrectclipregion"_ostr;
310 case MetaActionType::ISECTREGIONCLIPREGION: return "sectregionclipregion"_ostr;
311 case MetaActionType::MOVECLIPREGION: return "moveclipregion"_ostr;
312 case MetaActionType::LINECOLOR: return "linecolor"_ostr;
313 case MetaActionType::FILLCOLOR: return "fillcolor"_ostr;
314 case MetaActionType::TEXTCOLOR: return "textcolor"_ostr;
315 case MetaActionType::TEXTFILLCOLOR: return "textfillcolor"_ostr;
316 case MetaActionType::TEXTLINECOLOR: return "textlinecolor"_ostr;
317 case MetaActionType::OVERLINECOLOR: return "overlinecolor"_ostr;
318 case MetaActionType::TEXTALIGN: return "textalign"_ostr;
319 case MetaActionType::MAPMODE: return "mapmode"_ostr;
320 case MetaActionType::FONT: return "font"_ostr;
321 case MetaActionType::PUSH: return "push"_ostr;
322 case MetaActionType::POP: return "pop"_ostr;
323 case MetaActionType::RASTEROP: return "rasterop"_ostr;
324 case MetaActionType::Transparent: return "transparent"_ostr;
325 case MetaActionType::FLOATTRANSPARENT: return "floattransparent"_ostr;
326 case MetaActionType::EPS: return "eps"_ostr;
327 case MetaActionType::REFPOINT: return "refpoint"_ostr;
328 case MetaActionType::COMMENT: return "comment"_ostr;
329 case MetaActionType::LAYOUTMODE: return "layoutmode"_ostr;
330 case MetaActionType::TEXTLANGUAGE: return "textlanguage"_ostr;
331 }
332 return ""_ostr;
333 }
334
335 OUString convertBitmapExTransparentType(BitmapEx const & rBitmapEx)
336 {
337 if (rBitmapEx.IsAlpha())
338 return u"bitmap"_ustr;
339 else
340 return u"none"_ustr;
341 }
342
343 OUString convertMapUnitToString(MapUnit eUnit)
344 {
345 switch (eUnit)
346 {
347 default:
348 case MapUnit::LASTENUMDUMMY: return u"LASTENUMDUMMY"_ustr;
349 case MapUnit::Map1000thInch: return u"Map1000thInch"_ustr;
350 case MapUnit::Map100thInch: return u"Map100thInch"_ustr;
351 case MapUnit::Map100thMM: return u"Map100thMM"_ustr;
352 case MapUnit::Map10thInch: return u"Map10thInch"_ustr;
353 case MapUnit::Map10thMM: return u"Map10thMM"_ustr;
354 case MapUnit::MapAppFont: return u"MapAppFont"_ustr;
355 case MapUnit::MapCM: return u"MapCM"_ustr;
356 case MapUnit::MapInch: return u"MapInch"_ustr;
357 case MapUnit::MapMM: return u"MapMM"_ustr;
358 case MapUnit::MapPixel: return u"MapPixel"_ustr;
359 case MapUnit::MapPoint: return u"MapPoint"_ustr;
360 case MapUnit::MapRelative: return u"MapRelative"_ustr;
361 case MapUnit::MapSysFont: return u"MapSysFont"_ustr;
362 case MapUnit::MapTwip: return u"MapTwip"_ustr;
363 }
364 }
365
366 OUString convertFractionToString(const Fraction& aFraction)
367 {
368 std::stringstream ss;
369
370 ss << aFraction;
371
372 return OUString::createFromAscii(ss.str());
373 }
374
375 OUString convertGradientStyleToOUString(css::awt::GradientStyle eStyle)
376 {
377 switch (eStyle)
378 {
379 case css::awt::GradientStyle_LINEAR: return u"Linear"_ustr;
380 case css::awt::GradientStyle_AXIAL: return u"Axial"_ustr;
381 case css::awt::GradientStyle_RADIAL: return u"Radial"_ustr;
382 case css::awt::GradientStyle_ELLIPTICAL: return u"Elliptical"_ustr;
383 case css::awt::GradientStyle_SQUARE: return u"Square"_ustr;
384 case css::awt::GradientStyle_RECT: return u"Rect"_ustr;
385 case css::awt::GradientStyle::GradientStyle_MAKE_FIXED_SIZE: return u"ForceEqualSize"_ustr;
386 }
387 return OUString();
388 }
389
390 OUString convertHatchStyle(HatchStyle eStyle)
391 {
392 switch (eStyle)
393 {
394 case HatchStyle::Single: return u"Single"_ustr;
395 case HatchStyle::Double: return u"Double"_ustr;
396 case HatchStyle::Triple: return u"Triple"_ustr;
397 case HatchStyle::FORCE_EQUAL_SIZE: return u"ForceEqualSize"_ustr;
398 }
399 return OUString();
400 }
401
402 OUString convertLanguageTypeToString(LanguageType rLanguageType)
403 {
404 std::stringstream ss;
405 ss << std::hex << std::setfill ('0') << std::setw(4) << rLanguageType.get();
406 return "#" + OUString::createFromAscii(ss.str());
407 }
408
409 OUString convertWallpaperStyleToString(WallpaperStyle eWallpaperStyle)
410 {
411 switch (eWallpaperStyle)
412 {
413 case WallpaperStyle::NONE: return u"NONE"_ustr;
414 case WallpaperStyle::Tile: return u"Tile"_ustr;
415 case WallpaperStyle::Center: return u"Center"_ustr;
416 case WallpaperStyle::Scale: return u"Scale"_ustr;
417 case WallpaperStyle::TopLeft: return u"TopLeft"_ustr;
418 case WallpaperStyle::Top: return u"Top"_ustr;
419 case WallpaperStyle::TopRight: return u"TopRight"_ustr;
420 case WallpaperStyle::Left: return u"Left"_ustr;
421 case WallpaperStyle::Right: return u"Right"_ustr;
422 case WallpaperStyle::BottomLeft: return u"BottomLeft"_ustr;
423 case WallpaperStyle::Bottom: return u"Bottom"_ustr;
424 case WallpaperStyle::BottomRight: return u"BottomRight"_ustr;
425 case WallpaperStyle::ApplicationGradient: return u"ApplicationGradient"_ustr;
426 }
427 return OUString();
428 }
429
430 OUString convertPixelFormatToString(vcl::PixelFormat ePixelFormat)
431 {
432 switch (ePixelFormat)
433 {
434 case vcl::PixelFormat::INVALID: return u"INVALID"_ustr;
435 case vcl::PixelFormat::N8_BPP: return u"8BPP"_ustr;
436 case vcl::PixelFormat::N24_BPP: return u"24BPP"_ustr;
437 case vcl::PixelFormat::N32_BPP: return u"32BPP"_ustr;
438 }
439 return OUString();
440 }
441
442 OUString convertComplexTestLayoutFlags(vcl::text::ComplexTextLayoutFlags nFlags)
443 {
444 if (nFlags == vcl::text::ComplexTextLayoutFlags::Default)
445 return u"Default"_ustr;
446
447 std::vector<std::u16string_view> aStrings;
448
449 if (nFlags & vcl::text::ComplexTextLayoutFlags::BiDiRtl)
450 aStrings.emplace_back(u"BiDiRtl");
451 if (nFlags & vcl::text::ComplexTextLayoutFlags::BiDiStrong)
452 aStrings.emplace_back(u"BiDiStrong");
453 if (nFlags & vcl::text::ComplexTextLayoutFlags::TextOriginLeft)
454 aStrings.emplace_back(u"TextOriginLeft");
455 if (nFlags & vcl::text::ComplexTextLayoutFlags::TextOriginRight)
456 aStrings.emplace_back(u"TextOriginRight");
457
458 if (aStrings.empty())
459 return EMPTY_OUSTRING;
460
461 OUStringBuffer aStringBuffer;
462
463 aStringBuffer.append(aStrings[0]);
464 for (size_t i = 1; i < aStrings.size(); ++i)
465 {
466 aStringBuffer.append(u", "_ustr + aStrings[i]);
467 }
468 return aStringBuffer.makeStringAndClear();
469 }
470
471 OUString convertGfxLinkTypeToString(GfxLinkType eGfxLinkType)
472 {
473 switch(eGfxLinkType)
474 {
475 case GfxLinkType::EpsBuffer: return u"EpsBuffer"_ustr;
476 case GfxLinkType::NativeBmp: return u"NativeBmp"_ustr;
477 case GfxLinkType::NativeGif: return u"NativeGif"_ustr;
478 case GfxLinkType::NativeJpg: return u"NativeJpg"_ustr;
479 case GfxLinkType::NativeMet: return u"NativeMet"_ustr;
480 case GfxLinkType::NativeMov: return u"NativeMov"_ustr;
481 case GfxLinkType::NativePct: return u"NativePct"_ustr;
482 case GfxLinkType::NativePdf: return u"NativePdf"_ustr;
483 case GfxLinkType::NativePng: return u"NativePng"_ustr;
484 case GfxLinkType::NativeSvg: return u"NativeSvg"_ustr;
485 case GfxLinkType::NativeTif: return u"NativeTif"_ustr;
486 case GfxLinkType::NativeWmf: return u"NativeWmf"_ustr;
487 case GfxLinkType::NativeWebp: return u"NativeWebp"_ustr;
488 case GfxLinkType::NONE: return u"None"_ustr;
489 }
490 return OUString();
491 }
492
493 OUString hex32(sal_uInt32 nNumber)
494 {
495 std::stringstream ss;
496 ss << std::hex << std::setfill('0') << std::setw(8) << nNumber;
497 return OUString::createFromAscii(ss.str());
498 }
499
500 OUString toHexString(const sal_uInt8* nData, sal_uInt32 nDataSize){
501
502 std::stringstream aStrm;
503 for (sal_uInt32 i = 0; i < nDataSize; i++)
504 {
505 aStrm << std::setw(2) << std::setfill('0') << std::hex << static_cast<int>(nData[i]);
506 }
507
508 return OUString::createFromAscii(aStrm.str());
509 }
510
511 void writePoint(tools::XmlWriter& rWriter, Point const& rPoint)
512 {
513 rWriter.attribute("x", rPoint.X());
514 rWriter.attribute("y", rPoint.Y());
515 }
516
517 void writeStartPoint(tools::XmlWriter& rWriter, Point const& rPoint)
518 {
519 rWriter.attribute("startx", rPoint.X());
520 rWriter.attribute("starty", rPoint.Y());
521 }
522
523 void writeEndPoint(tools::XmlWriter& rWriter, Point const& rPoint)
524 {
525 rWriter.attribute("endx", rPoint.X());
526 rWriter.attribute("endy", rPoint.Y());
527 }
528
529 void writeSize(tools::XmlWriter& rWriter, Size const& rSize)
530 {
531 rWriter.attribute("width", rSize.Width());
532 rWriter.attribute("height", rSize.Height());
533 }
534
535 void writeRectangle(tools::XmlWriter& rWriter, tools::Rectangle const& rRectangle)
536 {
537 rWriter.attribute("left", rRectangle.Left());
538 rWriter.attribute("top", rRectangle.Top());
539 if (rRectangle.IsWidthEmpty())
540 rWriter.attribute("right", "empty"_ostr);
541 else
542 rWriter.attribute("right", rRectangle.Right());
543 if (rRectangle.IsHeightEmpty())
544 rWriter.attribute("bottom", "empty"_ostr);
545 else
546 rWriter.attribute("bottom", rRectangle.Bottom());
547 }
548
549 void writeMapMode(tools::XmlWriter& rWriter, MapMode const& rMapMode)
550 {
551 rWriter.attribute("mapunit", convertMapUnitToString( rMapMode.GetMapUnit() ));
552 writePoint(rWriter, rMapMode.GetOrigin());
553 rWriter.attribute("scalex", convertFractionToString(rMapMode.GetScaleX()));
554 rWriter.attribute("scaley", convertFractionToString(rMapMode.GetScaleY()));
555 }
556
557 void writeLineInfo(tools::XmlWriter& rWriter, LineInfo const& rLineInfo)
558 {
559 rWriter.attribute("style", convertLineStyleToString(rLineInfo.GetStyle()));
560 rWriter.attribute("width", rLineInfo.GetWidth());
561 rWriter.attribute("dashlen", rLineInfo.GetDashLen());
562 rWriter.attribute("dashcount", rLineInfo.GetDashCount());
563 rWriter.attribute("dotlen", rLineInfo.GetDotLen());
564 rWriter.attribute("dotcount", rLineInfo.GetDotCount());
565 rWriter.attribute("distance", rLineInfo.GetDistance());
566 rWriter.attribute("join", convertLineJoinToString(rLineInfo.GetLineJoin()));
567 rWriter.attribute("cap", convertLineCapToString(rLineInfo.GetLineCap()));
568 }
569
570 void writeGradient(tools::XmlWriter& rWriter, Gradient const& rGradient)
571 {
572 rWriter.attribute("style", convertGradientStyleToOUString(rGradient.GetStyle()));
573 rWriter.attribute("startcolor", convertColorToString(rGradient.GetStartColor()));
574 rWriter.attribute("endcolor", convertColorToString(rGradient.GetEndColor()));
575 rWriter.attribute("angle", rGradient.GetAngle().get());
576 rWriter.attribute("border", rGradient.GetBorder());
577 rWriter.attribute("offsetx", rGradient.GetOfsX());
578 rWriter.attribute("offsety", rGradient.GetOfsY());
579 rWriter.attribute("startintensity", rGradient.GetStartIntensity());
580 rWriter.attribute("endintensity", rGradient.GetEndIntensity());
581 rWriter.attribute("steps", rGradient.GetSteps());
582 }
583
584 OString toHexString(const std::vector<unsigned char>& a)
585 {
586 std::stringstream aStrm;
587 for (auto& i : a)
588 {
589 aStrm << std::setw(2) << std::setfill('0') << std::hex << static_cast<int>(i);
590 }
591
592 return OString(aStrm.str());
593 }
594
595 void writeBitmapContentChecksum(tools::XmlWriter& rWriter, Bitmap const& rBitmap)
596 {
597 const Bitmap& aBitmap(rBitmap);
598
599 comphelper::Hash aHashEngine(comphelper::HashType::SHA1);
600 BitmapScopedReadAccess pReadAccess(aBitmap);
601 assert(pReadAccess);
602
603 for (tools::Long y = 0 ; y < pReadAccess->Height() ; ++y)
604 {
605 for (tools::Long x = 0 ; x < pReadAccess->Width() ; ++x)
606 {
607 BitmapColor aColor = pReadAccess->GetColor(y, x);
608 sal_uInt8 r = aColor.GetRed();
609 sal_uInt8 g = aColor.GetGreen();
610 sal_uInt8 b = aColor.GetBlue();
611 sal_uInt8 a = aColor.GetAlpha();
612 aHashEngine.update(&r, 1);
613 aHashEngine.update(&g, 1);
614 aHashEngine.update(&b, 1);
615 aHashEngine.update(&a, 1);
616 }
617 }
618 std::vector<unsigned char> aVector = aHashEngine.finalize();
619 rWriter.attribute("contentchecksum", toHexString(aVector));
620 }
621
622 void writeBitmap(tools::XmlWriter& rWriter, Bitmap const& rBitmap)
623 {
624 writeBitmapContentChecksum(rWriter, rBitmap);
625 rWriter.attribute("bitmapwidth", rBitmap.GetSizePixel().Width());
626 rWriter.attribute("bitmapheight", rBitmap.GetSizePixel().Height());
627 rWriter.attribute("pixelformat", convertPixelFormatToString(rBitmap.getPixelFormat()));
628 rWriter.attribute("crc", hex32(rBitmap.GetChecksum()));
629 }
630
631 } // anonymous namespace
632
633 MetafileXmlDump::MetafileXmlDump()
634 {
635 maFilter.fill(false);
636 }
637
638 void MetafileXmlDump::filterActionType(const MetaActionType nActionType, bool bShouldFilter)
639 {
640 maFilter[nActionType] = bShouldFilter;
641 }
642
643 void MetafileXmlDump::filterAllActionTypes()
644 {
645 maFilter.fill(true);
646 }
647
648 void MetafileXmlDump::dump(const GDIMetaFile& rMetaFile, SvStream& rStream)
649 {
650 tools::XmlWriter aWriter(&rStream);
651 aWriter.startDocument();
652 aWriter.startElement("metafile");
653
654 writeXml(rMetaFile, aWriter);
655
656 aWriter.endElement();
657 aWriter.endDocument();
658 }
659
660 void MetafileXmlDump::writeXml(const GDIMetaFile& rMetaFile, tools::XmlWriter& rWriter)
661 {
662 const MapMode& aMtfMapMode = rMetaFile.GetPrefMapMode();
663 rWriter.attribute("mapunit", convertMapUnitToString(aMtfMapMode.GetMapUnit()));
664 writePoint(rWriter, aMtfMapMode.GetOrigin());
665 rWriter.attribute("scalex", convertFractionToString(aMtfMapMode.GetScaleX()));
666 rWriter.attribute("scaley", convertFractionToString(aMtfMapMode.GetScaleY()));
667
668 Size aMtfSize = rMetaFile.GetPrefSize();
669 writeSize(rWriter, aMtfSize);
670
671 for(size_t nAction = 0; nAction < rMetaFile.GetActionSize(); ++nAction)
672 {
673 MetaAction* pAction = rMetaFile.GetAction(nAction);
674 const MetaActionType nActionType = pAction->GetType();
675 if (maFilter[nActionType])
676 continue;
677
678 OString sCurrentElementTag = convertLineStyleToString(nActionType);
679
680 switch (nActionType)
681 {
682 case MetaActionType::NONE:
683 {
684 rWriter.startElement(sCurrentElementTag);
685 rWriter.endElement();
686 }
687 break;
688
689 case MetaActionType::PIXEL:
690 {
691 auto* pMetaAction = static_cast<MetaPixelAction*>(pAction);
692 rWriter.startElement(sCurrentElementTag);
693 writePoint(rWriter, pMetaAction->GetPoint());
694 rWriter.attribute("color", convertColorToString(pMetaAction->GetColor()));
695 rWriter.endElement();
696 }
697 break;
698
699 case MetaActionType::POINT:
700 {
701 auto* pMetaAction = static_cast<MetaPointAction*>(pAction);
702 rWriter.startElement(sCurrentElementTag);
703 writePoint(rWriter, pMetaAction->GetPoint());
704 rWriter.endElement();
705 }
706 break;
707
708 case MetaActionType::LINE:
709 {
710 MetaLineAction* pMetaLineAction = static_cast<MetaLineAction*>(pAction);
711 rWriter.startElement(sCurrentElementTag);
712 writeStartPoint(rWriter, pMetaLineAction->GetStartPoint());
713 writeEndPoint(rWriter, pMetaLineAction->GetEndPoint());
714
715 writeLineInfo(rWriter, pMetaLineAction->GetLineInfo());
716 rWriter.endElement();
717 }
718 break;
719
720 case MetaActionType::RECT:
721 {
722 MetaRectAction* pMetaAction = static_cast<MetaRectAction*>(pAction);
723 rWriter.startElement(sCurrentElementTag);
724 writeRectangle(rWriter, pMetaAction->GetRect());
725 rWriter.endElement();
726 }
727 break;
728
729 case MetaActionType::ROUNDRECT:
730 {
731 auto pMetaAction = static_cast<MetaRoundRectAction*>(pAction);
732 rWriter.startElement(sCurrentElementTag);
733 writeRectangle(rWriter, pMetaAction->GetRect());
734 rWriter.attribute("horizontalround", pMetaAction->GetHorzRound());
735 rWriter.attribute("verticalround", pMetaAction->GetVertRound());
736 rWriter.endElement();
737 }
738 break;
739
740 case MetaActionType::ELLIPSE:
741 {
742 auto pMetaAction = static_cast<MetaEllipseAction*>(pAction);
743 rWriter.startElement(sCurrentElementTag);
744 writeRectangle(rWriter, pMetaAction->GetRect());
745 rWriter.endElement();
746 }
747 break;
748
749 case MetaActionType::ARC:
750 {
751 auto pMetaAction = static_cast<MetaArcAction*>(pAction);
752 rWriter.startElement(sCurrentElementTag);
753 writeRectangle(rWriter, pMetaAction->GetRect());
754 writeStartPoint(rWriter, pMetaAction->GetStartPoint());
755 writeEndPoint(rWriter, pMetaAction->GetEndPoint());
756 rWriter.endElement();
757 }
758 break;
759
760 case MetaActionType::PIE:
761 {
762 auto pMetaAction = static_cast<MetaPieAction*>(pAction);
763 rWriter.startElement(sCurrentElementTag);
764 writeRectangle(rWriter, pMetaAction->GetRect());
765 writeStartPoint(rWriter, pMetaAction->GetStartPoint());
766 writeEndPoint(rWriter, pMetaAction->GetEndPoint());
767 rWriter.endElement();
768 }
769 break;
770
771 case MetaActionType::CHORD:
772 {
773 auto pMetaAction = static_cast<MetaChordAction*>(pAction);
774 rWriter.startElement(sCurrentElementTag);
775 writeRectangle(rWriter, pMetaAction->GetRect());
776 writeStartPoint(rWriter, pMetaAction->GetStartPoint());
777 writeEndPoint(rWriter, pMetaAction->GetEndPoint());
778 rWriter.endElement();
779 }
780 break;
781
782 case MetaActionType::POLYLINE:
783 {
784 MetaPolyLineAction* pMetaPolyLineAction = static_cast<MetaPolyLineAction*>(pAction);
785 rWriter.startElement(sCurrentElementTag);
786
787 writeLineInfo(rWriter, pMetaPolyLineAction->GetLineInfo());
788
789 tools::Polygon aPolygon = pMetaPolyLineAction->GetPolygon();
790 bool bFlags = aPolygon.HasFlags();
791 for (sal_uInt16 i = 0; i < aPolygon.GetSize(); i++)
792 {
793 rWriter.startElement("point");
794 writePoint(rWriter, aPolygon[i]);
795 if (bFlags)
796 rWriter.attribute("flags", convertPolygonFlags(aPolygon.GetFlags(i)));
797 rWriter.endElement();
798 }
799
800 rWriter.endElement();
801 }
802 break;
803
804 case MetaActionType::POLYGON:
805 {
806 MetaPolygonAction* pMetaPolygonAction = static_cast<MetaPolygonAction*>(pAction);
807 rWriter.startElement(sCurrentElementTag);
808
809 tools::Polygon aPolygon = pMetaPolygonAction->GetPolygon();
810 bool bFlags = aPolygon.HasFlags();
811 for (sal_uInt16 i = 0; i < aPolygon.GetSize(); i++)
812 {
813 rWriter.startElement("point");
814 writePoint(rWriter, aPolygon[i]);
815 if (bFlags)
816 rWriter.attribute("flags", convertPolygonFlags(aPolygon.GetFlags(i)));
817 rWriter.endElement();
818 }
819
820 rWriter.endElement();
821 }
822 break;
823
824 case MetaActionType::POLYPOLYGON:
825 {
826 MetaPolyPolygonAction *const pMetaPolyPolygonAction = static_cast<MetaPolyPolygonAction*>(pAction);
827 rWriter.startElement(sCurrentElementTag);
828
829 tools::PolyPolygon const& rPolyPolygon(pMetaPolyPolygonAction->GetPolyPolygon());
830
831 for (sal_uInt16 j = 0; j < rPolyPolygon.Count(); ++j)
832 {
833 rWriter.startElement("polygon");
834 tools::Polygon const& rPolygon = rPolyPolygon[j];
835 bool bFlags = rPolygon.HasFlags();
836 for (sal_uInt16 i = 0; i < rPolygon.GetSize(); ++i)
837 {
838 rWriter.startElement("point");
839 writePoint(rWriter, rPolygon[i]);
840 if (bFlags)
841 rWriter.attribute("flags", convertPolygonFlags(rPolygon.GetFlags(i)));
842 rWriter.endElement();
843 }
844 rWriter.endElement();
845 }
846 rWriter.endElement();
847 }
848 break;
849
850 case MetaActionType::TEXT:
851 {
852 auto* pMeta = static_cast<MetaTextAction*>(pAction);
853 rWriter.startElement(sCurrentElementTag);
854 writePoint(rWriter, pMeta->GetPoint());
855 rWriter.attribute("index", pMeta->GetIndex());
856 rWriter.attribute("length", pMeta->GetLen());
857 rWriter.startElement("textcontent");
858 rWriter.content(pMeta->GetText());
859 rWriter.endElement();
860
861 rWriter.endElement();
862 }
863 break;
864
865 case MetaActionType::TEXTARRAY:
866 {
867 MetaTextArrayAction* pMetaTextArrayAction = static_cast<MetaTextArrayAction*>(pAction);
868 rWriter.startElement(sCurrentElementTag);
869
870 sal_Int32 aIndex = pMetaTextArrayAction->GetIndex();
871 sal_Int32 aLength = pMetaTextArrayAction->GetLen();
872
873 writePoint(rWriter, pMetaTextArrayAction->GetPoint());
874 rWriter.attribute("index", aIndex);
875 rWriter.attribute("length", aLength);
876
877 if (pMetaTextArrayAction->GetLayoutContextIndex() >= 0)
878 {
879 rWriter.attribute("layoutcontextindex",
880 pMetaTextArrayAction->GetLayoutContextIndex());
881 rWriter.attribute("layoutcontextlength",
882 pMetaTextArrayAction->GetLayoutContextLen());
883 }
884
885 if (!pMetaTextArrayAction->GetDXArray().empty())
886 {
887 auto & rArray = pMetaTextArrayAction->GetDXArray();
888 rWriter.startElement("dxarray");
889 if (aIndex < o3tl::narrowing<sal_Int32>(rArray.size()))
890 rWriter.attribute("first", rArray[aIndex]);
891 if (aIndex + aLength - 1 < o3tl::narrowing<sal_Int32>(rArray.size()))
892 rWriter.attribute("last", rArray[aIndex + aLength - 1]);
893 OUStringBuffer sDxLengthString(std::max((aLength - aIndex) * 4, sal_Int32(0)));
894 for (sal_Int32 i = 0; i < aLength - aIndex; ++i)
895 {
896 sDxLengthString.append(OUString::number(rArray[aIndex + i]) + " ");
897 }
898 rWriter.content(sDxLengthString);
899 rWriter.endElement();
900 }
901
902 rWriter.startElement("text");
903
904 const OUString& rStr = pMetaTextArrayAction->GetText();
905 // fix bad XML dump by removing forbidden 0x01
906 // FIXME: expand footnote anchor point 0x01 instead of this
907 if ( rStr.indexOf(0x01) > -1 )
908 rWriter.content(rStr.replaceAll("\001", ""));
909 else
910 rWriter.content(rStr);
911
912 rWriter.endElement();
913
914 rWriter.endElement();
915 }
916 break;
917
918 case MetaActionType::STRETCHTEXT:
919 {
920 auto* pMeta = static_cast<MetaStretchTextAction*>(pAction);
921 rWriter.startElement(sCurrentElementTag);
922
923 writePoint(rWriter, pMeta->GetPoint());
924 rWriter.attribute("index", pMeta->GetIndex());
925 rWriter.attribute("length", pMeta->GetLen());
926 rWriter.attribute("width", pMeta->GetWidth());
927
928 rWriter.startElement("textcontent");
929 rWriter.content(pMeta->GetText());
930 rWriter.endElement();
931
932 rWriter.endElement();
933 }
934 break;
935
936 case MetaActionType::TEXTRECT:
937 {
938 auto* pMeta = static_cast<MetaTextRectAction*>(pAction);
939 rWriter.startElement(sCurrentElementTag);
940 writeRectangle(rWriter, pMeta->GetRect());
941 rWriter.startElement("textcontent");
942 rWriter.content(pMeta->GetText());
943 rWriter.endElement();
944
945 rWriter.startElement("style");
946 rWriter.content(convertDrawTextFlagsToString(pMeta->GetStyle()));
947 rWriter.endElement();
948
949 rWriter.endElement();
950 }
951 break;
952
953 case MetaActionType::BMP:
954 {
955 auto pMeta = static_cast<MetaBmpAction*>(pAction);
956 Bitmap aBitmap = pMeta->GetBitmap();
957 rWriter.startElement(sCurrentElementTag);
958 writePoint(rWriter, pMeta->GetPoint());
959 writeBitmap(rWriter, aBitmap);
960 rWriter.endElement();
961 }
962 break;
963
964 case MetaActionType::BMPSCALE:
965 {
966 auto pMeta = static_cast<MetaBmpScaleAction*>(pAction);
967 Bitmap aBitmap = pMeta->GetBitmap();
968 rWriter.startElement(sCurrentElementTag);
969 writePoint(rWriter, pMeta->GetPoint());
970 writeSize(rWriter, pMeta->GetSize());
971 writeBitmap(rWriter, aBitmap);
972 rWriter.endElement();
973 }
974 break;
975
976 case MetaActionType::BMPSCALEPART:
977 {
978 auto pMeta = static_cast<MetaBmpScalePartAction*>(pAction);
979 Bitmap aBitmap = pMeta->GetBitmap();
980 rWriter.startElement(sCurrentElementTag);
981 rWriter.attribute("destx", pMeta->GetDestPoint().X());
982 rWriter.attribute("desty", pMeta->GetDestPoint().Y());
983 rWriter.attribute("destwidth", pMeta->GetDestSize().Width());
984 rWriter.attribute("destheight", pMeta->GetDestSize().Height());
985 rWriter.attribute("srcx", pMeta->GetSrcPoint().X());
986 rWriter.attribute("srcy", pMeta->GetSrcPoint().Y());
987 rWriter.attribute("srcwidth", pMeta->GetSrcSize().Width());
988 rWriter.attribute("srcheight", pMeta->GetSrcSize().Height());
989 writeBitmap(rWriter, aBitmap);
990 rWriter.endElement();
991 }
992 break;
993
994 case MetaActionType::BMPEX:
995 {
996 auto pMeta = static_cast<MetaBmpExAction*>(pAction);
997 rWriter.startElement(sCurrentElementTag);
998 writePoint(rWriter, pMeta->GetPoint());
999 Bitmap aBitmap = pMeta->GetBitmapEx().GetBitmap();
1000 rWriter.attribute("transparenttype", convertBitmapExTransparentType(pMeta->GetBitmapEx()));
1001 writeBitmap(rWriter, aBitmap);
1002 rWriter.endElement();
1003 }
1004 break;
1005
1006 case MetaActionType::BMPEXSCALE:
1007 {
1008 auto pMeta = static_cast<MetaBmpExScaleAction*>(pAction);
1009 rWriter.startElement(sCurrentElementTag);
1010 writePoint(rWriter, pMeta->GetPoint());
1011 writeSize(rWriter, pMeta->GetSize());
1012 Bitmap aBitmap = pMeta->GetBitmapEx().GetBitmap();
1013 rWriter.attribute("transparenttype", convertBitmapExTransparentType(pMeta->GetBitmapEx()));
1014 writeBitmap(rWriter, aBitmap);
1015 rWriter.endElement();
1016 }
1017 break;
1018
1019 case MetaActionType::BMPEXSCALEPART:
1020 {
1021 auto pMeta = static_cast<MetaBmpExScalePartAction*>(pAction);
1022 Bitmap aBitmap = pMeta->GetBitmapEx().GetBitmap();
1023 rWriter.startElement(sCurrentElementTag);
1024 rWriter.attribute("destx", pMeta->GetDestPoint().X());
1025 rWriter.attribute("desty", pMeta->GetDestPoint().Y());
1026 rWriter.attribute("destwidth", pMeta->GetDestSize().Width());
1027 rWriter.attribute("destheight", pMeta->GetDestSize().Height());
1028 rWriter.attribute("srcx", pMeta->GetSrcPoint().X());
1029 rWriter.attribute("srcy", pMeta->GetSrcPoint().Y());
1030 rWriter.attribute("srcwidth", pMeta->GetSrcSize().Width());
1031 rWriter.attribute("srcheight", pMeta->GetSrcSize().Height());
1032 rWriter.attribute("transparenttype", convertBitmapExTransparentType(pMeta->GetBitmapEx()));
1033 writeBitmap(rWriter, aBitmap);
1034 rWriter.endElement();
1035 }
1036 break;
1037
1038 case MetaActionType::MASK:
1039 {
1040 auto pMeta = static_cast<MetaMaskAction*>(pAction);
1041 rWriter.startElement(sCurrentElementTag);
1042 writePoint(rWriter, pMeta->GetPoint());
1043 rWriter.attribute("crc", hex32(pMeta->GetBitmap().GetChecksum()));
1044 rWriter.attribute("color", convertColorToString(pMeta->GetColor()));
1045 rWriter.endElement();
1046 }
1047 break;
1048
1049 case MetaActionType::MASKSCALE:
1050 {
1051 auto pMeta = static_cast<MetaMaskScaleAction*>(pAction);
1052 rWriter.startElement(sCurrentElementTag);
1053 writePoint(rWriter, pMeta->GetPoint());
1054 writeSize(rWriter, pMeta->GetSize());
1055 rWriter.attribute("crc", hex32(pMeta->GetBitmap().GetChecksum()));
1056 rWriter.attribute("color", convertColorToString(pMeta->GetColor()));
1057 rWriter.endElement();
1058 }
1059 break;
1060
1061 case MetaActionType::MASKSCALEPART:
1062 {
1063 auto pMeta = static_cast<MetaMaskScalePartAction*>(pAction);
1064 rWriter.startElement(sCurrentElementTag);
1065 rWriter.attribute("destx", pMeta->GetDestPoint().X());
1066 rWriter.attribute("desty", pMeta->GetDestPoint().Y());
1067 rWriter.attribute("destwidth", pMeta->GetDestSize().Width());
1068 rWriter.attribute("destheight", pMeta->GetDestSize().Height());
1069 rWriter.attribute("srcx", pMeta->GetSrcPoint().X());
1070 rWriter.attribute("srcy", pMeta->GetSrcPoint().Y());
1071 rWriter.attribute("srcwidth", pMeta->GetSrcSize().Width());
1072 rWriter.attribute("srcheight", pMeta->GetSrcSize().Height());
1073 rWriter.attribute("crc", hex32(pMeta->GetBitmap().GetChecksum()));
1074 rWriter.attribute("color", convertColorToString(pMeta->GetColor()));
1075 rWriter.endElement();
1076 }
1077 break;
1078
1079 case MetaActionType::GRADIENT:
1080 {
1081 const MetaGradientAction* pMeta = static_cast<MetaGradientAction*>(pAction);
1082
1083 rWriter.startElement(sCurrentElementTag);
1084 writeGradient(rWriter, pMeta->GetGradient());
1085
1086 rWriter.startElement("rectangle");
1087 writeRectangle(rWriter, pMeta->GetRect());
1088 rWriter.endElement();
1089
1090 rWriter.endElement();
1091 }
1092 break;
1093
1094 case MetaActionType::HATCH:
1095 {
1096 auto* const pMetaHatchAction = static_cast<MetaHatchAction*>(pAction);
1097 rWriter.startElement(sCurrentElementTag);
1098
1099 tools::PolyPolygon const& rPolyPolygon(pMetaHatchAction->GetPolyPolygon());
1100
1101 for (sal_uInt16 j = 0; j < rPolyPolygon.Count(); ++j)
1102 {
1103 rWriter.startElement("polygon");
1104 tools::Polygon const& rPolygon = rPolyPolygon[j];
1105 bool bFlags = rPolygon.HasFlags();
1106 for (sal_uInt16 i = 0; i < rPolygon.GetSize(); ++i)
1107 {
1108 rWriter.startElement("point");
1109 writePoint(rWriter, rPolygon[i]);
1110 if (bFlags)
1111 rWriter.attribute("flags", convertPolygonFlags(rPolygon.GetFlags(i)));
1112 rWriter.endElement();
1113 }
1114 rWriter.endElement();
1115 }
1116
1117 rWriter.startElement("hatch");
1118 const auto& rHatch = pMetaHatchAction->GetHatch();
1119 rWriter.attribute("style", convertHatchStyle(rHatch.GetStyle()));
1120 rWriter.attribute("color", convertColorToString(rHatch.GetColor()));
1121 rWriter.attribute("distance", sal_Int32(rHatch.GetDistance()));
1122 rWriter.attribute("angle", sal_Int32(rHatch.GetAngle().get()));
1123 rWriter.endElement();
1124
1125 rWriter.endElement();
1126 }
1127 break;
1128
1129 case MetaActionType::WALLPAPER:
1130 {
1131 const auto* pMetaAction = static_cast<const MetaWallpaperAction*>(pAction);
1132 rWriter.startElement(sCurrentElementTag);
1133
1134 writeRectangle(rWriter, pMetaAction->GetRect());
1135
1136 rWriter.startElement("wallpaper");
1137 const auto& rWallpaper = pMetaAction->GetWallpaper();
1138
1139 rWriter.attribute("color", convertColorToString(rWallpaper.GetColor()));
1140
1141 WallpaperStyle eStyle = rWallpaper.GetStyle();
1142 rWriter.attribute("style", convertWallpaperStyleToString(eStyle));
1143
1144 if (rWallpaper.IsBitmap())
1145 {
1146 rWriter.startElement("bitmap");
1147 BitmapEx const & rBitmapEx = rWallpaper.GetBitmap();
1148 rWriter.attribute("crc", hex32(rBitmapEx.GetChecksum()));
1149 rWriter.attribute("transparenttype", convertBitmapExTransparentType(rBitmapEx));
1150 rWriter.attribute("pixelformat", convertPixelFormatToString(rBitmapEx.GetBitmap().getPixelFormat()));
1151 rWriter.attribute("width", hex32(rBitmapEx.GetSizePixel().Width()));
1152 rWriter.attribute("height", hex32(rBitmapEx.GetSizePixel().Height()));
1153 rWriter.endElement();
1154 }
1155
1156 if (rWallpaper.IsGradient())
1157 {
1158 rWriter.startElement("gradient");
1159 Gradient aGradient = rWallpaper.GetGradient();
1160 writeGradient(rWriter, aGradient);
1161 rWriter.endElement();
1162 }
1163
1164 if (rWallpaper.IsRect())
1165 {
1166 tools::Rectangle aRect = rWallpaper.GetRect();
1167 rWriter.startElement("rectangle");
1168 writeRectangle(rWriter, aRect);
1169 rWriter.endElement();
1170 }
1171
1172 rWriter.attribute("fixed", rWallpaper.IsFixed() ? "true" : "false");
1173 rWriter.attribute("scrollable", rWallpaper.IsScrollable() ? "true" : "false");
1174
1175 rWriter.endElement();
1176
1177 rWriter.endElement();
1178 }
1179 break;
1180
1181 case MetaActionType::CLIPREGION:
1182 {
1183 const auto* pMetaClipRegionAction = static_cast<const MetaClipRegionAction*>(pAction);
1184 rWriter.startElement(sCurrentElementTag);
1185
1186 tools::Rectangle aRectangle = pMetaClipRegionAction->GetRegion().GetBoundRect();
1187 writeRectangle(rWriter, aRectangle);
1188
1189 vcl::Region aRegion = pMetaClipRegionAction->GetRegion();
1190
1191 if (aRegion.HasPolyPolygonOrB2DPolyPolygon())
1192 {
1193 tools::PolyPolygon aPolyPolygon = aRegion.GetAsPolyPolygon();
1194
1195 for (sal_uInt16 j = 0; j < aPolyPolygon.Count(); ++j)
1196 {
1197 rWriter.startElement("polygon");
1198 tools::Polygon const& rPolygon = aPolyPolygon[j];
1199 bool bFlags = rPolygon.HasFlags();
1200 for (sal_uInt16 i = 0; i < rPolygon.GetSize(); ++i)
1201 {
1202 rWriter.startElement("point");
1203 writePoint(rWriter, rPolygon[i]);
1204 if (bFlags)
1205 rWriter.attribute("flags", convertPolygonFlags(rPolygon.GetFlags(i)));
1206 rWriter.endElement();
1207 }
1208 rWriter.endElement();
1209 }
1210 }
1211
1212 rWriter.endElement();
1213 }
1214 break;
1215
1216 case MetaActionType::ISECTRECTCLIPREGION:
1217 {
1218 MetaISectRectClipRegionAction* pMetaISectRectClipRegionAction = static_cast<MetaISectRectClipRegionAction*>(pAction);
1219 rWriter.startElement(sCurrentElementTag);
1220
1221 tools::Rectangle aRectangle = pMetaISectRectClipRegionAction->GetRect();
1222 writeRectangle(rWriter, aRectangle);
1223 rWriter.endElement();
1224 }
1225 break;
1226
1227 case MetaActionType::ISECTREGIONCLIPREGION:
1228 {
1229 MetaISectRegionClipRegionAction* pMetaISectRegionClipRegionAction = static_cast<MetaISectRegionClipRegionAction*>(pAction);
1230 rWriter.startElement(sCurrentElementTag);
1231
1232 // FIXME for now we dump only the bounding box; this is
1233 // enough for the tests we have, but may need extending to
1234 // dumping the real polypolygon in the future
1235 tools::Rectangle aRectangle = pMetaISectRegionClipRegionAction->GetRegion().GetBoundRect();
1236 writeRectangle(rWriter, aRectangle);
1237 rWriter.endElement();
1238 }
1239 break;
1240
1241 case MetaActionType::MOVECLIPREGION:
1242 {
1243 const auto* pMetaMoveClipRegionAction = static_cast<MetaMoveClipRegionAction*>(pAction);
1244 rWriter.startElement(sCurrentElementTag);
1245
1246 rWriter.attribute("horzmove", pMetaMoveClipRegionAction->GetHorzMove());
1247 rWriter.attribute("vertmove", pMetaMoveClipRegionAction->GetVertMove());
1248 rWriter.endElement();
1249 }
1250 break;
1251
1252 case MetaActionType::LINECOLOR:
1253 {
1254 MetaLineColorAction* pMetaLineColorAction = static_cast<MetaLineColorAction*>(pAction);
1255 rWriter.startElement(sCurrentElementTag);
1256
1257 rWriter.attribute("color", convertColorToString(pMetaLineColorAction->GetColor()));
1258 rWriter.endElement();
1259 }
1260 break;
1261
1262 case MetaActionType::FILLCOLOR:
1263 {
1264 MetaFillColorAction* pMetaFillColorAction = static_cast<MetaFillColorAction*>(pAction);
1265 rWriter.startElement(sCurrentElementTag);
1266
1267 rWriter.attribute("color", convertColorToString(pMetaFillColorAction->GetColor()));
1268 rWriter.endElement();
1269 }
1270 break;
1271
1272 case MetaActionType::TEXTCOLOR:
1273 {
1274 MetaTextColorAction* pMetaTextColorAction = static_cast<MetaTextColorAction*>(pAction);
1275 rWriter.startElement(sCurrentElementTag);
1276
1277 rWriter.attribute("color", convertColorToString(pMetaTextColorAction->GetColor()));
1278 rWriter.endElement();
1279 }
1280 break;
1281
1282 case MetaActionType::TEXTFILLCOLOR:
1283 {
1284 MetaTextFillColorAction* pMetaTextFillColorAction = static_cast<MetaTextFillColorAction*>(pAction);
1285 rWriter.startElement(sCurrentElementTag);
1286
1287 rWriter.attribute("color", convertColorToString(pMetaTextFillColorAction->GetColor()));
1288
1289 if (pMetaTextFillColorAction->IsSetting())
1290 rWriter.attribute("setting", u"true");
1291
1292 rWriter.endElement();
1293 }
1294 break;
1295
1296 case MetaActionType::TEXTALIGN:
1297 {
1298 MetaTextAlignAction* pMetaTextAlignAction = static_cast<MetaTextAlignAction*>(pAction);
1299 rWriter.startElement(sCurrentElementTag);
1300 OUString sAlign = convertTextAlignToString(pMetaTextAlignAction->GetTextAlign());
1301 if (!sAlign.isEmpty())
1302 rWriter.attribute("align", sAlign);
1303 rWriter.endElement();
1304 }
1305 break;
1306
1307 case MetaActionType::MAPMODE:
1308 {
1309 const MetaMapModeAction* pMeta = static_cast<MetaMapModeAction*>(pAction);
1310 MapMode aMapMode = pMeta->GetMapMode();
1311 rWriter.startElement(sCurrentElementTag);
1312 rWriter.attribute("mapunit", convertMapUnitToString( aMapMode.GetMapUnit() ));
1313 writePoint(rWriter, aMapMode.GetOrigin());
1314 rWriter.attribute("scalex", convertFractionToString(aMapMode.GetScaleX()));
1315 rWriter.attribute("scaley", convertFractionToString(aMapMode.GetScaleY()));
1316 rWriter.endElement();
1317 }
1318 break;
1319
1320 case MetaActionType::FONT:
1321 {
1322 MetaFontAction* pMetaFontAction = static_cast<MetaFontAction*>(pAction);
1323 rWriter.startElement(sCurrentElementTag);
1324
1325 vcl::Font aFont = pMetaFontAction->GetFont();
1326
1327 rWriter.attribute("color", convertColorToString(aFont.GetColor()));
1328 rWriter.attribute("fillcolor", convertColorToString(aFont.GetFillColor()));
1329 rWriter.attribute("name", aFont.GetFamilyName());
1330 rWriter.attribute("stylename", aFont.GetStyleName());
1331 rWriter.attribute("width", aFont.GetFontSize().Width());
1332 rWriter.attribute("height", aFont.GetFontSize().Height());
1333 rWriter.attribute("orientation", aFont.GetOrientation().get());
1334 rWriter.attribute("weight", convertFontWeightToString(aFont.GetWeight()));
1335 rWriter.attribute("vertical", aFont.IsVertical() ? "true" : "false");
1336 rWriter.attribute("emphasis", aFont.GetEmphasisMark() != FontEmphasisMark::NONE ? "true" : "false");
1337 rWriter.attribute("shadow", aFont.IsShadow() ? "true" : "false");
1338 rWriter.attribute("wordunderline", aFont.IsWordLineMode() ? "true" : "false");
1339 rWriter.attribute("outline", aFont.IsOutline() ? "true" : "false");
1340
1341 rWriter.endElement();
1342 }
1343 break;
1344
1345 case MetaActionType::PUSH:
1346 {
1347 MetaPushAction* pMetaPushAction = static_cast<MetaPushAction*>(pAction);
1348 rWriter.startElement(sCurrentElementTag);
1349
1350 rWriter.attribute("flags", collectPushFlags(pMetaPushAction->GetFlags()));
1351 }
1352 break;
1353
1354 case MetaActionType::POP:
1355 {
1356 rWriter.endElement();
1357 }
1358 break;
1359
1360 case MetaActionType::RASTEROP:
1361 {
1362 MetaRasterOpAction* pMetaRasterOpAction = static_cast<MetaRasterOpAction*>(pAction);
1363 rWriter.startElement(sCurrentElementTag);
1364
1365 if (pMetaRasterOpAction->GetRasterOp() != RasterOp::OverPaint)
1366 {
1367 rWriter.attribute("operation", convertRopToString(pMetaRasterOpAction->GetRasterOp()));
1368 }
1369 rWriter.endElement();
1370 }
1371 break;
1372
1373 case MetaActionType::Transparent:
1374 {
1375 const MetaTransparentAction* pMeta = static_cast<MetaTransparentAction*>(pAction);
1376
1377 rWriter.startElement(sCurrentElementTag);
1378 rWriter.attribute("transparence", pMeta->GetTransparence());
1379
1380 tools::PolyPolygon const& rPolyPolygon(pMeta->GetPolyPolygon());
1381
1382 for (sal_uInt16 j = 0; j < rPolyPolygon.Count(); ++j)
1383 {
1384 rWriter.startElement("polygon");
1385 tools::Polygon const& rPolygon = rPolyPolygon[j];
1386 bool bFlags = rPolygon.HasFlags();
1387 for (sal_uInt16 i = 0; i < rPolygon.GetSize(); ++i)
1388 {
1389 rWriter.startElement("point");
1390 writePoint(rWriter, rPolygon[i]);
1391 if (bFlags)
1392 rWriter.attribute("flags", convertPolygonFlags(rPolygon.GetFlags(i)));
1393 rWriter.endElement();
1394 }
1395 rWriter.endElement();
1396 }
1397
1398 rWriter.endElement();
1399 }
1400 break;
1401
1402 case MetaActionType::EPS:
1403 {
1404 MetaEPSAction* pMetaEPSAction = static_cast<MetaEPSAction*>(pAction);
1405 rWriter.startElement(sCurrentElementTag);
1406
1407 writePoint(rWriter, pMetaEPSAction->GetPoint());
1408 writeSize(rWriter, pMetaEPSAction->GetSize());
1409
1410 rWriter.startElement("gfxlink");
1411 writeSize(rWriter, pMetaEPSAction->GetLink().GetPrefSize());
1412 rWriter.attribute("type", convertGfxLinkTypeToString(pMetaEPSAction->GetLink().GetType()));
1413 rWriter.attribute("userid", pMetaEPSAction->GetLink().GetUserId());
1414 rWriter.attribute("datasize", pMetaEPSAction->GetLink().GetDataSize());
1415 rWriter.attribute("data", toHexString(pMetaEPSAction->GetLink().GetData(), pMetaEPSAction->GetLink().GetDataSize()));
1416 rWriter.attribute("native", pMetaEPSAction->GetLink().IsNative() ? "true" : "false");
1417 rWriter.attribute("emf", pMetaEPSAction->GetLink().IsEMF() ? "true" : "false");
1418 rWriter.attribute("validmapmode", pMetaEPSAction->GetLink().IsPrefMapModeValid() ? "true" : "false");
1419 rWriter.startElement("prefmapmode");
1420 writeMapMode(rWriter, pMetaEPSAction->GetLink().GetPrefMapMode());
1421 rWriter.endElement();
1422 rWriter.endElement();
1423
1424 rWriter.startElement("metafile");
1425 writeXml(pMetaEPSAction->GetSubstitute(), rWriter);
1426 rWriter.endElement();
1427
1428 rWriter.endElement();
1429 }
1430 break;
1431
1432 case MetaActionType::REFPOINT:
1433 {
1434 auto* pMeta = static_cast<MetaRefPointAction*>(pAction);
1435 rWriter.startElement(sCurrentElementTag);
1436 writePoint(rWriter, pMeta->GetRefPoint());
1437 rWriter.attribute("set", pMeta->IsSetting() ? "true" : "false");
1438 rWriter.endElement();
1439 }
1440 break;
1441
1442 case MetaActionType::TEXTLINECOLOR:
1443 {
1444 auto* pMeta = static_cast<MetaTextLineColorAction*>(pAction);
1445 rWriter.startElement(sCurrentElementTag);
1446 rWriter.attribute("color", convertColorToString(pMeta->GetColor()));
1447 rWriter.endElement();
1448 }
1449 break;
1450
1451 case MetaActionType::TEXTLINE:
1452 {
1453 auto* pMeta = static_cast<MetaTextLineAction*>(pAction);
1454 rWriter.startElement(sCurrentElementTag);
1455 writePoint(rWriter, pMeta->GetStartPoint());
1456 rWriter.attribute("width", pMeta->GetWidth());
1457 rWriter.attribute("strikeout", convertFontStrikeoutToString(pMeta->GetStrikeout()));
1458 rWriter.attribute("underline", convertFontLineStyleToString(pMeta->GetUnderline()));
1459 rWriter.attribute("overline", convertFontLineStyleToString(pMeta->GetOverline()));
1460 rWriter.endElement();
1461 }
1462 break;
1463
1464 case MetaActionType::FLOATTRANSPARENT:
1465 {
1466 const auto* pMeta = static_cast<MetaFloatTransparentAction*>(pAction);
1467 rWriter.startElement(sCurrentElementTag);
1468 writePoint(rWriter, pMeta->GetPoint());
1469 writeSize(rWriter, pMeta->GetSize());
1470 rWriter.attribute("transparent", pMeta->IsTransparent() ? "true" : "false");
1471
1472 rWriter.startElement("gradient");
1473 writeGradient(rWriter, pMeta->GetGradient());
1474 rWriter.endElement();
1475
1476 rWriter.startElement("metafile");
1477 writeXml(pMeta->GetGDIMetaFile(), rWriter);
1478 rWriter.endElement();
1479
1480 rWriter.endElement();
1481 }
1482 break;
1483
1484 case MetaActionType::GRADIENTEX:
1485 {
1486 const MetaGradientExAction* pMetaGradientExAction = static_cast<MetaGradientExAction*>(pAction);
1487
1488 rWriter.startElement(sCurrentElementTag);
1489 writeGradient(rWriter, pMetaGradientExAction->GetGradient());
1490
1491 tools::PolyPolygon const& rPolyPolygon(pMetaGradientExAction->GetPolyPolygon());
1492 for (sal_uInt16 j = 0; j < rPolyPolygon.Count(); ++j)
1493 {
1494 rWriter.startElement("polygon");
1495 tools::Polygon const& rPolygon = rPolyPolygon[j];
1496 bool bFlags = rPolygon.HasFlags();
1497 for (sal_uInt16 i = 0; i < rPolygon.GetSize(); ++i)
1498 {
1499 rWriter.startElement("point");
1500 writePoint(rWriter, rPolygon[i]);
1501 if (bFlags)
1502 rWriter.attribute("flags", convertPolygonFlags(rPolygon.GetFlags(i)));
1503 rWriter.endElement();
1504 }
1505 rWriter.endElement();
1506 }
1507
1508 rWriter.endElement();
1509 }
1510 break;
1511
1512 case MetaActionType::LAYOUTMODE:
1513 {
1514 const MetaLayoutModeAction* pMetaLayoutModeAction = static_cast<MetaLayoutModeAction*>(pAction);
1515
1516 rWriter.startElement(sCurrentElementTag);
1517
1518 rWriter.attribute("textlayout", convertComplexTestLayoutFlags(pMetaLayoutModeAction->GetLayoutMode()));
1519
1520 rWriter.endElement();
1521 }
1522 break;
1523
1524 case MetaActionType::TEXTLANGUAGE:
1525 {
1526 const MetaTextLanguageAction* pMetaTextLanguageAction = static_cast<MetaTextLanguageAction*>(pAction);
1527
1528 rWriter.startElement(sCurrentElementTag);
1529
1530 rWriter.attribute("language", convertLanguageTypeToString(pMetaTextLanguageAction->GetTextLanguage()));
1531
1532 rWriter.endElement();
1533 }
1534 break;
1535
1536 case MetaActionType::OVERLINECOLOR:
1537 {
1538 const auto* pMetaAction = static_cast<MetaOverlineColorAction*>(pAction);
1539 rWriter.startElement(sCurrentElementTag);
1540 rWriter.attribute("color", convertColorToString(pMetaAction->GetColor()));
1541 rWriter.endElement();
1542 }
1543 break;
1544
1545 case MetaActionType::COMMENT:
1546 {
1547 MetaCommentAction* pMetaCommentAction = static_cast<MetaCommentAction*>(pAction);
1548 rWriter.startElement(sCurrentElementTag);
1549
1550 if (pMetaCommentAction->GetDataSize() > 0)
1551 {
1552 rWriter.attribute("datasize", pMetaCommentAction->GetDataSize());
1553 rWriter.attribute("data", toHexString(pMetaCommentAction->GetData(), pMetaCommentAction->GetDataSize()));
1554 }
1555 rWriter.attribute("value", pMetaCommentAction->GetValue());
1556
1557 if (!pMetaCommentAction->GetComment().isEmpty())
1558 {
1559 rWriter.startElement("comment");
1560 rWriter.content(pMetaCommentAction->GetComment());
1561 rWriter.endElement();
1562 }
1563 rWriter.endElement();
1564 }
1565 break;
1566
1567 default:
1568 {
1569 rWriter.startElement(sCurrentElementTag);
1570 rWriter.attribute("note", "not implemented in xml dump"_ostr);
1571 rWriter.endElement();
1572 }
1573 break;
1574 }
1575 }
1576 }
1577
1578 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE