LibreOffice Module drawinglayer (master) 1
primitive2dxmldump.cxx
Go to the documentation of this file.
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 <drawinglayer/tools/primitive2dxmldump.hxx>
11
12#include <rtl/string.hxx>
13#include <tools/stream.hxx>
14#include <tools/XmlWriter.hxx>
15
16#include <math.h>
17#include <memory>
18#include <sal/log.hxx>
19
20#include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>
21#include <drawinglayer/primitive2d/pointarrayprimitive2d.hxx>
22#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
23#include <drawinglayer/primitive2d/Tools.hxx>
24#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
25#include <drawinglayer/primitive2d/PolygonHairlinePrimitive2D.hxx>
26#include <drawinglayer/primitive2d/PolygonStrokeArrowPrimitive2D.hxx>
27#include <drawinglayer/primitive2d/PolygonStrokePrimitive2D.hxx>
28#include <drawinglayer/primitive2d/PolyPolygonStrokePrimitive2D.hxx>
29#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>
30#include <drawinglayer/primitive2d/hiddengeometryprimitive2d.hxx>
31#include <drawinglayer/primitive2d/softedgeprimitive2d.hxx>
32#include <drawinglayer/primitive2d/textdecoratedprimitive2d.hxx>
33#include <primitive2d/textlineprimitive2d.hxx>
34#include <drawinglayer/primitive2d/textprimitive2d.hxx>
35#include <drawinglayer/primitive2d/maskprimitive2d.hxx>
36#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
37#include <drawinglayer/primitive2d/objectinfoprimitive2d.hxx>
38#include <drawinglayer/primitive2d/structuretagprimitive2d.hxx>
39#include <drawinglayer/primitive2d/svggradientprimitive2d.hxx>
40#include <drawinglayer/primitive2d/metafileprimitive2d.hxx>
41#include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx>
42#include <drawinglayer/primitive2d/sceneprimitive2d.hxx>
43#include <drawinglayer/primitive2d/shadowprimitive2d.hxx>
44#include <drawinglayer/geometry/viewinformation2d.hxx>
45#include <drawinglayer/attribute/lineattribute.hxx>
46#include <drawinglayer/attribute/fontattribute.hxx>
47
48#include <basegfx/polygon/b2dpolypolygontools.hxx>
49#include <basegfx/polygon/b2dpolygontools.hxx>
50#include <basegfx/utils/gradienttools.hxx>
51#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx>
52#include <toolkit/helper/vclunohelper.hxx>
53
54#include <drawinglayer/primitive3d/baseprimitive3d.hxx>
55#include <drawinglayer/primitive3d/Tools.hxx>
56#include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
57#include <drawinglayer/primitive3d/sdrextrudeprimitive3d.hxx>
58#include <drawinglayer/attribute/sdrlightattribute3d.hxx>
59#include <drawinglayer/attribute/sdrfillattribute.hxx>
60#include <drawinglayer/attribute/fillhatchattribute.hxx>
61#include <drawinglayer/attribute/fillgradientattribute.hxx>
62#include <drawinglayer/attribute/sdrfillgraphicattribute.hxx>
63#include <drawinglayer/attribute/materialattribute3d.hxx>
64
65using namespace drawinglayer::primitive2d;
66
67namespace drawinglayer
68{
69namespace
70{
71const size_t constMaxActionType = 513;
72
73OUString convertColorToString(const basegfx::BColor& rColor)
74{
75 OUString aRGBString = Color(rColor).AsRGBHexString();
76 return "#" + aRGBString;
77}
78
79void writeMatrix(::tools::XmlWriter& rWriter, const basegfx::B2DHomMatrix& rMatrix)
80{
81 rWriter.attribute("xy11", rMatrix.get(0, 0));
82 rWriter.attribute("xy12", rMatrix.get(0, 1));
83 rWriter.attribute("xy13", rMatrix.get(0, 2));
84 rWriter.attribute("xy21", rMatrix.get(1, 0));
85 rWriter.attribute("xy22", rMatrix.get(1, 1));
86 rWriter.attribute("xy23", rMatrix.get(1, 2));
87 rWriter.attribute("xy31", 0);
88 rWriter.attribute("xy32", 0);
89 rWriter.attribute("xy33", 1);
90}
91
92void writeMatrix3D(::tools::XmlWriter& rWriter, const basegfx::B3DHomMatrix& rMatrix)
93{
94 rWriter.attribute("xy11", rMatrix.get(0, 0));
95 rWriter.attribute("xy12", rMatrix.get(0, 1));
96 rWriter.attribute("xy13", rMatrix.get(0, 2));
97 rWriter.attribute("xy14", rMatrix.get(0, 3));
98 rWriter.attribute("xy21", rMatrix.get(1, 0));
99 rWriter.attribute("xy22", rMatrix.get(1, 1));
100 rWriter.attribute("xy23", rMatrix.get(1, 2));
101 rWriter.attribute("xy24", rMatrix.get(1, 3));
102 rWriter.attribute("xy31", rMatrix.get(2, 0));
103 rWriter.attribute("xy32", rMatrix.get(2, 1));
104 rWriter.attribute("xy33", rMatrix.get(2, 2));
105 rWriter.attribute("xy34", rMatrix.get(2, 3));
106 rWriter.attribute("xy41", rMatrix.get(3, 0));
107 rWriter.attribute("xy42", rMatrix.get(3, 1));
108 rWriter.attribute("xy43", rMatrix.get(3, 2));
109 rWriter.attribute("xy44", rMatrix.get(3, 3));
110}
111
112void writePolyPolygon(::tools::XmlWriter& rWriter, const basegfx::B2DPolyPolygon& rB2DPolyPolygon)
113{
114 rWriter.startElement("polypolygon");
115 const basegfx::B2DRange aB2DRange(rB2DPolyPolygon.getB2DRange());
116 rWriter.attributeDouble("height", aB2DRange.getHeight());
117 rWriter.attributeDouble("width", aB2DRange.getWidth());
118 rWriter.attributeDouble("minx", aB2DRange.getMinX());
119 rWriter.attributeDouble("miny", aB2DRange.getMinY());
120 rWriter.attributeDouble("maxx", aB2DRange.getMaxX());
121 rWriter.attributeDouble("maxy", aB2DRange.getMaxY());
122 rWriter.attribute("path", basegfx::utils::exportToSvgD(rB2DPolyPolygon, true, true, false));
123
124 for (basegfx::B2DPolygon const& rPolygon : rB2DPolyPolygon)
125 {
126 rWriter.startElement("polygon");
127 for (sal_uInt32 i = 0; i < rPolygon.count(); ++i)
128 {
129 basegfx::B2DPoint const& rPoint = rPolygon.getB2DPoint(i);
130
131 rWriter.startElement("point");
132 rWriter.attribute("x", OUString::number(rPoint.getX()));
133 rWriter.attribute("y", OUString::number(rPoint.getY()));
134 rWriter.endElement();
135 }
136 rWriter.endElement();
137 }
138
139 rWriter.endElement();
140}
141
142void writeStrokeAttribute(::tools::XmlWriter& rWriter,
143 const drawinglayer::attribute::StrokeAttribute& rStrokeAttribute)
144{
145 if (!rStrokeAttribute.getDotDashArray().empty())
146 {
147 rWriter.startElement("stroke");
148
149 OUString sDotDash;
150 for (double fDotDash : rStrokeAttribute.getDotDashArray())
151 {
152 sDotDash += OUString::number(lround(fDotDash)) + " ";
153 }
154 rWriter.attribute("dotDashArray", sDotDash);
155 rWriter.attribute("fullDotDashLength", rStrokeAttribute.getFullDotDashLen());
156 rWriter.endElement();
157 }
158}
159
160void writeLineAttribute(::tools::XmlWriter& rWriter,
161 const drawinglayer::attribute::LineAttribute& rLineAttribute)
162{
163 rWriter.startElement("line");
164 rWriter.attribute("color", convertColorToString(rLineAttribute.getColor()));
165 rWriter.attribute("width", rLineAttribute.getWidth());
166 switch (rLineAttribute.getLineJoin())
167 {
168 case basegfx::B2DLineJoin::NONE:
169 rWriter.attribute("linejoin", "NONE");
170 break;
171 case basegfx::B2DLineJoin::Bevel:
172 rWriter.attribute("linejoin", "Bevel");
173 break;
174 case basegfx::B2DLineJoin::Miter:
175 {
176 rWriter.attribute("linejoin", "Miter");
177 rWriter.attribute("miterangle",
178 basegfx::rad2deg(rLineAttribute.getMiterMinimumAngle()));
179 break;
180 }
181 case basegfx::B2DLineJoin::Round:
182 rWriter.attribute("linejoin", "Round");
183 break;
184 default:
185 rWriter.attribute("linejoin", "Unknown");
186 break;
187 }
188 switch (rLineAttribute.getLineCap())
189 {
190 case css::drawing::LineCap::LineCap_BUTT:
191 rWriter.attribute("linecap", "BUTT");
192 break;
193 case css::drawing::LineCap::LineCap_ROUND:
194 rWriter.attribute("linecap", "ROUND");
195 break;
196 case css::drawing::LineCap::LineCap_SQUARE:
197 rWriter.attribute("linecap", "SQUARE");
198 break;
199 default:
200 rWriter.attribute("linecap", "Unknown");
201 break;
202 }
203
204 rWriter.endElement();
205}
206
207void writeSdrLineAttribute(::tools::XmlWriter& rWriter,
208 const drawinglayer::attribute::SdrLineAttribute& rLineAttribute)
209{
210 if (rLineAttribute.isDefault())
211 return;
212
213 rWriter.startElement("line");
214 rWriter.attribute("color", convertColorToString(rLineAttribute.getColor()));
215 rWriter.attribute("width", rLineAttribute.getWidth());
216 rWriter.attribute("transparence", rLineAttribute.getTransparence());
217
218 switch (rLineAttribute.getJoin())
219 {
220 case basegfx::B2DLineJoin::NONE:
221 rWriter.attribute("linejoin", "NONE");
222 break;
223 case basegfx::B2DLineJoin::Bevel:
224 rWriter.attribute("linejoin", "Bevel");
225 break;
226 case basegfx::B2DLineJoin::Miter:
227 rWriter.attribute("linejoin", "Miter");
228 break;
229 case basegfx::B2DLineJoin::Round:
230 rWriter.attribute("linejoin", "Round");
231 break;
232 default:
233 rWriter.attribute("linejoin", "Unknown");
234 break;
235 }
236 switch (rLineAttribute.getCap())
237 {
238 case css::drawing::LineCap::LineCap_BUTT:
239 rWriter.attribute("linecap", "BUTT");
240 break;
241 case css::drawing::LineCap::LineCap_ROUND:
242 rWriter.attribute("linecap", "ROUND");
243 break;
244 case css::drawing::LineCap::LineCap_SQUARE:
245 rWriter.attribute("linecap", "SQUARE");
246 break;
247 default:
248 rWriter.attribute("linecap", "Unknown");
249 break;
250 }
251
252 if (!rLineAttribute.getDotDashArray().empty())
253 {
254 OUString sDotDash;
255 for (double fDotDash : rLineAttribute.getDotDashArray())
256 {
257 sDotDash += OUString::number(fDotDash) + " ";
258 }
259 rWriter.attribute("dotDashArray", sDotDash);
260 rWriter.attribute("fullDotDashLength", rLineAttribute.getFullDotDashLen());
261 }
262
263 rWriter.endElement();
264}
265
266void writeSdrFillAttribute(::tools::XmlWriter& rWriter,
267 const drawinglayer::attribute::SdrFillAttribute& rFillAttribute)
268{
269 if (rFillAttribute.isDefault())
270 return;
271
272 rWriter.startElement("fill");
273 rWriter.attribute("color", convertColorToString(rFillAttribute.getColor()));
274 rWriter.attribute("transparence", rFillAttribute.getTransparence());
275
276 auto const& rGradient = rFillAttribute.getGradient();
277 if (!rGradient.isDefault())
278 {
279 rWriter.startElement("gradient");
280 switch (rGradient.getStyle())
281 {
282 default: // GradientStyle_MAKE_FIXED_SIZE
283 case css::awt::GradientStyle_LINEAR:
284 rWriter.attribute("style", "Linear");
285 break;
286 case css::awt::GradientStyle_AXIAL:
287 rWriter.attribute("style", "Axial");
288 break;
289 case css::awt::GradientStyle_RADIAL:
290 rWriter.attribute("style", "Radial");
291 break;
292 case css::awt::GradientStyle_ELLIPTICAL:
293 rWriter.attribute("style", "Elliptical");
294 break;
295 case css::awt::GradientStyle_SQUARE:
296 rWriter.attribute("style", "Square");
297 break;
298 case css::awt::GradientStyle_RECT:
299 rWriter.attribute("style", "Rect");
300 break;
301 }
302 rWriter.attribute("border", rGradient.getBorder());
303 rWriter.attribute("offsetX", rGradient.getOffsetX());
304 rWriter.attribute("offsetY", rGradient.getOffsetY());
305 rWriter.attribute("angle", rGradient.getAngle());
306 rWriter.attribute("steps", rGradient.getSteps());
307
308 auto const& rColorStops(rGradient.getColorStops());
309 for (size_t a(0); a < rColorStops.size(); a++)
310 {
311 if (0 == a)
312 rWriter.attribute("startColor",
313 convertColorToString(rColorStops[a].getStopColor()));
314 else if (rColorStops.size() == a + 1)
315 rWriter.attribute("endColor", convertColorToString(rColorStops[a].getStopColor()));
316 else
317 {
318 rWriter.startElement("colorStop");
319 rWriter.attribute("stopOffset", rColorStops[a].getStopOffset());
320 rWriter.attribute("stopColor", convertColorToString(rColorStops[a].getStopColor()));
321 rWriter.endElement();
322 }
323 }
324 rWriter.endElement();
325 }
326
327 auto const& rHatch = rFillAttribute.getHatch();
328 if (!rHatch.isDefault())
329 {
330 rWriter.startElement("hatch");
331 switch (rHatch.getStyle())
332 {
333 case drawinglayer::attribute::HatchStyle::Single:
334 rWriter.attribute("style", "Single");
335 break;
336 case drawinglayer::attribute::HatchStyle::Double:
337 rWriter.attribute("style", "Double");
338 break;
339 case drawinglayer::attribute::HatchStyle::Triple:
340 rWriter.attribute("style", "Triple");
341 break;
342 }
343 rWriter.attribute("distance", rHatch.getDistance());
344 rWriter.attribute("angle", rHatch.getAngle());
345 rWriter.attribute("color", convertColorToString(rHatch.getColor()));
346 rWriter.attribute("minimalDescreteDistance", rHatch.getMinimalDiscreteDistance());
347 rWriter.attribute("isFillBackground", sal_Int32(rHatch.isFillBackground()));
348 rWriter.endElement();
349 }
350
351 auto const& rGraphic = rFillAttribute.getFillGraphic();
352 if (!rGraphic.isDefault())
353 {
354 rWriter.startElement("graphic");
355 // TODO
356 rWriter.endElement();
357 }
358
359 rWriter.endElement();
360}
361
362void writeShadeMode(::tools::XmlWriter& rWriter, const css::drawing::ShadeMode& rMode)
363{
364 switch (rMode)
365 {
366 case css::drawing::ShadeMode_FLAT:
367 rWriter.attribute("shadeMode", "Flat");
368 break;
369 case css::drawing::ShadeMode_SMOOTH:
370 rWriter.attribute("shadeMode", "Smooth");
371 break;
372 case css::drawing::ShadeMode_PHONG:
373 rWriter.attribute("shadeMode", "Phong");
374 break;
375 case css::drawing::ShadeMode_DRAFT:
376 rWriter.attribute("shadeMode", "Draft");
377 break;
378 default:
379 rWriter.attribute("shadeMode", "Undefined");
380 break;
381 }
382}
383
384void writeProjectionMode(::tools::XmlWriter& rWriter, const css::drawing::ProjectionMode& rMode)
385{
386 switch (rMode)
387 {
388 case css::drawing::ProjectionMode_PARALLEL:
389 rWriter.attribute("projectionMode", "Parallel");
390 break;
391 case css::drawing::ProjectionMode_PERSPECTIVE:
392 rWriter.attribute("projectionMode", "Perspective");
393 break;
394 default:
395 rWriter.attribute("projectionMode", "Undefined");
396 break;
397 }
398}
399
400void writeNormalsKind(::tools::XmlWriter& rWriter, const css::drawing::NormalsKind& rKind)
401{
402 switch (rKind)
403 {
404 case css::drawing::NormalsKind_SPECIFIC:
405 rWriter.attribute("normalsKind", "Specific");
406 break;
407 case css::drawing::NormalsKind_FLAT:
408 rWriter.attribute("normalsKind", "Flat");
409 break;
410 case css::drawing::NormalsKind_SPHERE:
411 rWriter.attribute("normalsKind", "Sphere");
412 break;
413 default:
414 rWriter.attribute("normalsKind", "Undefined");
415 break;
416 }
417}
418
419void writeTextureProjectionMode(::tools::XmlWriter& rWriter, const char* pElement,
420 const css::drawing::TextureProjectionMode& rMode)
421{
422 switch (rMode)
423 {
424 case css::drawing::TextureProjectionMode_OBJECTSPECIFIC:
425 rWriter.attribute(pElement, "Specific");
426 break;
427 case css::drawing::TextureProjectionMode_PARALLEL:
428 rWriter.attribute(pElement, "Parallel");
429 break;
430 case css::drawing::TextureProjectionMode_SPHERE:
431 rWriter.attribute(pElement, "Sphere");
432 break;
433 default:
434 rWriter.attribute(pElement, "Undefined");
435 break;
436 }
437}
438
439void writeTextureKind(::tools::XmlWriter& rWriter, const css::drawing::TextureKind2& rKind)
440{
441 switch (rKind)
442 {
443 case css::drawing::TextureKind2_LUMINANCE:
444 rWriter.attribute("textureKind", "Luminance");
445 break;
446 case css::drawing::TextureKind2_INTENSITY:
447 rWriter.attribute("textureKind", "Intensity");
448 break;
449 case css::drawing::TextureKind2_COLOR:
450 rWriter.attribute("textureKind", "Color");
451 break;
452 default:
453 rWriter.attribute("textureKind", "Undefined");
454 break;
455 }
456}
457
458void writeTextureMode(::tools::XmlWriter& rWriter, const css::drawing::TextureMode& rMode)
459{
460 switch (rMode)
461 {
462 case css::drawing::TextureMode_REPLACE:
463 rWriter.attribute("textureMode", "Replace");
464 break;
465 case css::drawing::TextureMode_MODULATE:
466 rWriter.attribute("textureMode", "Modulate");
467 break;
468 case css::drawing::TextureMode_BLEND:
469 rWriter.attribute("textureMode", "Blend");
470 break;
471 default:
472 rWriter.attribute("textureMode", "Undefined");
473 break;
474 }
475}
476
477void writeMaterialAttribute(::tools::XmlWriter& rWriter,
478 const drawinglayer::attribute::MaterialAttribute3D& rMaterial)
479{
480 rWriter.startElement("material");
481 rWriter.attribute("color", convertColorToString(rMaterial.getColor()));
482 rWriter.attribute("specular", convertColorToString(rMaterial.getSpecular()));
483 rWriter.attribute("emission", convertColorToString(rMaterial.getEmission()));
484 rWriter.attribute("specularIntensity", rMaterial.getSpecularIntensity());
485 rWriter.endElement();
486}
487
488void writeSpreadMethod(::tools::XmlWriter& rWriter,
489 const drawinglayer::primitive2d::SpreadMethod& rSpreadMethod)
490{
491 switch (rSpreadMethod)
492 {
493 case drawinglayer::primitive2d::SpreadMethod::Pad:
494 rWriter.attribute("spreadmethod", "pad");
495 break;
496 case drawinglayer::primitive2d::SpreadMethod::Reflect:
497 rWriter.attribute("spreadmethod", "reflect");
498 break;
499 case drawinglayer::primitive2d::SpreadMethod::Repeat:
500 rWriter.attribute("spreadmethod", "repeat");
501 break;
502 default:
503 rWriter.attribute("spreadmethod", "unknown");
504 }
505}
506
507} // end anonymous namespace
508
509Primitive2dXmlDump::Primitive2dXmlDump()
510 : maFilter(constMaxActionType, false)
511{
512}
513
514Primitive2dXmlDump::~Primitive2dXmlDump() = default;
515
516void Primitive2dXmlDump::dump(
517 const drawinglayer::primitive2d::Primitive2DContainer& rPrimitive2DSequence,
518 const OUString& rStreamName)
519{
520 std::unique_ptr<SvStream> pStream;
521
522 if (rStreamName.isEmpty())
523 pStream.reset(new SvMemoryStream());
524 else
525 pStream.reset(new SvFileStream(rStreamName, StreamMode::STD_READWRITE | StreamMode::TRUNC));
526
527 ::tools::XmlWriter aWriter(pStream.get());
528 aWriter.startDocument();
529 aWriter.startElement("primitive2D");
530
531 decomposeAndWrite(rPrimitive2DSequence, aWriter);
532
533 aWriter.endElement();
534 aWriter.endDocument();
535
536 pStream->Seek(STREAM_SEEK_TO_BEGIN);
537}
538
539namespace
540{
541class Primitive3DXmlDump
542{
543public:
544 void decomposeAndWrite(const drawinglayer::primitive3d::Primitive3DContainer& rSequence,
545 ::tools::XmlWriter& rWriter)
546 {
547 for (size_t i = 0; i < rSequence.size(); i++)
548 {
549 drawinglayer::primitive3d::Primitive3DReference xReference = rSequence[i];
550 const auto* pBasePrimitive
551 = static_cast<const drawinglayer::primitive3d::BasePrimitive3D*>(xReference.get());
552 sal_uInt32 nId = pBasePrimitive->getPrimitive3DID();
553 OUString sCurrentElementTag = drawinglayer::primitive3d::idToString(nId);
554 switch (nId)
555 {
556 case PRIMITIVE3D_ID_SDREXTRUDEPRIMITIVE3D:
557 {
558 const auto* pExtrudePrimitive3D
559 = static_cast<const drawinglayer::primitive3d::SdrExtrudePrimitive3D*>(
560 xReference.get());
561 rWriter.startElement("extrude3D");
562
563 rWriter.startElement("matrix3D");
564 writeMatrix3D(rWriter, pExtrudePrimitive3D->getTransform());
565 rWriter.endElement();
566
567 rWriter.attribute("textureSizeX", pExtrudePrimitive3D->getTextureSize().getX());
568 rWriter.attribute("textureSizeY", pExtrudePrimitive3D->getTextureSize().getY());
569 auto const& rLFSAttribute = pExtrudePrimitive3D->getSdrLFSAttribute();
570 writeSdrLineAttribute(rWriter, rLFSAttribute.getLine());
571 writeSdrFillAttribute(rWriter, rLFSAttribute.getFill());
572
573 rWriter.startElement("object3Dattributes");
574 {
575 auto const& r3DObjectAttributes
576 = pExtrudePrimitive3D->getSdr3DObjectAttribute();
577
578 writeNormalsKind(rWriter, r3DObjectAttributes.getNormalsKind());
579 writeTextureProjectionMode(rWriter, "textureProjectionX",
580 r3DObjectAttributes.getTextureProjectionX());
581 writeTextureProjectionMode(rWriter, "textureProjectionY",
582 r3DObjectAttributes.getTextureProjectionY());
583 writeTextureKind(rWriter, r3DObjectAttributes.getTextureKind());
584 writeTextureMode(rWriter, r3DObjectAttributes.getTextureMode());
585 writeMaterialAttribute(rWriter, r3DObjectAttributes.getMaterial());
586
587 rWriter.attribute("normalsInvert",
588 sal_Int32(r3DObjectAttributes.getNormalsInvert()));
589 rWriter.attribute("doubleSided",
590 sal_Int32(r3DObjectAttributes.getDoubleSided()));
591 rWriter.attribute("shadow3D", sal_Int32(r3DObjectAttributes.getShadow3D()));
592 rWriter.attribute("textureFilter",
593 sal_Int32(r3DObjectAttributes.getTextureFilter()));
594 rWriter.attribute("reducedGeometry",
595 sal_Int32(r3DObjectAttributes.getReducedLineGeometry()));
596 }
597 rWriter.endElement();
598
599 rWriter.attribute("depth", pExtrudePrimitive3D->getDepth());
600 rWriter.attribute("diagonal", pExtrudePrimitive3D->getDiagonal());
601 rWriter.attribute("backScale", pExtrudePrimitive3D->getBackScale());
602 rWriter.attribute("smoothNormals",
603 sal_Int32(pExtrudePrimitive3D->getSmoothNormals()));
604 rWriter.attribute("smoothLids",
605 sal_Int32(pExtrudePrimitive3D->getSmoothLids()));
606 rWriter.attribute("characterMode",
607 sal_Int32(pExtrudePrimitive3D->getCharacterMode()));
608 rWriter.attribute("closeFront",
609 sal_Int32(pExtrudePrimitive3D->getCloseFront()));
610 rWriter.attribute("closeBack", sal_Int32(pExtrudePrimitive3D->getCloseBack()));
611 writePolyPolygon(rWriter, pExtrudePrimitive3D->getPolyPolygon());
612 rWriter.endElement();
613 }
614 break;
615
616 default:
617 {
618 rWriter.startElement("unhandled");
619 rWriter.attribute("id", sCurrentElementTag);
620 rWriter.attribute("idNumber", nId);
621
622 drawinglayer::geometry::ViewInformation3D aViewInformation3D;
623 drawinglayer::primitive3d::Primitive3DContainer aContainer;
624 aContainer = pBasePrimitive->get3DDecomposition(aViewInformation3D);
625 decomposeAndWrite(aContainer, rWriter);
626 rWriter.endElement();
627 }
628 break;
629 }
630 }
631 }
632};
633}
634xmlDocUniquePtr Primitive2dXmlDump::dumpAndParse(
635 const drawinglayer::primitive2d::Primitive2DContainer& rPrimitive2DSequence,
636 const OUString& rStreamName)
637{
638 std::unique_ptr<SvStream> pStream;
639
640 if (rStreamName.isEmpty())
641 pStream.reset(new SvMemoryStream());
642 else
643 pStream.reset(new SvFileStream(rStreamName, StreamMode::STD_READWRITE | StreamMode::TRUNC));
644
645 ::tools::XmlWriter aWriter(pStream.get());
646 aWriter.startDocument();
647 aWriter.startElement("primitive2D");
648
649 decomposeAndWrite(rPrimitive2DSequence, aWriter);
650
651 aWriter.endElement();
652 aWriter.endDocument();
653
654 pStream->Seek(STREAM_SEEK_TO_BEGIN);
655
656 std::size_t nSize = pStream->remainingSize();
657 std::unique_ptr<sal_uInt8[]> pBuffer(new sal_uInt8[nSize + 1]);
658 pStream->ReadBytes(pBuffer.get(), nSize);
659 pBuffer[nSize] = 0;
660 SAL_INFO("drawinglayer", "Parsed XML: " << pBuffer.get());
661
662 return xmlDocUniquePtr(xmlParseDoc(reinterpret_cast<xmlChar*>(pBuffer.get())));
663}
664
665void Primitive2dXmlDump::decomposeAndWrite(
666 const drawinglayer::primitive2d::Primitive2DContainer& rPrimitive2DSequence,
667 ::tools::XmlWriter& rWriter)
668{
669 for (size_t i = 0; i < rPrimitive2DSequence.size(); i++)
670 {
671 const BasePrimitive2D* pBasePrimitive = rPrimitive2DSequence[i].get();
672 sal_uInt32 nId = pBasePrimitive->getPrimitive2DID();
673 if (nId < maFilter.size() && maFilter[nId])
674 continue;
675
676 OUString sCurrentElementTag = drawinglayer::primitive2d::idToString(nId);
677
678 switch (nId)
679 {
680 case PRIMITIVE2D_ID_BITMAPPRIMITIVE2D:
681 {
682 const BitmapPrimitive2D& rBitmapPrimitive2D
683 = dynamic_cast<const BitmapPrimitive2D&>(*pBasePrimitive);
684 rWriter.startElement("bitmap");
685 writeMatrix(rWriter, rBitmapPrimitive2D.getTransform());
686
687 const BitmapEx aBitmapEx(rBitmapPrimitive2D.getBitmap());
688 const Size& rSizePixel(aBitmapEx.GetSizePixel());
689
690 rWriter.attribute("height", rSizePixel.getHeight());
691 rWriter.attribute("width", rSizePixel.getWidth());
692 rWriter.attribute("checksum", OString(std::to_string(aBitmapEx.GetChecksum())));
693
694 for (tools::Long y = 0; y < rSizePixel.getHeight(); y++)
695 {
696 rWriter.startElement("data");
697 OUString aBitmapData = "";
698 for (tools::Long x = 0; x < rSizePixel.getHeight(); x++)
699 {
700 if (x != 0)
701 aBitmapData = aBitmapData + ",";
702 aBitmapData = aBitmapData + aBitmapEx.GetPixelColor(x, y).AsRGBHexString();
703 }
704 rWriter.attribute("row", aBitmapData);
705 rWriter.endElement();
706 }
707 rWriter.endElement();
708 }
709 break;
710 case PRIMITIVE2D_ID_HIDDENGEOMETRYPRIMITIVE2D:
711 {
712 const HiddenGeometryPrimitive2D& rHiddenGeometryPrimitive2D
713 = dynamic_cast<const HiddenGeometryPrimitive2D&>(*pBasePrimitive);
714 rWriter.startElement("hiddengeometry");
715 decomposeAndWrite(rHiddenGeometryPrimitive2D.getChildren(), rWriter);
716 rWriter.endElement();
717 }
718 break;
719
720 case PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D:
721 {
722 const TransformPrimitive2D& rTransformPrimitive2D
723 = dynamic_cast<const TransformPrimitive2D&>(*pBasePrimitive);
724 rWriter.startElement("transform");
725 writeMatrix(rWriter, rTransformPrimitive2D.getTransformation());
726 decomposeAndWrite(rTransformPrimitive2D.getChildren(), rWriter);
727 rWriter.endElement();
728 }
729 break;
730
731 case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D:
732 {
733 const PolyPolygonColorPrimitive2D& rPolyPolygonColorPrimitive2D
734 = dynamic_cast<const PolyPolygonColorPrimitive2D&>(*pBasePrimitive);
735
736 rWriter.startElement("polypolygoncolor");
737 rWriter.attribute("color",
738 convertColorToString(rPolyPolygonColorPrimitive2D.getBColor()));
739
740 const basegfx::B2DPolyPolygon& aB2DPolyPolygon(
741 rPolyPolygonColorPrimitive2D.getB2DPolyPolygon());
742 writePolyPolygon(rWriter, aB2DPolyPolygon);
743
744 rWriter.endElement();
745 }
746 break;
747 case PRIMITIVE2D_ID_POINTARRAYPRIMITIVE2D:
748 {
749 const PointArrayPrimitive2D& rPointArrayPrimitive2D
750 = dynamic_cast<const PointArrayPrimitive2D&>(*pBasePrimitive);
751 rWriter.startElement("pointarray");
752
753 rWriter.attribute("color",
754 convertColorToString(rPointArrayPrimitive2D.getRGBColor()));
755
756 const std::vector<basegfx::B2DPoint> aPositions
757 = rPointArrayPrimitive2D.getPositions();
758 for (std::vector<basegfx::B2DPoint>::const_iterator iter = aPositions.begin();
759 iter != aPositions.end(); ++iter)
760 {
761 rWriter.startElement("point");
762 rWriter.attribute("x", OUString::number(iter->getX()));
763 rWriter.attribute("y", OUString::number(iter->getY()));
764 rWriter.endElement();
765 }
766
767 rWriter.endElement();
768 }
769 break;
770
771 case PRIMITIVE2D_ID_POLYGONSTROKEARROWPRIMITIVE2D:
772 {
773 const PolygonStrokeArrowPrimitive2D& rPolygonStrokeArrowPrimitive2D
774 = dynamic_cast<const PolygonStrokeArrowPrimitive2D&>(*pBasePrimitive);
775 rWriter.startElement("polygonstrokearrow");
776
777 rWriter.startElement("polygon");
778 rWriter.content(basegfx::utils::exportToSvgPoints(
779 rPolygonStrokeArrowPrimitive2D.getB2DPolygon()));
780 rWriter.endElement();
781
782 if (rPolygonStrokeArrowPrimitive2D.getStart().getB2DPolyPolygon().count())
783 {
784 rWriter.startElement("linestartattribute");
785 rWriter.attribute("width",
786 rPolygonStrokeArrowPrimitive2D.getStart().getWidth());
787 rWriter.attribute("centered",
788 static_cast<sal_Int32>(
789 rPolygonStrokeArrowPrimitive2D.getStart().isCentered()));
790 writePolyPolygon(rWriter,
791 rPolygonStrokeArrowPrimitive2D.getStart().getB2DPolyPolygon());
792 rWriter.endElement();
793 }
794
795 if (rPolygonStrokeArrowPrimitive2D.getEnd().getB2DPolyPolygon().count())
796 {
797 rWriter.startElement("lineendattribute");
798 rWriter.attribute("width", rPolygonStrokeArrowPrimitive2D.getEnd().getWidth());
799 rWriter.attribute("centered",
800 static_cast<sal_Int32>(
801 rPolygonStrokeArrowPrimitive2D.getEnd().isCentered()));
802 writePolyPolygon(rWriter,
803 rPolygonStrokeArrowPrimitive2D.getEnd().getB2DPolyPolygon());
804 rWriter.endElement();
805 }
806
807 writeLineAttribute(rWriter, rPolygonStrokeArrowPrimitive2D.getLineAttribute());
808 writeStrokeAttribute(rWriter, rPolygonStrokeArrowPrimitive2D.getStrokeAttribute());
809 rWriter.endElement();
810 }
811 break;
812
813 case PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D:
814 {
815 const PolygonStrokePrimitive2D& rPolygonStrokePrimitive2D
816 = dynamic_cast<const PolygonStrokePrimitive2D&>(*pBasePrimitive);
817 rWriter.startElement("polygonstroke");
818
819 rWriter.startElement("polygon");
820 rWriter.content(
821 basegfx::utils::exportToSvgPoints(rPolygonStrokePrimitive2D.getB2DPolygon()));
822 rWriter.endElement();
823
824 writeLineAttribute(rWriter, rPolygonStrokePrimitive2D.getLineAttribute());
825 writeStrokeAttribute(rWriter, rPolygonStrokePrimitive2D.getStrokeAttribute());
826 rWriter.endElement();
827 }
828 break;
829 case PRIMITIVE2D_ID_POLYPOLYGONSTROKEPRIMITIVE2D:
830 {
831 const PolyPolygonStrokePrimitive2D& rPolyPolygonStrokePrimitive2D
832 = dynamic_cast<const PolyPolygonStrokePrimitive2D&>(*pBasePrimitive);
833 rWriter.startElement("polypolygonstroke");
834
835 writeLineAttribute(rWriter, rPolyPolygonStrokePrimitive2D.getLineAttribute());
836 writeStrokeAttribute(rWriter, rPolyPolygonStrokePrimitive2D.getStrokeAttribute());
837 writePolyPolygon(rWriter, rPolyPolygonStrokePrimitive2D.getB2DPolyPolygon());
838
839 rWriter.endElement();
840 }
841 break;
842
843 case PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D:
844 {
845 const PolygonHairlinePrimitive2D& rPolygonHairlinePrimitive2D
846 = dynamic_cast<const PolygonHairlinePrimitive2D&>(*pBasePrimitive);
847 rWriter.startElement("polygonhairline");
848
849 rWriter.attribute("color",
850 convertColorToString(rPolygonHairlinePrimitive2D.getBColor()));
851
852 rWriter.startElement("polygon");
853 rWriter.content(
854 basegfx::utils::exportToSvgPoints(rPolygonHairlinePrimitive2D.getB2DPolygon()));
855 rWriter.endElement();
856
857 rWriter.endElement();
858 }
859 break;
860
861 case PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D:
862 {
863 const TextDecoratedPortionPrimitive2D& rTextDecoratedPortionPrimitive2D
864 = dynamic_cast<const TextDecoratedPortionPrimitive2D&>(*pBasePrimitive);
865 rWriter.startElement("textdecoratedportion");
866 writeMatrix(rWriter, rTextDecoratedPortionPrimitive2D.getTextTransform());
867
868 rWriter.attribute("text", rTextDecoratedPortionPrimitive2D.getText());
869 rWriter.attribute(
870 "fontcolor",
871 convertColorToString(rTextDecoratedPortionPrimitive2D.getFontColor()));
872
873 const drawinglayer::attribute::FontAttribute& aFontAttribute
874 = rTextDecoratedPortionPrimitive2D.getFontAttribute();
875 rWriter.attribute("familyname", aFontAttribute.getFamilyName());
876 rWriter.endElement();
877 }
878 break;
879
880 case PRIMITIVE2D_ID_TEXTLINEPRIMITIVE2D:
881 {
882 const TextLinePrimitive2D& rTextLinePrimitive2D
883 = dynamic_cast<const TextLinePrimitive2D&>(*pBasePrimitive);
884 rWriter.startElement("textline");
885 writeMatrix(rWriter, rTextLinePrimitive2D.getObjectTransformation());
886
887 rWriter.attribute("width", rTextLinePrimitive2D.getWidth());
888 rWriter.attribute("offset", rTextLinePrimitive2D.getOffset());
889 rWriter.attribute("height", rTextLinePrimitive2D.getHeight());
890 rWriter.attribute("color",
891 convertColorToString(rTextLinePrimitive2D.getLineColor()));
892 rWriter.endElement();
893 }
894 break;
895
896 case PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D:
897 {
898 const TextSimplePortionPrimitive2D& rTextSimplePortionPrimitive2D
899 = dynamic_cast<const TextSimplePortionPrimitive2D&>(*pBasePrimitive);
900 rWriter.startElement("textsimpleportion");
901
902 basegfx::B2DVector aScale, aTranslate;
903 double fRotate, fShearX;
904 if (rTextSimplePortionPrimitive2D.getTextTransform().decompose(aScale, aTranslate,
905 fRotate, fShearX))
906 {
907 rWriter.attribute("width", aScale.getX());
908 rWriter.attribute("height", aScale.getY());
909 }
910 rWriter.attribute("x", aTranslate.getX());
911 rWriter.attribute("y", aTranslate.getY());
912 OUString aText = rTextSimplePortionPrimitive2D.getText();
913 // TODO share code with sax_fastparser::FastSaxSerializer::write().
914 rWriter.attribute("text", aText.replaceAll("␁", "&#9;"));
915 rWriter.attribute("fontcolor", convertColorToString(
916 rTextSimplePortionPrimitive2D.getFontColor()));
917
918 const drawinglayer::attribute::FontAttribute& aFontAttribute
919 = rTextSimplePortionPrimitive2D.getFontAttribute();
920 rWriter.attribute("familyname", aFontAttribute.getFamilyName());
921 const std::vector<double> aDx = rTextSimplePortionPrimitive2D.getDXArray();
922 if (aDx.size())
923 {
924 for (size_t iDx = 0; iDx < aDx.size(); ++iDx)
925 {
926 OString sName = "dx" + OString::number(iDx);
927 rWriter.attribute(sName, OString::number(aDx[iDx]));
928 }
929 }
930 rWriter.endElement();
931 }
932 break;
933
934 case PRIMITIVE2D_ID_GROUPPRIMITIVE2D:
935 {
936 const GroupPrimitive2D& rGroupPrimitive2D
937 = dynamic_cast<const GroupPrimitive2D&>(*pBasePrimitive);
938 rWriter.startElement("group");
939 decomposeAndWrite(rGroupPrimitive2D.getChildren(), rWriter);
940 rWriter.endElement();
941 }
942 break;
943
944 case PRIMITIVE2D_ID_MASKPRIMITIVE2D:
945 {
946 const MaskPrimitive2D& rMaskPrimitive2D
947 = dynamic_cast<const MaskPrimitive2D&>(*pBasePrimitive);
948 rWriter.startElement("mask");
949 writePolyPolygon(rWriter, rMaskPrimitive2D.getMask());
950 decomposeAndWrite(rMaskPrimitive2D.getChildren(), rWriter);
951 rWriter.endElement();
952 }
953 break;
954
955 case PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D:
956 {
957 const UnifiedTransparencePrimitive2D& rUnifiedTransparencePrimitive2D
958 = dynamic_cast<const UnifiedTransparencePrimitive2D&>(*pBasePrimitive);
959 rWriter.startElement("unifiedtransparence");
960 rWriter.attribute(
961 "transparence",
962 std::lround(100 * rUnifiedTransparencePrimitive2D.getTransparence()));
963 decomposeAndWrite(rUnifiedTransparencePrimitive2D.getChildren(), rWriter);
964 rWriter.endElement();
965 }
966 break;
967
968 case PRIMITIVE2D_ID_OBJECTINFOPRIMITIVE2D:
969 {
970 const ObjectInfoPrimitive2D& rObjectInfoPrimitive2D
971 = dynamic_cast<const ObjectInfoPrimitive2D&>(*pBasePrimitive);
972 rWriter.startElement("objectinfo");
973
974 decomposeAndWrite(rObjectInfoPrimitive2D.getChildren(), rWriter);
975 rWriter.endElement();
976 }
977 break;
978
979 case PRIMITIVE2D_ID_STRUCTURETAGPRIMITIVE2D:
980 {
981 const StructureTagPrimitive2D& rStructureTagPrimitive2D
982 = dynamic_cast<const StructureTagPrimitive2D&>(*pBasePrimitive);
983 rWriter.startElement("structuretag");
984 rWriter.attribute("structureelement",
985 rStructureTagPrimitive2D.getStructureElement());
986
987 decomposeAndWrite(rStructureTagPrimitive2D.getChildren(), rWriter);
988 rWriter.endElement();
989 }
990 break;
991
992 case PRIMITIVE2D_ID_SVGRADIALGRADIENTPRIMITIVE2D:
993 {
994 const SvgRadialGradientPrimitive2D& rSvgRadialGradientPrimitive2D
995 = dynamic_cast<const SvgRadialGradientPrimitive2D&>(*pBasePrimitive);
996 rWriter.startElement("svgradialgradient");
997 if (rSvgRadialGradientPrimitive2D.isFocalSet())
998 {
999 basegfx::B2DPoint aFocalAttribute = rSvgRadialGradientPrimitive2D.getFocal();
1000 rWriter.attribute("focalx", aFocalAttribute.getX());
1001 rWriter.attribute("focaly", aFocalAttribute.getY());
1002 }
1003
1004 basegfx::B2DPoint aStartPoint = rSvgRadialGradientPrimitive2D.getStart();
1005 rWriter.attribute("startx", aStartPoint.getX());
1006 rWriter.attribute("starty", aStartPoint.getY());
1007 rWriter.attribute("radius",
1008 OString::number(rSvgRadialGradientPrimitive2D.getRadius()));
1009 writeSpreadMethod(rWriter, rSvgRadialGradientPrimitive2D.getSpreadMethod());
1010 rWriter.attributeDouble(
1011 "opacity",
1012 rSvgRadialGradientPrimitive2D.getGradientEntries().front().getOpacity());
1013
1014 rWriter.startElement("transform");
1015 writeMatrix(rWriter, rSvgRadialGradientPrimitive2D.getGradientTransform());
1016 rWriter.endElement();
1017
1018 writePolyPolygon(rWriter, rSvgRadialGradientPrimitive2D.getPolyPolygon());
1019 rWriter.endElement();
1020 }
1021 break;
1022
1023 case PRIMITIVE2D_ID_SVGLINEARGRADIENTPRIMITIVE2D:
1024 {
1025 const SvgLinearGradientPrimitive2D& rSvgLinearGradientPrimitive2D
1026 = dynamic_cast<const SvgLinearGradientPrimitive2D&>(*pBasePrimitive);
1027 rWriter.startElement("svglineargradient");
1028 basegfx::B2DPoint aStartAttribute = rSvgLinearGradientPrimitive2D.getStart();
1029 basegfx::B2DPoint aEndAttribute = rSvgLinearGradientPrimitive2D.getEnd();
1030
1031 rWriter.attribute("startx", aStartAttribute.getX());
1032 rWriter.attribute("starty", aStartAttribute.getY());
1033 rWriter.attribute("endx", aEndAttribute.getX());
1034 rWriter.attribute("endy", aEndAttribute.getY());
1035 writeSpreadMethod(rWriter, rSvgLinearGradientPrimitive2D.getSpreadMethod());
1036 rWriter.attributeDouble(
1037 "opacity",
1038 rSvgLinearGradientPrimitive2D.getGradientEntries().front().getOpacity());
1039
1040 rWriter.startElement("transform");
1041 writeMatrix(rWriter, rSvgLinearGradientPrimitive2D.getGradientTransform());
1042 rWriter.endElement();
1043
1044 writePolyPolygon(rWriter, rSvgLinearGradientPrimitive2D.getPolyPolygon());
1045
1046 rWriter.endElement();
1047 }
1048 break;
1049
1050 case PRIMITIVE2D_ID_METAFILEPRIMITIVE2D:
1051 {
1052 const MetafilePrimitive2D& rMetafilePrimitive2D
1053 = dynamic_cast<const MetafilePrimitive2D&>(*pBasePrimitive);
1054 rWriter.startElement("metafile");
1055 drawinglayer::primitive2d::Primitive2DContainer aPrimitiveContainer;
1056 // since the graphic is not rendered in a document, we do not need a concrete view information
1057 rMetafilePrimitive2D.get2DDecomposition(
1058 aPrimitiveContainer, drawinglayer::geometry::ViewInformation2D());
1059 decomposeAndWrite(aPrimitiveContainer, rWriter);
1060 rWriter.endElement();
1061 }
1062
1063 break;
1064
1065 case PRIMITIVE2D_ID_SDRRECTANGLEPRIMITIVE2D:
1066 {
1067 // SdrRectanglePrimitive2D is private to us.
1068 rWriter.startElement("sdrrectangle");
1069 drawinglayer::primitive2d::Primitive2DContainer aPrimitiveContainer;
1070 pBasePrimitive->get2DDecomposition(aPrimitiveContainer,
1071 drawinglayer::geometry::ViewInformation2D());
1072 decomposeAndWrite(aPrimitiveContainer, rWriter);
1073 rWriter.endElement();
1074 break;
1075 }
1076
1077 case PRIMITIVE2D_ID_SDRBLOCKTEXTPRIMITIVE2D:
1078 {
1079 // SdrBlockTextPrimitive2D is private to us.
1080 rWriter.startElement("sdrblocktext");
1081 drawinglayer::primitive2d::Primitive2DContainer aPrimitiveContainer;
1082 pBasePrimitive->get2DDecomposition(aPrimitiveContainer,
1083 drawinglayer::geometry::ViewInformation2D());
1084 decomposeAndWrite(aPrimitiveContainer, rWriter);
1085 rWriter.endElement();
1086 break;
1087 }
1088
1089 case PRIMITIVE2D_ID_TEXTHIERARCHYBLOCKPRIMITIVE2D:
1090 {
1091 // TextHierarchyBlockPrimitive2D.
1092 rWriter.startElement("texthierarchyblock");
1093 drawinglayer::primitive2d::Primitive2DContainer aPrimitiveContainer;
1094 pBasePrimitive->get2DDecomposition(aPrimitiveContainer,
1095 drawinglayer::geometry::ViewInformation2D());
1096 decomposeAndWrite(aPrimitiveContainer, rWriter);
1097 rWriter.endElement();
1098 break;
1099 }
1100
1101 case PRIMITIVE2D_ID_TEXTHIERARCHYPARAGRAPHPRIMITIVE2D:
1102 {
1103 // TextHierarchyParagraphPrimitive2D.
1104 rWriter.startElement("texthierarchyparagraph");
1105 drawinglayer::primitive2d::Primitive2DContainer aPrimitiveContainer;
1106 pBasePrimitive->get2DDecomposition(aPrimitiveContainer,
1107 drawinglayer::geometry::ViewInformation2D());
1108 decomposeAndWrite(aPrimitiveContainer, rWriter);
1109 rWriter.endElement();
1110 break;
1111 }
1112
1113 case PRIMITIVE2D_ID_TEXTHIERARCHYLINEPRIMITIVE2D:
1114 {
1115 // TextHierarchyLinePrimitive2D.
1116 rWriter.startElement("texthierarchyline");
1117 drawinglayer::primitive2d::Primitive2DContainer aPrimitiveContainer;
1118 pBasePrimitive->get2DDecomposition(aPrimitiveContainer,
1119 drawinglayer::geometry::ViewInformation2D());
1120 decomposeAndWrite(aPrimitiveContainer, rWriter);
1121 rWriter.endElement();
1122 break;
1123 }
1124
1125 case PRIMITIVE2D_ID_SHADOWPRIMITIVE2D:
1126 {
1127 // ShadowPrimitive2D.
1128 const ShadowPrimitive2D& rShadowPrimitive2D
1129 = dynamic_cast<const ShadowPrimitive2D&>(*pBasePrimitive);
1130 rWriter.startElement("shadow");
1131 rWriter.attribute("color",
1132 convertColorToString(rShadowPrimitive2D.getShadowColor()));
1133 rWriter.attributeDouble("blur", rShadowPrimitive2D.getShadowBlur());
1134
1135 rWriter.startElement("transform");
1136 writeMatrix(rWriter, rShadowPrimitive2D.getShadowTransform());
1137 rWriter.endElement();
1138
1139 rWriter.endElement();
1140 break;
1141 }
1142
1143 case PRIMITIVE2D_ID_MODIFIEDCOLORPRIMITIVE2D:
1144 {
1145 // ModifiedColorPrimitive2D.
1146 const ModifiedColorPrimitive2D& rModifiedColorPrimitive2D
1147 = dynamic_cast<const ModifiedColorPrimitive2D&>(*pBasePrimitive);
1148 rWriter.startElement("modifiedColor");
1149 const basegfx::BColorModifierSharedPtr& aColorModifier
1150 = rModifiedColorPrimitive2D.getColorModifier();
1151 rWriter.attribute("modifier", aColorModifier->getModifierName());
1152
1153 decomposeAndWrite(rModifiedColorPrimitive2D.getChildren(), rWriter);
1154 rWriter.endElement();
1155 break;
1156 }
1157 case PRIMITIVE2D_ID_SOFTEDGEPRIMITIVE2D:
1158 {
1159 // SoftEdgePrimitive2D.
1160 const SoftEdgePrimitive2D& rSoftEdgePrimitive2D
1161 = dynamic_cast<const SoftEdgePrimitive2D&>(*pBasePrimitive);
1162 rWriter.startElement("softedge");
1163 rWriter.attribute("radius", OUString::number(rSoftEdgePrimitive2D.getRadius()));
1164
1165 decomposeAndWrite(rSoftEdgePrimitive2D.getChildren(), rWriter);
1166 rWriter.endElement();
1167 break;
1168 }
1169
1170 case PRIMITIVE2D_ID_SCENEPRIMITIVE2D:
1171 {
1172 const auto& rScenePrimitive2D
1173 = dynamic_cast<const drawinglayer::primitive2d::ScenePrimitive2D&>(
1174 *pBasePrimitive);
1175 rWriter.startElement("scene");
1176
1177 auto const& rSceneAttribute = rScenePrimitive2D.getSdrSceneAttribute();
1178
1179 rWriter.attribute("shadowSlant", rSceneAttribute.getShadowSlant());
1180 rWriter.attribute("isTwoSidedLighting",
1181 sal_Int32(rSceneAttribute.getTwoSidedLighting()));
1182 writeShadeMode(rWriter, rSceneAttribute.getShadeMode());
1183 writeProjectionMode(rWriter, rSceneAttribute.getProjectionMode());
1184
1185 auto const& rLightingAttribute = rScenePrimitive2D.getSdrLightingAttribute();
1186 rWriter.attribute("ambientLightColor",
1187 convertColorToString(rLightingAttribute.getAmbientLightColor()));
1188 rWriter.startElement("lights");
1189 for (auto const& rLight : rLightingAttribute.getLightVector())
1190 {
1191 rWriter.startElement("light");
1192 rWriter.attribute("color", convertColorToString(rLight.getColor()));
1193 rWriter.attribute("directionVectorX", rLight.getDirection().getX());
1194 rWriter.attribute("directionVectorY", rLight.getDirection().getY());
1195 rWriter.attribute("specular", sal_Int32(rLight.getSpecular()));
1196 rWriter.endElement();
1197 }
1198 rWriter.endElement();
1199
1200 Primitive3DXmlDump aPrimitive3DXmlDump;
1201 aPrimitive3DXmlDump.decomposeAndWrite(rScenePrimitive2D.getChildren3D(), rWriter);
1202
1203 rWriter.endElement();
1204 break;
1205 }
1206
1207 default:
1208 {
1209 const char* aName = "unhandled";
1210 switch (nId)
1211 {
1212 case PRIMITIVE2D_ID_RANGE_SVX | 14: // PRIMITIVE2D_ID_SDRCELLPRIMITIVE2D
1213 {
1214 aName = "sdrCell";
1215 break;
1216 }
1217 }
1218 rWriter.startElement(aName);
1219 rWriter.attribute("id", sCurrentElementTag);
1220 rWriter.attribute("idNumber", nId);
1221
1222 auto pBufferedDecomposition
1223 = dynamic_cast<const BufferedDecompositionPrimitive2D*>(pBasePrimitive);
1224 if (pBufferedDecomposition)
1225 {
1226 rWriter.attribute(
1227 "transparenceForShadow",
1228 OString::number(pBufferedDecomposition->getTransparenceForShadow()));
1229 }
1230
1231 drawinglayer::primitive2d::Primitive2DContainer aPrimitiveContainer;
1232 pBasePrimitive->get2DDecomposition(aPrimitiveContainer,
1233 drawinglayer::geometry::ViewInformation2D());
1234 decomposeAndWrite(aPrimitiveContainer, rWriter);
1235 rWriter.endElement();
1236 }
1237 break;
1238 }
1239 }
1240}
1241
1242} // end namespace drawinglayer
1243
1244/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
BitmapEx::GetPixelColor
::Color GetPixelColor(sal_Int32 nX, sal_Int32 nY) const
BitmapEx::GetChecksum
BitmapChecksum GetChecksum() const
BitmapEx::GetSizePixel
const Size & GetSizePixel() const
Color::AsRGBHexString
OUString AsRGBHexString() const
Size::getHeight
constexpr tools::Long getHeight() const
Size::getWidth
constexpr tools::Long getWidth() const
basegfx::B2DHomMatrix::decompose
bool decompose(B2DTuple &rScale, B2DTuple &rTranslate, double &rRotate, double &rShearX) const
basegfx::B2DHomMatrix::get
double get(sal_uInt16 nRow, sal_uInt16 nColumn) const
basegfx::B2DPolyPolygon::getB2DRange
B2DRange getB2DRange() const
basegfx::B2DPolyPolygon::count
sal_uInt32 count() const
basegfx::B3DHomMatrix::get
double get(sal_uInt16 nRow, sal_uInt16 nColumn) const
basegfx::Tuple2D::getX
TYPE getX() const
basegfx::Tuple2D::getY
TYPE getY() const
drawinglayer::Primitive2dXmlDump::dump
void dump(const drawinglayer::primitive2d::Primitive2DContainer &rPrimitive2DSequence, const OUString &rStreamName)
Dumps the input primitive sequence to xml into a file.
Definition: primitive2dxmldump.cxx:516
drawinglayer::Primitive2dXmlDump::dumpAndParse
xmlDocUniquePtr dumpAndParse(const drawinglayer::primitive2d::Primitive2DContainer &aPrimitive2DSequence, const OUString &rStreamName=OUString())
Dumps the input primitive sequence to xml into a file or memory stream and parses the xml for testing...
Definition: primitive2dxmldump.cxx:634
drawinglayer::Primitive2dXmlDump::decomposeAndWrite
void decomposeAndWrite(const drawinglayer::primitive2d::Primitive2DContainer &rPrimitive2DSequence, tools::XmlWriter &rWriter)
Definition: primitive2dxmldump.cxx:665
drawinglayer::attribute::FontAttribute::getFamilyName
const OUString & getFamilyName() const
data read access
drawinglayer::attribute::LineAttribute::getLineJoin
basegfx::B2DLineJoin getLineJoin() const
Definition: lineattribute.cxx:135
drawinglayer::attribute::LineAttribute::getLineCap
css::drawing::LineCap getLineCap() const
Definition: lineattribute.cxx:140
drawinglayer::attribute::LineAttribute::getColor
const basegfx::BColor & getColor() const
Definition: lineattribute.cxx:125
drawinglayer::attribute::LineStartEndAttribute::getB2DPolyPolygon
const basegfx::B2DPolyPolygon & getB2DPolyPolygon() const
Definition: linestartendattribute.cxx:114
drawinglayer::attribute::SdrFillAttribute::getColor
const basegfx::BColor & getColor() const
Definition: sdrfillattribute.cxx:144
drawinglayer::attribute::SdrFillAttribute::getHatch
const FillHatchAttribute & getHatch() const
Definition: sdrfillattribute.cxx:154
drawinglayer::attribute::SdrFillAttribute::getGradient
const FillGradientAttribute & getGradient() const
Definition: sdrfillattribute.cxx:149
drawinglayer::attribute::SdrFillAttribute::getFillGraphic
const SdrFillGraphicAttribute & getFillGraphic() const
Definition: sdrfillattribute.cxx:159
drawinglayer::attribute::SdrLineAttribute::getDotDashArray
const ::std::vector< double > & getDotDashArray() const
Definition: sdrlineattribute.cxx:164
drawinglayer::attribute::SdrLineAttribute::getColor
const basegfx::BColor & getColor() const
Definition: sdrlineattribute.cxx:159
drawinglayer::attribute::StrokeAttribute::getDotDashArray
const ::std::vector< double > & getDotDashArray() const
Definition: strokeattribute.cxx:113
drawinglayer::primitive2d::BasePrimitive2D::get2DDecomposition
virtual void get2DDecomposition(Primitive2DDecompositionVisitor &rVisitor, const geometry::ViewInformation2D &rViewInformation) const
The default implementation will return an empty sequence.
Definition: baseprimitive2d.cxx:77
drawinglayer::primitive2d::BasePrimitive2D::getPrimitive2DID
virtual sal_uInt32 getPrimitive2DID() const =0
provide unique ID for fast identifying of known primitive implementations in renderers.
drawinglayer::primitive2d::BitmapPrimitive2D::getTransform
const basegfx::B2DHomMatrix & getTransform() const
Definition: bitmapprimitive2d.hxx:51
drawinglayer::primitive2d::BitmapPrimitive2D::getBitmap
const BitmapEx & getBitmap() const
data read access
Definition: bitmapprimitive2d.hxx:50
drawinglayer::primitive2d::BufferedDecompositionPrimitive2D::get2DDecomposition
virtual void get2DDecomposition(Primitive2DDecompositionVisitor &rVisitor, const geometry::ViewInformation2D &rViewInformation) const override
The getDecomposition default implementation will on demand use create2DDecomposition() if maBuffered2...
Definition: BufferedDecompositionPrimitive2D.cxx:29
drawinglayer::primitive2d::GroupPrimitive2D::getChildren
const Primitive2DContainer & getChildren() const
data read access
Definition: groupprimitive2d.hxx:74
drawinglayer::primitive2d::MaskPrimitive2D::getMask
const basegfx::B2DPolyPolygon & getMask() const
data read access
Definition: maskprimitive2d.hxx:57
drawinglayer::primitive2d::ModifiedColorPrimitive2D::getColorModifier
const basegfx::BColorModifierSharedPtr & getColorModifier() const
data read access
Definition: modifiedcolorprimitive2d.hxx:60
drawinglayer::primitive2d::PointArrayPrimitive2D::getPositions
const std::vector< basegfx::B2DPoint > & getPositions() const
data read access
Definition: pointarrayprimitive2d.hxx:59
drawinglayer::primitive2d::PolyPolygonColorPrimitive2D::getB2DPolyPolygon
const basegfx::B2DPolyPolygon & getB2DPolyPolygon() const
data read access
Definition: PolyPolygonColorPrimitive2D.hxx:51
drawinglayer::primitive2d::PolyPolygonStrokePrimitive2D::getB2DPolyPolygon
const basegfx::B2DPolyPolygon & getB2DPolyPolygon() const
data read access
Definition: PolyPolygonStrokePrimitive2D.hxx:65
drawinglayer::primitive2d::PolygonHairlinePrimitive2D::getB2DPolygon
const basegfx::B2DPolygon & getB2DPolygon() const
data read access
Definition: PolygonHairlinePrimitive2D.hxx:52
drawinglayer::primitive2d::PolygonStrokeArrowPrimitive2D::getStart
const attribute::LineStartEndAttribute & getStart() const
data read access
Definition: PolygonStrokeArrowPrimitive2D.hxx:62
drawinglayer::primitive2d::PolygonStrokeArrowPrimitive2D::getEnd
const attribute::LineStartEndAttribute & getEnd() const
Definition: PolygonStrokeArrowPrimitive2D.hxx:63
drawinglayer::primitive2d::PolygonStrokePrimitive2D::getStrokeAttribute
const attribute::StrokeAttribute & getStrokeAttribute() const
Definition: PolygonStrokePrimitive2D.hxx:71
drawinglayer::primitive2d::PolygonStrokePrimitive2D::getB2DPolygon
const basegfx::B2DPolygon & getB2DPolygon() const
data read access
Definition: PolygonStrokePrimitive2D.hxx:69
drawinglayer::primitive2d::PolygonStrokePrimitive2D::getLineAttribute
const attribute::LineAttribute & getLineAttribute() const
Definition: PolygonStrokePrimitive2D.hxx:70
drawinglayer::primitive2d::ShadowPrimitive2D::getShadowColor
const basegfx::BColor & getShadowColor() const
Definition: shadowprimitive2d.hxx:79
drawinglayer::primitive2d::ShadowPrimitive2D::getShadowTransform
const basegfx::B2DHomMatrix & getShadowTransform() const
data read access
Definition: shadowprimitive2d.hxx:78
drawinglayer::primitive2d::StructureTagPrimitive2D::getStructureElement
const vcl::PDFWriter::StructElement & getStructureElement() const
data read access
Definition: structuretagprimitive2d.hxx:68
drawinglayer::primitive2d::SvgLinearGradientPrimitive2D::getEnd
const basegfx::B2DPoint & getEnd() const
data read access
Definition: svggradientprimitive2d.hxx:203
drawinglayer::primitive2d::TextLinePrimitive2D::getObjectTransformation
const basegfx::B2DHomMatrix & getObjectTransformation() const
data read access
Definition: textlineprimitive2d.hxx:57
drawinglayer::primitive2d::TextSimplePortionPrimitive2D::getDXArray
const ::std::vector< double > & getDXArray() const
Definition: textprimitive2d.hxx:165
drawinglayer::primitive2d::TextSimplePortionPrimitive2D::getFontAttribute
const attribute::FontAttribute & getFontAttribute() const
Definition: textprimitive2d.hxx:167
drawinglayer::primitive2d::TextSimplePortionPrimitive2D::getTextTransform
const basegfx::B2DHomMatrix & getTextTransform() const
data read access
Definition: textprimitive2d.hxx:161
drawinglayer::primitive2d::TransformPrimitive2D::getTransformation
const basegfx::B2DHomMatrix & getTransformation() const
data read access
Definition: transformprimitive2d.hxx:62
tools::XmlWriter::content
void content(const OString &sValue)
tools::XmlWriter::startDocument
bool startDocument(sal_Int32 nIndent=2, bool bWriteXmlHeader=true)
tools::XmlWriter::attributeDouble
void attributeDouble(const char *sTagName, double aNumber)
tools::XmlWriter::attribute
void attribute(const char *sTagName, const OString &aValue)
tools::XmlWriter::startElement
void startElement(const char *sName)
drawinglayer_primitivetypes2d.hxx
PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D
#define PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:67
PRIMITIVE2D_ID_SCENEPRIMITIVE2D
#define PRIMITIVE2D_ID_SCENEPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:64
PRIMITIVE2D_ID_TEXTHIERARCHYBLOCKPRIMITIVE2D
#define PRIMITIVE2D_ID_TEXTHIERARCHYBLOCKPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:74
PRIMITIVE2D_ID_TEXTHIERARCHYLINEPRIMITIVE2D
#define PRIMITIVE2D_ID_TEXTHIERARCHYLINEPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:72
PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D
#define PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:69
PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D
#define PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:68
PRIMITIVE2D_ID_POLYPOLYGONSTROKEPRIMITIVE2D
#define PRIMITIVE2D_ID_POLYPOLYGONSTROKEPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:58
PRIMITIVE2D_ID_SOFTEDGEPRIMITIVE2D
#define PRIMITIVE2D_ID_SOFTEDGEPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:106
PRIMITIVE2D_ID_HIDDENGEOMETRYPRIMITIVE2D
#define PRIMITIVE2D_ID_HIDDENGEOMETRYPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:95
PRIMITIVE2D_ID_TEXTHIERARCHYPARAGRAPHPRIMITIVE2D
#define PRIMITIVE2D_ID_TEXTHIERARCHYPARAGRAPHPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:73
PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D
#define PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:60
PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D
#define PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:54
PRIMITIVE2D_ID_TEXTLINEPRIMITIVE2D
#define PRIMITIVE2D_ID_TEXTLINEPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:90
PRIMITIVE2D_ID_MODIFIEDCOLORPRIMITIVE2D
#define PRIMITIVE2D_ID_MODIFIEDCOLORPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:53
PRIMITIVE2D_ID_STRUCTURETAGPRIMITIVE2D
#define PRIMITIVE2D_ID_STRUCTURETAGPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:83
PRIMITIVE2D_ID_GROUPPRIMITIVE2D
#define PRIMITIVE2D_ID_GROUPPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:47
PRIMITIVE2D_ID_POINTARRAYPRIMITIVE2D
#define PRIMITIVE2D_ID_POINTARRAYPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:70
PRIMITIVE2D_ID_SHADOWPRIMITIVE2D
#define PRIMITIVE2D_ID_SHADOWPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:65
PRIMITIVE2D_ID_MASKPRIMITIVE2D
#define PRIMITIVE2D_ID_MASKPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:50
PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D
#define PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:56
PRIMITIVE2D_ID_METAFILEPRIMITIVE2D
#define PRIMITIVE2D_ID_METAFILEPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:52
PRIMITIVE2D_ID_BITMAPPRIMITIVE2D
#define PRIMITIVE2D_ID_BITMAPPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:39
PRIMITIVE2D_ID_SVGLINEARGRADIENTPRIMITIVE2D
#define PRIMITIVE2D_ID_SVGLINEARGRADIENTPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:96
PRIMITIVE2D_ID_POLYGONSTROKEARROWPRIMITIVE2D
#define PRIMITIVE2D_ID_POLYGONSTROKEARROWPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:57
PRIMITIVE2D_ID_OBJECTINFOPRIMITIVE2D
#define PRIMITIVE2D_ID_OBJECTINFOPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:102
PRIMITIVE2D_ID_RANGE_SVX
#define PRIMITIVE2D_ID_RANGE_SVX
Definition: drawinglayer_primitivetypes2d.hxx:26
PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D
#define PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:66
PRIMITIVE2D_ID_SVGRADIALGRADIENTPRIMITIVE2D
#define PRIMITIVE2D_ID_SVGRADIALGRADIENTPRIMITIVE2D
Definition: drawinglayer_primitivetypes2d.hxx:97
drawinglayer_primitivetypes3d.hxx
PRIMITIVE3D_ID_SDREXTRUDEPRIMITIVE3D
#define PRIMITIVE3D_ID_SDREXTRUDEPRIMITIVE3D
Definition: drawinglayer_primitivetypes3d.hxx:39
y
float y
x
float x
sName
OUString sName
aName
OUString aName
a
uno_Any a
SAL_INFO
#define SAL_INFO(area, stream)
basegfx::utils::exportToSvgD
OUString exportToSvgD(const B2DPolyPolygon &rPolyPoly, bool bUseRelativeCoordinates, bool bDetectQuadraticBeziers, bool bHandleRelativeNextPointCompatible, bool bOOXMLMotionPath=false)
basegfx::utils::exportToSvgPoints
OUString exportToSvgPoints(const B2DPolygon &rPoly)
basegfx::BColorModifierSharedPtr
std::shared_ptr< BColorModifier > BColorModifierSharedPtr
basegfx::rad2deg
constexpr double rad2deg(double v)
drawinglayer::primitive2d::idToString
OUString idToString(sal_uInt32 nId)
Definition: primitive2d/Tools.cxx:78
drawinglayer::primitive3d::Primitive3DReference
css::uno::Reference< css::graphic::XPrimitive3D > Primitive3DReference
Definition: baseprimitive3d.hxx:54
drawinglayer::primitive3d::idToString
OUString idToString(sal_uInt32 nId)
Definition: primitive3d/Tools.cxx:18
i
int i
tools::Long
long Long
nId
sal_Int16 nId
STREAM_SEEK_TO_BEGIN
#define STREAM_SEEK_TO_BEGIN
svx_primitivetypes2d.hxx
PRIMITIVE2D_ID_SDRRECTANGLEPRIMITIVE2D
#define PRIMITIVE2D_ID_SDRRECTANGLEPRIMITIVE2D
PRIMITIVE2D_ID_SDRBLOCKTEXTPRIMITIVE2D
#define PRIMITIVE2D_ID_SDRBLOCKTEXTPRIMITIVE2D
sal_uInt8
unsigned char sal_uInt8
xmlDocUniquePtr
std::unique_ptr< xmlDoc, xmlDocDeleter > xmlDocUniquePtr
Generated on Sun Jul 30 2023 04:42:56 for LibreOffice Module drawinglayer (master) by doxygen 1.9.3