?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fdo#74697 Add Bluez 5 support for impress remote.
[LibreOffice.git] / drawinglayer / source / primitive2d / metafileprimitive2d.cxx
bloba7abeb66bc0baf1b3e29c287c758459a651a0ac5
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 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <drawinglayer/primitive2d/metafileprimitive2d.hxx>
21 #include <basegfx/tools/canvastools.hxx>
22 #include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
23 #include <basegfx/color/bcolor.hxx>
24 #include <drawinglayer/primitive2d/pointarrayprimitive2d.hxx>
25 #include <vcl/lineinfo.hxx>
26 #include <drawinglayer/attribute/lineattribute.hxx>
27 #include <drawinglayer/attribute/strokeattribute.hxx>
28 #include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
29 #include <vcl/metaact.hxx>
30 #include <drawinglayer/primitive2d/transformprimitive2d.hxx>
31 #include <basegfx/matrix/b2dhommatrixtools.hxx>
32 #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
33 #include <basegfx/polygon/b2dpolygontools.hxx>
34 #include <drawinglayer/primitive2d/discretebitmapprimitive2d.hxx>
35 #include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>
36 #include <vcl/salbtype.hxx>
37 #include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
38 #include <drawinglayer/primitive2d/fillgradientprimitive2d.hxx>
39 #include <vcl/svapp.hxx>
40 #include <drawinglayer/primitive2d/transparenceprimitive2d.hxx>
41 #include <drawinglayer/primitive2d/fillhatchprimitive2d.hxx>
42 #include <drawinglayer/primitive2d/maskprimitive2d.hxx>
43 #include <basegfx/polygon/b2dpolygonclipper.hxx>
44 #include <drawinglayer/primitive2d/invertprimitive2d.hxx>
45 #include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx>
46 #include <drawinglayer/primitive2d/fillbitmapprimitive2d.hxx>
47 #include <drawinglayer/primitive2d/wallpaperprimitive2d.hxx>
48 #include <drawinglayer/primitive2d/textprimitive2d.hxx>
49 #include <drawinglayer/primitive2d/textlayoutdevice.hxx>
50 #include <drawinglayer/primitive2d/textdecoratedprimitive2d.hxx>
51 #include <i18nlangtag/languagetag.hxx>
52 #include <drawinglayer/primitive2d/textlineprimitive2d.hxx>
53 #include <drawinglayer/primitive2d/textstrikeoutprimitive2d.hxx>
54 #include <drawinglayer/primitive2d/epsprimitive2d.hxx>
55 #include <numeric>
56
57 //////////////////////////////////////////////////////////////////////////////
58
59 using namespace com::sun::star;
60
61 //////////////////////////////////////////////////////////////////////////////
62
63 namespace
64 {
65 /** helper class for graphic context
66
67 This class allows to hold a complete status of classic
68 VCL OutputDevice stati. This data is needed for correct
69 interpretation of the MetaFile action flow.
70 */
71 class PropertyHolder
72 {
73 private:
74 /// current transformation (aka MapMode)
75 basegfx::B2DHomMatrix maTransformation;
76 MapUnit maMapUnit;
77
78 /// current colors
79 basegfx::BColor maLineColor;
80 basegfx::BColor maFillColor;
81 basegfx::BColor maTextColor;
82 basegfx::BColor maTextFillColor;
83 basegfx::BColor maTextLineColor;
84 basegfx::BColor maOverlineColor;
85
86 /// clipping
87 basegfx::B2DPolyPolygon maClipPolyPoygon;
88
89 /// font, etc.
90 Font maFont;
91 RasterOp maRasterOp;
92 sal_uInt32 mnLayoutMode;
93 LanguageType maLanguageType;
94 sal_uInt16 mnPushFlags;
95
96 /// bitfield
97 /// contains all active markers
98 bool mbLineColor : 1;
99 bool mbFillColor : 1;
100 bool mbTextColor : 1;
101 bool mbTextFillColor : 1;
102 bool mbTextLineColor : 1;
103 bool mbOverlineColor : 1;
104 bool mbClipPolyPolygonActive : 1;
105
106 public:
107 PropertyHolder()
108 : maTransformation(),
109 maMapUnit(MAP_100TH_MM),
110 maLineColor(),
111 maFillColor(),
112 maTextColor(COL_BLACK),
113 maTextFillColor(),
114 maTextLineColor(),
115 maOverlineColor(),
116 maClipPolyPoygon(),
117 maFont(),
118 maRasterOp(ROP_OVERPAINT),
119 mnLayoutMode(0),
120 maLanguageType(0),
121 mnPushFlags(0),
122 mbLineColor(false),
123 mbFillColor(false),
124 mbTextColor(true),
125 mbTextFillColor(false),
126 mbTextLineColor(false),
127 mbOverlineColor(false),
128 mbClipPolyPolygonActive(false)
129 {
130 }
131
132 ~PropertyHolder()
133 {
134 }
135
136 /// read/write accesses
137 const basegfx::B2DHomMatrix& getTransformation() const { return maTransformation; }
138 void setTransformation(const basegfx::B2DHomMatrix& rNew) { if(rNew != maTransformation) maTransformation = rNew; }
139
140 MapUnit getMapUnit() const { return maMapUnit; }
141 void setMapUnit(MapUnit eNew) { if(eNew != maMapUnit) maMapUnit = eNew; }
142
143 const basegfx::BColor& getLineColor() const { return maLineColor; }
144 void setLineColor(const basegfx::BColor& rNew) { if(rNew != maLineColor) maLineColor = rNew; }
145 bool getLineColorActive() const { return mbLineColor; }
146 void setLineColorActive(bool bNew) { if(bNew != mbLineColor) mbLineColor = bNew; }
147
148 const basegfx::BColor& getFillColor() const { return maFillColor; }
149 void setFillColor(const basegfx::BColor& rNew) { if(rNew != maFillColor) maFillColor = rNew; }
150 bool getFillColorActive() const { return mbFillColor; }
151 void setFillColorActive(bool bNew) { if(bNew != mbFillColor) mbFillColor = bNew; }
152
153 const basegfx::BColor& getTextColor() const { return maTextColor; }
154 void setTextColor(const basegfx::BColor& rNew) { if(rNew != maTextColor) maTextColor = rNew; }
155 bool getTextColorActive() const { return mbTextColor; }
156 void setTextColorActive(bool bNew) { if(bNew != mbTextColor) mbTextColor = bNew; }
157
158 const basegfx::BColor& getTextFillColor() const { return maTextFillColor; }
159 void setTextFillColor(const basegfx::BColor& rNew) { if(rNew != maTextFillColor) maTextFillColor = rNew; }
160 bool getTextFillColorActive() const { return mbTextFillColor; }
161 void setTextFillColorActive(bool bNew) { if(bNew != mbTextFillColor) mbTextFillColor = bNew; }
162
163 const basegfx::BColor& getTextLineColor() const { return maTextLineColor; }
164 void setTextLineColor(const basegfx::BColor& rNew) { if(rNew != maTextLineColor) maTextLineColor = rNew; }
165 bool getTextLineColorActive() const { return mbTextLineColor; }
166 void setTextLineColorActive(bool bNew) { if(bNew != mbTextLineColor) mbTextLineColor = bNew; }
167
168 const basegfx::BColor& getOverlineColor() const { return maOverlineColor; }
169 void setOverlineColor(const basegfx::BColor& rNew) { if(rNew != maOverlineColor) maOverlineColor = rNew; }
170 bool getOverlineColorActive() const { return mbOverlineColor; }
171 void setOverlineColorActive(bool bNew) { if(bNew != mbOverlineColor) mbOverlineColor = bNew; }
172
173 const basegfx::B2DPolyPolygon& getClipPolyPolygon() const { return maClipPolyPoygon; }
174 void setClipPolyPolygon(const basegfx::B2DPolyPolygon& rNew) { if(rNew != maClipPolyPoygon) maClipPolyPoygon = rNew; }
175 bool getClipPolyPolygonActive() const { return mbClipPolyPolygonActive; }
176 void setClipPolyPolygonActive(bool bNew) { if(bNew != mbClipPolyPolygonActive) mbClipPolyPolygonActive = bNew; }
177
178 const Font& getFont() const { return maFont; }
179 void setFont(const Font& rFont) { if(rFont != maFont) maFont = rFont; }
180
181 const RasterOp& getRasterOp() const { return maRasterOp; }
182 void setRasterOp(const RasterOp& rRasterOp) { if(rRasterOp != maRasterOp) maRasterOp = rRasterOp; }
183 bool isRasterOpInvert() const { return (ROP_XOR == maRasterOp || ROP_INVERT == maRasterOp); }
184 bool isRasterOpForceBlack() const { return ROP_0 == maRasterOp; }
185 bool isRasterOpActive() const { return isRasterOpInvert() || isRasterOpForceBlack(); }
186
187 sal_uInt32 getLayoutMode() const { return mnLayoutMode; }
188 void setLayoutMode(sal_uInt32 nNew) { if(nNew != mnLayoutMode) mnLayoutMode = nNew; }
189
190 LanguageType getLanguageType() const { return maLanguageType; }
191 void setLanguageType(LanguageType aNew) { if(aNew != maLanguageType) maLanguageType = aNew; }
192
193 sal_uInt16 getPushFlags() const { return mnPushFlags; }
194 void setPushFlags(sal_uInt16 nNew) { if(nNew != mnPushFlags) mnPushFlags = nNew; }
195
196 bool getLineOrFillActive() const { return (mbLineColor || mbFillColor); }
197 };
198 } // end of anonymous namespace
199
200 //////////////////////////////////////////////////////////////////////////////
201
202 namespace
203 {
204 /** stack for properites
205
206 This class builds a stack based on the PropertyHolder
207 class. It encapsulates the pointer/new/delete usage to
208 make it safe and implements the push/pop as needed by a
209 VCL Metafile interpreter. The critical part here are the
210 flag values VCL OutputDevice uses here; not all stuff is
211 pushed and thus needs to be copied at pop.
212 */
213 class PropertyHolders
214 {
215 private:
216 std::vector< PropertyHolder* > maPropertyHolders;
217
218 public:
219 PropertyHolders()
220 {
221 maPropertyHolders.push_back(new PropertyHolder());
222 }
223
224 sal_uInt32 size() const
225 {
226 return maPropertyHolders.size();
227 }
228
229 void PushDefault()
230 {
231 PropertyHolder* pNew = new PropertyHolder();
232 maPropertyHolders.push_back(pNew);
233 }
234
235 void Push(sal_uInt16 nPushFlags)
236 {
237 if(nPushFlags)
238 {
239 OSL_ENSURE(maPropertyHolders.size(), "PropertyHolders: PUSH with no property holders (!)");
240 if ( !maPropertyHolders.empty() )
241 {
242 PropertyHolder* pNew = new PropertyHolder(*maPropertyHolders.back());
243 pNew->setPushFlags(nPushFlags);
244 maPropertyHolders.push_back(pNew);
245 }
246 }
247 }
248
249 void Pop()
250 {
251 OSL_ENSURE(maPropertyHolders.size(), "PropertyHolders: POP with no property holders (!)");
252 const sal_uInt32 nSize(maPropertyHolders.size());
253
254 if(nSize)
255 {
256 const PropertyHolder* pTip = maPropertyHolders.back();
257 const sal_uInt16 nPushFlags(pTip->getPushFlags());
258
259 if(nPushFlags)
260 {
261 if(nSize > 1)
262 {
263 // copy back content for all non-set flags
264 PropertyHolder* pLast = maPropertyHolders[nSize - 2];
265
266 if(PUSH_ALL != nPushFlags)
267 {
268 if(!(nPushFlags & PUSH_LINECOLOR ))
269 {
270 pLast->setLineColor(pTip->getLineColor());
271 pLast->setLineColorActive(pTip->getLineColorActive());
272 }
273 if(!(nPushFlags & PUSH_FILLCOLOR ))
274 {
275 pLast->setFillColor(pTip->getFillColor());
276 pLast->setFillColorActive(pTip->getFillColorActive());
277 }
278 if(!(nPushFlags & PUSH_FONT ))
279 {
280 pLast->setFont(pTip->getFont());
281 }
282 if(!(nPushFlags & PUSH_TEXTCOLOR ))
283 {
284 pLast->setTextColor(pTip->getTextColor());
285 pLast->setTextColorActive(pTip->getTextColorActive());
286 }
287 if(!(nPushFlags & PUSH_MAPMODE ))
288 {
289 pLast->setTransformation(pTip->getTransformation());
290 pLast->setMapUnit(pTip->getMapUnit());
291 }
292 if(!(nPushFlags & PUSH_CLIPREGION ))
293 {
294 pLast->setClipPolyPolygon(pTip->getClipPolyPolygon());
295 pLast->setClipPolyPolygonActive(pTip->getClipPolyPolygonActive());
296 }
297 if(!(nPushFlags & PUSH_RASTEROP ))
298 {
299 pLast->setRasterOp(pTip->getRasterOp());
300 }
301 if(!(nPushFlags & PUSH_TEXTFILLCOLOR ))
302 {
303 pLast->setTextFillColor(pTip->getTextFillColor());
304 pLast->setTextFillColorActive(pTip->getTextFillColorActive());
305 }
306 if(!(nPushFlags & PUSH_TEXTALIGN ))
307 {
308 if(pLast->getFont().GetAlign() != pTip->getFont().GetAlign())
309 {
310 Font aFont(pLast->getFont());
311 aFont.SetAlign(pTip->getFont().GetAlign());
312 pLast->setFont(aFont);
313 }
314 }
315 if(!(nPushFlags & PUSH_REFPOINT ))
316 {
317 // not supported
318 }
319 if(!(nPushFlags & PUSH_TEXTLINECOLOR ))
320 {
321 pLast->setTextLineColor(pTip->getTextLineColor());
322 pLast->setTextLineColorActive(pTip->getTextLineColorActive());
323 }
324 if(!(nPushFlags & PUSH_TEXTLAYOUTMODE ))
325 {
326 pLast->setLayoutMode(pTip->getLayoutMode());
327 }
328 if(!(nPushFlags & PUSH_TEXTLANGUAGE ))
329 {
330 pLast->setLanguageType(pTip->getLanguageType());
331 }
332 if(!(nPushFlags & PUSH_OVERLINECOLOR ))
333 {
334 pLast->setOverlineColor(pTip->getOverlineColor());
335 pLast->setOverlineColorActive(pTip->getOverlineColorActive());
336 }
337 }
338 }
339 }
340
341 // execute the pop
342 delete maPropertyHolders.back();
343 maPropertyHolders.pop_back();
344 }
345 }
346
347 PropertyHolder& Current()
348 {
349 static PropertyHolder aDummy;
350 OSL_ENSURE(maPropertyHolders.size(), "PropertyHolders: CURRENT with no property holders (!)");
351 return maPropertyHolders.empty() ? aDummy : *maPropertyHolders.back();
352 }
353
354 ~PropertyHolders()
355 {
356 while(!maPropertyHolders.empty())
357 {
358 delete maPropertyHolders.back();
359 maPropertyHolders.pop_back();
360 }
361 }
362 };
363 } // end of anonymous namespace
364
365 //////////////////////////////////////////////////////////////////////////////
366
367 namespace
368 {
369 /** helper to convert a Region to a B2DPolyPolygon
370 when it does not yet contain one. In the future
371 this may be expanded to merge the polygons created
372 from rectangles or use a special algo to directly turn
373 the spans of regions to a single, already merged
374 PolyPolygon.
375 */
376 basegfx::B2DPolyPolygon getB2DPolyPolygonFromRegion(const Region& rRegion)
377 {
378 basegfx::B2DPolyPolygon aRetval;
379
380 if(!rRegion.IsEmpty())
381 {
382 Region aRegion(rRegion);
383 aRetval = aRegion.GetB2DPolyPolygon();
384
385 if(!aRetval.count())
386 {
387 RegionHandle aRegionHandle(aRegion.BeginEnumRects());
388 Rectangle aRegionRectangle;
389
390 while(aRegion.GetEnumRects(aRegionHandle, aRegionRectangle))
391 {
392 if(!aRegionRectangle.IsEmpty())
393 {
394 const basegfx::B2DRange aRegionRange(
395 aRegionRectangle.Left(), aRegionRectangle.Top(),
396 aRegionRectangle.Right(), aRegionRectangle.Bottom());
397 aRetval.append(basegfx::tools::createPolygonFromRect(aRegionRange));
398 }
399 }
400
401 aRegion.EndEnumRects(aRegionHandle);
402 }
403 }
404
405 return aRetval;
406 }
407 } // end of anonymous namespace
408
409 //////////////////////////////////////////////////////////////////////////////
410
411 namespace
412 {
413 /** Helper class to buffer and hold a Primive target vector. It
414 encapsulates the new/delete functionality and aloows to work
415 on pointers of the implementation classes. All data will
416 be converted to uno sequences of uno references when accessing the
417 data.
418 */
419 class TargetHolder
420 {
421 private:
422 std::vector< drawinglayer::primitive2d::BasePrimitive2D* > aTargets;
423
424 public:
425 TargetHolder()
426 : aTargets()
427 {
428 }
429
430 ~TargetHolder()
431 {
432 const sal_uInt32 nCount(aTargets.size());
433
434 for(sal_uInt32 a(0); a < nCount; a++)
435 {
436 delete aTargets[a];
437 }
438 }
439
440 sal_uInt32 size() const
441 {
442 return aTargets.size();
443 }
444
445 void append(drawinglayer::primitive2d::BasePrimitive2D* pCandidate)
446 {
447 if(pCandidate)
448 {
449 aTargets.push_back(pCandidate);
450 }
451 }
452
453 drawinglayer::primitive2d::Primitive2DSequence getPrimitive2DSequence(const PropertyHolder& rPropertyHolder)
454 {
455 const sal_uInt32 nCount(aTargets.size());
456 drawinglayer::primitive2d::Primitive2DSequence xRetval(nCount);
457
458 for(sal_uInt32 a(0); a < nCount; a++)
459 {
460 xRetval[a] = aTargets[a];
461 }
462
463 // All Targets were pointers, but do not need to be deleted since they
464 // were converted to UNO API references now, so they stay as long as
465 // referenced. Do NOT delete the C++ implementation classes here, but clear
466 // the buffer to not delete them in the destructor.
467 aTargets.clear();
468
469 if(xRetval.hasElements() && rPropertyHolder.getClipPolyPolygonActive())
470 {
471 const basegfx::B2DPolyPolygon& rClipPolyPolygon = rPropertyHolder.getClipPolyPolygon();
472
473 if(rClipPolyPolygon.count())
474 {
475 const drawinglayer::primitive2d::Primitive2DReference xMask(
476 new drawinglayer::primitive2d::MaskPrimitive2D(
477 rClipPolyPolygon,
478 xRetval));
479
480 xRetval = drawinglayer::primitive2d::Primitive2DSequence(&xMask, 1);
481 }
482 }
483
484 return xRetval;
485 }
486 };
487 } // end of anonymous namespace
488
489 //////////////////////////////////////////////////////////////////////////////
490
491 namespace
492 {
493 /** Helper class which builds a stack on the TargetHolder class */
494 class TargetHolders
495 {
496 private:
497 std::vector< TargetHolder* > maTargetHolders;
498
499 public:
500 TargetHolders()
501 {
502 maTargetHolders.push_back(new TargetHolder());
503 }
504
505 sal_uInt32 size() const
506 {
507 return maTargetHolders.size();
508 }
509
510 void Push()
511 {
512 maTargetHolders.push_back(new TargetHolder());
513 }
514
515 void Pop()
516 {
517 OSL_ENSURE(maTargetHolders.size(), "TargetHolders: POP with no property holders (!)");
518 if(!maTargetHolders.empty())
519 {
520 delete maTargetHolders.back();
521 maTargetHolders.pop_back();
522 }
523 }
524
525 TargetHolder& Current()
526 {
527 static TargetHolder aDummy;
528 OSL_ENSURE(maTargetHolders.size(), "TargetHolders: CURRENT with no property holders (!)");
529 return maTargetHolders.empty() ? aDummy : *maTargetHolders.back();
530 }
531
532 ~TargetHolders()
533 {
534 while(!maTargetHolders.empty())
535 {
536 delete maTargetHolders.back();
537 maTargetHolders.pop_back();
538 }
539 }
540 };
541 } // end of anonymous namespace
542
543 //////////////////////////////////////////////////////////////////////////////
544
545 namespace drawinglayer
546 {
547 namespace primitive2d
548 {
549 /** NonOverlappingFillGradientPrimitive2D class
550
551 This is a special version of the FillGradientPrimitive2D which decomposes
552 to a non-overlapping geometry version of the gradient. This needs to be
553 used to support the old XOR paint-'trick'.
554
555 It does not need an own identifier since a renderer who wants to interpret
556 it itself may do so. It just overloads the decomposition of the C++
557 implementation class to do an alternative decomposition.
558 */
559 class NonOverlappingFillGradientPrimitive2D : public FillGradientPrimitive2D
560 {
561 protected:
562 /// local decomposition.
563 virtual Primitive2DSequence create2DDecomposition(
564 const geometry::ViewInformation2D& rViewInformation) const;
565
566 public:
567 /// constructor
568 NonOverlappingFillGradientPrimitive2D(
569 const basegfx::B2DRange& rObjectRange,
570 const attribute::FillGradientAttribute& rFillGradient)
571 : FillGradientPrimitive2D(rObjectRange, rFillGradient)
572 {
573 }
574 };
575
576 Primitive2DSequence NonOverlappingFillGradientPrimitive2D::create2DDecomposition(
577 const geometry::ViewInformation2D& /*rViewInformation*/) const
578 {
579 if(!getFillGradient().isDefault())
580 {
581 return createFill(false);
582 }
583 else
584 {
585 return Primitive2DSequence();
586 }
587 }
588 } // end of namespace primitive2d
589 } // end of namespace drawinglayer
590
591 //////////////////////////////////////////////////////////////////////////////
592
593 namespace
594 {
595 /** helper to convert a MapMode to a transformation */
596 basegfx::B2DHomMatrix getTransformFromMapMode(const MapMode& rMapMode)
597 {
598 basegfx::B2DHomMatrix aMapping;
599 const Fraction aNoScale(1, 1);
600 const Point& rOrigin(rMapMode.GetOrigin());
601
602 if(0 != rOrigin.X() || 0 != rOrigin.Y())
603 {
604 aMapping.translate(rOrigin.X(), rOrigin.Y());
605 }
606
607 if(rMapMode.GetScaleX() != aNoScale || rMapMode.GetScaleY() != aNoScale)
608 {
609 aMapping.scale(
610 double(rMapMode.GetScaleX()),
611 double(rMapMode.GetScaleY()));
612 }
613
614 return aMapping;
615 }
616
617 /** helper to create a PointArrayPrimitive2D based on current context */
618 void createPointArrayPrimitive(
619 const std::vector< basegfx::B2DPoint >& rPositions,
620 TargetHolder& rTarget,
621 PropertyHolder& rProperties,
622 basegfx::BColor aBColor)
623 {
624 if(!rPositions.empty())
625 {
626 if(rProperties.getTransformation().isIdentity())
627 {
628 rTarget.append(
629 new drawinglayer::primitive2d::PointArrayPrimitive2D(
630 rPositions,
631 aBColor));
632 }
633 else
634 {
635 std::vector< basegfx::B2DPoint > aPositions(rPositions);
636
637 for(sal_uInt32 a(0); a < aPositions.size(); a++)
638 {
639 aPositions[a] = rProperties.getTransformation() * aPositions[a];
640 }
641
642 rTarget.append(
643 new drawinglayer::primitive2d::PointArrayPrimitive2D(
644 aPositions,
645 aBColor));
646 }
647 }
648 }
649
650 /** helper to create a PolygonHairlinePrimitive2D based on current context */
651 void createHairlinePrimitive(
652 const basegfx::B2DPolygon& rLinePolygon,
653 TargetHolder& rTarget,
654 PropertyHolder& rProperties)
655 {
656 if(rLinePolygon.count())
657 {
658 basegfx::B2DPolygon aLinePolygon(rLinePolygon);
659 aLinePolygon.transform(rProperties.getTransformation());
660 rTarget.append(
661 new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(
662 aLinePolygon,
663 rProperties.getLineColor()));
664 }
665 }
666
667 /** helper to create a PolyPolygonColorPrimitive2D based on current context */
668 void createFillPrimitive(
669 const basegfx::B2DPolyPolygon& rFillPolyPolygon,
670 TargetHolder& rTarget,
671 PropertyHolder& rProperties)
672 {
673 if(rFillPolyPolygon.count())
674 {
675 basegfx::B2DPolyPolygon aFillPolyPolygon(rFillPolyPolygon);
676 aFillPolyPolygon.transform(rProperties.getTransformation());
677 rTarget.append(
678 new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
679 aFillPolyPolygon,
680 rProperties.getFillColor()));
681 }
682 }
683
684 /** helper to create a PolygonStrokePrimitive2D based on current context */
685 void createLinePrimitive(
686 const basegfx::B2DPolygon& rLinePolygon,
687 const LineInfo& rLineInfo,
688 TargetHolder& rTarget,
689 PropertyHolder& rProperties)
690 {
691 if(rLinePolygon.count())
692 {
693 const bool bDashDotUsed(LINE_DASH == rLineInfo.GetStyle());
694 const bool bWidthUsed(rLineInfo.GetWidth() > 1);
695
696 if(bDashDotUsed || bWidthUsed)
697 {
698 basegfx::B2DPolygon aLinePolygon(rLinePolygon);
699 aLinePolygon.transform(rProperties.getTransformation());
700 const drawinglayer::attribute::LineAttribute aLineAttribute(
701 rProperties.getLineColor(),
702 bWidthUsed ? rLineInfo.GetWidth() : 0.0,
703 rLineInfo.GetLineJoin(),
704 rLineInfo.GetLineCap());
705
706 if(bDashDotUsed)
707 {
708 ::std::vector< double > fDotDashArray;
709 const double fDashLen(rLineInfo.GetDashLen());
710 const double fDotLen(rLineInfo.GetDotLen());
711 const double fDistance(rLineInfo.GetDistance());
712
713 for(sal_uInt16 a(0); a < rLineInfo.GetDashCount(); a++)
714 {
715 fDotDashArray.push_back(fDashLen);
716 fDotDashArray.push_back(fDistance);
717 }
718
719 for(sal_uInt16 b(0); b < rLineInfo.GetDotCount(); b++)
720 {
721 fDotDashArray.push_back(fDotLen);
722 fDotDashArray.push_back(fDistance);
723 }
724
725 const double fAccumulated(::std::accumulate(fDotDashArray.begin(), fDotDashArray.end(), 0.0));
726 const drawinglayer::attribute::StrokeAttribute aStrokeAttribute(
727 fDotDashArray,
728 fAccumulated);
729
730 rTarget.append(
731 new drawinglayer::primitive2d::PolygonStrokePrimitive2D(
732 aLinePolygon,
733 aLineAttribute,
734 aStrokeAttribute));
735 }
736 else
737 {
738 rTarget.append(
739 new drawinglayer::primitive2d::PolygonStrokePrimitive2D(
740 aLinePolygon,
741 aLineAttribute));
742 }
743 }
744 else
745 {
746 createHairlinePrimitive(rLinePolygon, rTarget, rProperties);
747 }
748 }
749 }
750
751 /** helper to create needed line and fill primitives based on current context */
752 void createHairlineAndFillPrimitive(
753 const basegfx::B2DPolygon& rPolygon,
754 TargetHolder& rTarget,
755 PropertyHolder& rProperties)
756 {
757 if(rProperties.getFillColorActive())
758 {
759 createFillPrimitive(basegfx::B2DPolyPolygon(rPolygon), rTarget, rProperties);
760 }
761
762 if(rProperties.getLineColorActive())
763 {
764 createHairlinePrimitive(rPolygon, rTarget, rProperties);
765 }
766 }
767
768 /** helper to create needed line and fill primitives based on current context */
769 void createHairlineAndFillPrimitive(
770 const basegfx::B2DPolyPolygon& rPolyPolygon,
771 TargetHolder& rTarget,
772 PropertyHolder& rProperties)
773 {
774 if(rProperties.getFillColorActive())
775 {
776 createFillPrimitive(rPolyPolygon, rTarget, rProperties);
777 }
778
779 if(rProperties.getLineColorActive())
780 {
781 for(sal_uInt32 a(0); a < rPolyPolygon.count(); a++)
782 {
783 createHairlinePrimitive(rPolyPolygon.getB2DPolygon(a), rTarget, rProperties);
784 }
785 }
786 }
787
788 /** helper to create DiscreteBitmapPrimitive2D based on current context.
789 The DiscreteBitmapPrimitive2D is especially created for this usage
790 since no other usage defines a bitmap visualisation based on top-left
791 position and size in pixels. At the end it will create a view-dependent
792 transformed embedding of a BitmapPrimitive2D.
793 */
794 void createBitmapExPrimitive(
795 const BitmapEx& rBitmapEx,
796 const Point& rPoint,
797 TargetHolder& rTarget,
798 PropertyHolder& rProperties)
799 {
800 if(!rBitmapEx.IsEmpty())
801 {
802 basegfx::B2DPoint aPoint(rPoint.X(), rPoint.Y());
803 aPoint = rProperties.getTransformation() * aPoint;
804
805 rTarget.append(
806 new drawinglayer::primitive2d::DiscreteBitmapPrimitive2D(
807 rBitmapEx,
808 aPoint));
809 }
810 }
811
812 /** helper to create BitmapPrimitive2D based on current context */
813 void createBitmapExPrimitive(
814 const BitmapEx& rBitmapEx,
815 const Point& rPoint,
816 const Size& rSize,
817 TargetHolder& rTarget,
818 PropertyHolder& rProperties)
819 {
820 if(!rBitmapEx.IsEmpty())
821 {
822 basegfx::B2DHomMatrix aObjectTransform;
823
824 aObjectTransform.set(0, 0, rSize.Width());
825 aObjectTransform.set(1, 1, rSize.Height());
826 aObjectTransform.set(0, 2, rPoint.X());
827 aObjectTransform.set(1, 2, rPoint.Y());
828
829 aObjectTransform = rProperties.getTransformation() * aObjectTransform;
830
831 rTarget.append(
832 new drawinglayer::primitive2d::BitmapPrimitive2D(
833 rBitmapEx,
834 aObjectTransform));
835 }
836 }
837
838 /** helper to create a regular BotmapEx from a MaskAction (definitions
839 which use a bitmap without transparence but define one of the colors as
840 transparent)
841 */
842 BitmapEx createMaskBmpEx(const Bitmap& rBitmap, const Color& rMaskColor)
843 {
844 const Color aWhite(COL_WHITE);
845 BitmapPalette aBiLevelPalette(2);
846
847 aBiLevelPalette[0] = aWhite;
848 aBiLevelPalette[1] = rMaskColor;
849
850 Bitmap aMask(rBitmap.CreateMask(aWhite));
851 Bitmap aSolid(rBitmap.GetSizePixel(), 1, &aBiLevelPalette);
852
853 aSolid.Erase(rMaskColor);
854
855 return BitmapEx(aSolid, aMask);
856 }
857
858 /** helper to convert from a VCL Gradient definition to the corresponding
859 data for primitive representation
860 */
861 drawinglayer::attribute::FillGradientAttribute createFillGradientAttribute(const Gradient& rGradient)
862 {
863 const Color aStartColor(rGradient.GetStartColor());
864 const sal_uInt16 nStartIntens(rGradient.GetStartIntensity());
865 basegfx::BColor aStart(aStartColor.getBColor());
866
867 if(nStartIntens != 100)
868 {
869 const basegfx::BColor aBlack;
870 aStart = interpolate(aBlack, aStart, (double)nStartIntens * 0.01);
871 }
872
873 const Color aEndColor(rGradient.GetEndColor());
874 const sal_uInt16 nEndIntens(rGradient.GetEndIntensity());
875 basegfx::BColor aEnd(aEndColor.getBColor());
876
877 if(nEndIntens != 100)
878 {
879 const basegfx::BColor aBlack;
880 aEnd = interpolate(aBlack, aEnd, (double)nEndIntens * 0.01);
881 }
882
883 drawinglayer::attribute::GradientStyle aGradientStyle(drawinglayer::attribute::GRADIENTSTYLE_RECT);
884
885 switch(rGradient.GetStyle())
886 {
887 case GradientStyle_LINEAR :
888 {
889 aGradientStyle = drawinglayer::attribute::GRADIENTSTYLE_LINEAR;
890 break;
891 }
892 case GradientStyle_AXIAL :
893 {
894 aGradientStyle = drawinglayer::attribute::GRADIENTSTYLE_AXIAL;
895 break;
896 }
897 case GradientStyle_RADIAL :
898 {
899 aGradientStyle = drawinglayer::attribute::GRADIENTSTYLE_RADIAL;
900 break;
901 }
902 case GradientStyle_ELLIPTICAL :
903 {
904 aGradientStyle = drawinglayer::attribute::GRADIENTSTYLE_ELLIPTICAL;
905 break;
906 }
907 case GradientStyle_SQUARE :
908 {
909 aGradientStyle = drawinglayer::attribute::GRADIENTSTYLE_SQUARE;
910 break;
911 }
912 default : // GradientStyle_RECT
913 {
914 aGradientStyle = drawinglayer::attribute::GRADIENTSTYLE_RECT;
915 break;
916 }
917 }
918
919 return drawinglayer::attribute::FillGradientAttribute(
920 aGradientStyle,
921 (double)rGradient.GetBorder() * 0.01,
922 (double)rGradient.GetOfsX() * 0.01,
923 (double)rGradient.GetOfsY() * 0.01,
924 (double)rGradient.GetAngle() * F_PI1800,
925 aStart,
926 aEnd,
927 rGradient.GetSteps());
928 }
929
930 /** helper to convert from a VCL Hatch definition to the corresponding
931 data for primitive representation
932 */
933 drawinglayer::attribute::FillHatchAttribute createFillHatchAttribute(const Hatch& rHatch)
934 {
935 drawinglayer::attribute::HatchStyle aHatchStyle(drawinglayer::attribute::HATCHSTYLE_SINGLE);
936
937 switch(rHatch.GetStyle())
938 {
939 default : // case HATCH_SINGLE :
940 {
941 aHatchStyle = drawinglayer::attribute::HATCHSTYLE_SINGLE;
942 break;
943 }
944 case HATCH_DOUBLE :
945 {
946 aHatchStyle = drawinglayer::attribute::HATCHSTYLE_DOUBLE;
947 break;
948 }
949 case HATCH_TRIPLE :
950 {
951 aHatchStyle = drawinglayer::attribute::HATCHSTYLE_TRIPLE;
952 break;
953 }
954 }
955
956 return drawinglayer::attribute::FillHatchAttribute(
957 aHatchStyle,
958 (double)rHatch.GetDistance(),
959 (double)rHatch.GetAngle() * F_PI1800,
960 rHatch.GetColor().getBColor(),
961 3, // same default as VCL, a minimum of three discrete units (pixels) offset
962 false);
963 }
964
965 /** helper to take needed action on ClipRegion change. This method needs to be called
966 on any Region change, e.g. at the obvious actions doing this, but also at pop-calls
967 which change the Region of the current context. It takes care of creating the
968 current embeddec context, set the new Region at the context and eventually prepare
969 a new target for embracing new geometry to the current region
970 */
971 void HandleNewClipRegion(
972 const basegfx::B2DPolyPolygon& rClipPolyPolygon,
973 TargetHolders& rTargetHolders,
974 PropertyHolders& rPropertyHolders)
975 {
976 const bool bNewActive(rClipPolyPolygon.count());
977
978 // #i108636# The handlig of new ClipPolyPolygons was not done as good as possible
979 // in the first version of this interpreter; e.g. when a ClipPolyPolygon was set
980 // initially and then using a lot of push/pop actions, the pop always leads
981 // to setting a 'new' ClipPolyPolygon which indeed is the return to the ClipPolyPolygon
982 // of the properties next on the stack.
983 //
984 // This ClipPolyPolygon is identical to the current one, so there is no need to
985 // create a MaskPrimitive2D containing the up-to-now created primitives, but
986 // this was done before. While this does not lead to wrong primitive
987 // representations of the metafile data, it creates unneccesarily expensive
988 // representations. Just detecting when no really 'new' ClipPolyPolygon gets set
989 // solves the problem.
990
991 if(!rPropertyHolders.Current().getClipPolyPolygonActive() && !bNewActive)
992 {
993 // no active ClipPolyPolygon exchanged by no new one, done
994 return;
995 }
996
997 if(rPropertyHolders.Current().getClipPolyPolygonActive() && bNewActive)
998 {
999 // active ClipPolyPolygon and new active ClipPolyPolygon
1000 if(rPropertyHolders.Current().getClipPolyPolygon() == rClipPolyPolygon)
1001 {
1002 // new is the same as old, done
1003 return;
1004 }
1005 }
1006
1007 // Here the old and the new are definitively different, maybe
1008 // old one and/or new one is not active.
1009
1010 // Handle deletion of old ClipPolyPolygon. The process evtl. created primitives which
1011 // belong to this active ClipPolyPolygon. These need to be embedded to a
1012 // MaskPrimitive2D accordingly.
1013 if(rPropertyHolders.Current().getClipPolyPolygonActive() && rTargetHolders.size() > 1)
1014 {
1015 drawinglayer::primitive2d::Primitive2DSequence aSubContent;
1016
1017 if(rPropertyHolders.Current().getClipPolyPolygon().count()
1018 && rTargetHolders.Current().size())
1019 {
1020 aSubContent = rTargetHolders.Current().getPrimitive2DSequence(
1021 rPropertyHolders.Current());
1022 }
1023
1024 rTargetHolders.Pop();
1025
1026 if(aSubContent.hasElements())
1027 {
1028 rTargetHolders.Current().append(
1029 new drawinglayer::primitive2d::GroupPrimitive2D(
1030 aSubContent));
1031 }
1032 }
1033
1034 // apply new settings to current properties by setting
1035 // the new region now
1036 rPropertyHolders.Current().setClipPolyPolygonActive(bNewActive);
1037
1038 if(bNewActive)
1039 {
1040 rPropertyHolders.Current().setClipPolyPolygon(rClipPolyPolygon);
1041
1042 // prepare new content holder for new active region
1043 rTargetHolders.Push();
1044 }
1045 }
1046
1047 /** helper to handle the change of RasterOp. It takes care of encapsulating all current
1048 geometry to the current RasterOp (if changed) and needs to be called on any RasterOp
1049 change. It will also start a new geometry target to embrace to the new RasterOp if
1050 a changuing RasterOp is used. Currently, ROP_XOR and ROP_INVERT are supported using
1051 InvertPrimitive2D, and ROP_0 by using a ModifiedColorPrimitive2D to force to black paint
1052 */
1053 void HandleNewRasterOp(
1054 RasterOp aRasterOp,
1055 TargetHolders& rTargetHolders,
1056 PropertyHolders& rPropertyHolders)
1057 {
1058 // check if currently active
1059 if(rPropertyHolders.Current().isRasterOpActive() && rTargetHolders.size() > 1)
1060 {
1061 drawinglayer::primitive2d::Primitive2DSequence aSubContent;
1062
1063 if(rTargetHolders.Current().size())
1064 {
1065 aSubContent = rTargetHolders.Current().getPrimitive2DSequence(rPropertyHolders.Current());
1066 }
1067
1068 rTargetHolders.Pop();
1069
1070 if(aSubContent.hasElements())
1071 {
1072 if(rPropertyHolders.Current().isRasterOpForceBlack())
1073 {
1074 // force content to black
1075 rTargetHolders.Current().append(
1076 new drawinglayer::primitive2d::ModifiedColorPrimitive2D(
1077 aSubContent,
1078 basegfx::BColorModifier(basegfx::BColor(0.0, 0.0, 0.0))));
1079 }
1080 else // if(rPropertyHolders.Current().isRasterOpInvert())
1081 {
1082 // invert content
1083 rTargetHolders.Current().append(
1084 new drawinglayer::primitive2d::InvertPrimitive2D(
1085 aSubContent));
1086 }
1087 }
1088 }
1089
1090 // apply new settings
1091 rPropertyHolders.Current().setRasterOp(aRasterOp);
1092
1093 // check if now active
1094 if(rPropertyHolders.Current().isRasterOpActive())
1095 {
1096 // prepare new content holder for new invert
1097 rTargetHolders.Push();
1098 }
1099 }
1100
1101 /** helper to create needed data to emulate the VCL Wallpaper Metafile action.
1102 It is a quite mighty action. This helper is for simple color filled background.
1103 */
1104 drawinglayer::primitive2d::BasePrimitive2D* CreateColorWallpaper(
1105 const basegfx::B2DRange& rRange,
1106 const basegfx::BColor& rColor,
1107 PropertyHolder& rPropertyHolder)
1108 {
1109 basegfx::B2DPolygon aOutline(basegfx::tools::createPolygonFromRect(rRange));
1110 aOutline.transform(rPropertyHolder.getTransformation());
1111
1112 return new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
1113 basegfx::B2DPolyPolygon(aOutline),
1114 rColor);
1115 }
1116
1117 /** helper to create needed data to emulate the VCL Wallpaper Metafile action.
1118 It is a quite mighty action. This helper is for gradient filled background.
1119 */
1120 drawinglayer::primitive2d::BasePrimitive2D* CreateGradientWallpaper(
1121 const basegfx::B2DRange& rRange,
1122 const Gradient& rGradient,
1123 PropertyHolder& rPropertyHolder)
1124 {
1125 const drawinglayer::attribute::FillGradientAttribute aAttribute(createFillGradientAttribute(rGradient));
1126
1127 if(aAttribute.getStartColor() == aAttribute.getEndColor())
1128 {
1129 // not really a gradient. Create filled rectangle
1130 return CreateColorWallpaper(rRange, aAttribute.getStartColor(), rPropertyHolder);
1131 }
1132 else
1133 {
1134 // really a gradient
1135 drawinglayer::primitive2d::BasePrimitive2D* pRetval =
1136 new drawinglayer::primitive2d::FillGradientPrimitive2D(
1137 rRange,
1138 aAttribute);
1139
1140 if(!rPropertyHolder.getTransformation().isIdentity())
1141 {
1142 const drawinglayer::primitive2d::Primitive2DReference xPrim(pRetval);
1143 const drawinglayer::primitive2d::Primitive2DSequence xSeq(&xPrim, 1);
1144
1145 pRetval = new drawinglayer::primitive2d::TransformPrimitive2D(
1146 rPropertyHolder.getTransformation(),
1147 xSeq);
1148 }
1149
1150 return pRetval;
1151 }
1152 }
1153
1154 /** helper to create needed data to emulate the VCL Wallpaper Metafile action.
1155 It is a quite mighty action. This helper decides if color and/or gradient
1156 background is needed for the wanted bitmap fill and then creates the needed
1157 WallpaperBitmapPrimitive2D. This primitive was created for this purpose and
1158 takes over all needed logic of orientations and tiling.
1159 */
1160 void CreateAndAppendBitmapWallpaper(
1161 basegfx::B2DRange aWallpaperRange,
1162 const Wallpaper& rWallpaper,
1163 TargetHolder& rTarget,
1164 PropertyHolder& rProperty)
1165 {
1166 const BitmapEx aBitmapEx(rWallpaper.GetBitmap());
1167 const WallpaperStyle eWallpaperStyle(rWallpaper.GetStyle());
1168
1169 // if bitmap visualisation is transparent, maybe background
1170 // needs to be filled. Create background
1171 if(aBitmapEx.IsTransparent()
1172 || (WALLPAPER_TILE != eWallpaperStyle && WALLPAPER_SCALE != eWallpaperStyle))
1173 {
1174 if(rWallpaper.IsGradient())
1175 {
1176 rTarget.append(
1177 CreateGradientWallpaper(
1178 aWallpaperRange,
1179 rWallpaper.GetGradient(),
1180 rProperty));
1181 }
1182 else if(!rWallpaper.GetColor().GetTransparency())
1183 {
1184 rTarget.append(
1185 CreateColorWallpaper(
1186 aWallpaperRange,
1187 rWallpaper.GetColor().getBColor(),
1188 rProperty));
1189 }
1190 }
1191
1192 // use wallpaper rect if set
1193 if(rWallpaper.IsRect() && !rWallpaper.GetRect().IsEmpty())
1194 {
1195 aWallpaperRange = basegfx::B2DRange(
1196 rWallpaper.GetRect().Left(), rWallpaper.GetRect().Top(),
1197 rWallpaper.GetRect().Right(), rWallpaper.GetRect().Bottom());
1198 }
1199
1200 drawinglayer::primitive2d::BasePrimitive2D* pBitmapWallpaperFill =
1201 new drawinglayer::primitive2d::WallpaperBitmapPrimitive2D(
1202 aWallpaperRange,
1203 aBitmapEx,
1204 eWallpaperStyle);
1205
1206 if(rProperty.getTransformation().isIdentity())
1207 {
1208 // add directly
1209 rTarget.append(pBitmapWallpaperFill);
1210 }
1211 else
1212 {
1213 // when a transformation is set, embed to it
1214 const drawinglayer::primitive2d::Primitive2DReference xPrim(pBitmapWallpaperFill);
1215
1216 rTarget.append(
1217 new drawinglayer::primitive2d::TransformPrimitive2D(
1218 rProperty.getTransformation(),
1219 drawinglayer::primitive2d::Primitive2DSequence(&xPrim, 1)));
1220 }
1221 }
1222
1223 /** helper to decide UnderlineAbove for text primitives */
1224 bool isUnderlineAbove(const Font& rFont)
1225 {
1226 if(!rFont.IsVertical())
1227 {
1228 return false;
1229 }
1230
1231 if((LANGUAGE_JAPANESE == rFont.GetLanguage()) || (LANGUAGE_JAPANESE == rFont.GetCJKContextLanguage()))
1232 {
1233 // the underline is right for Japanese only
1234 return true;
1235 }
1236
1237 return false;
1238 }
1239
1240 void createFontAttributeTransformAndAlignment(
1241 drawinglayer::attribute::FontAttribute& rFontAttribute,
1242 basegfx::B2DHomMatrix& rTextTransform,
1243 basegfx::B2DVector& rAlignmentOffset,
1244 PropertyHolder& rProperty)
1245 {
1246 const Font& rFont = rProperty.getFont();
1247 basegfx::B2DVector aFontScaling;
1248
1249 rFontAttribute = drawinglayer::attribute::FontAttribute(
1250 drawinglayer::primitive2d::getFontAttributeFromVclFont(
1251 aFontScaling,
1252 rFont,
1253 0 != (rProperty.getLayoutMode() & TEXT_LAYOUT_BIDI_RTL),
1254 0 != (rProperty.getLayoutMode() & TEXT_LAYOUT_BIDI_STRONG)));
1255
1256 // add FontScaling
1257 rTextTransform.scale(aFontScaling.getX(), aFontScaling.getY());
1258
1259 // take text align into account
1260 if(ALIGN_BASELINE != rFont.GetAlign())
1261 {
1262 drawinglayer::primitive2d::TextLayouterDevice aTextLayouterDevice;
1263 aTextLayouterDevice.setFont(rFont);
1264
1265 if(ALIGN_TOP == rFont.GetAlign())
1266 {
1267 rAlignmentOffset.setY(aTextLayouterDevice.getFontAscent());
1268 }
1269 else // ALIGN_BOTTOM
1270 {
1271 rAlignmentOffset.setY(-aTextLayouterDevice.getFontDescent());
1272 }
1273
1274 rTextTransform.translate(rAlignmentOffset.getX(), rAlignmentOffset.getY());
1275 }
1276
1277 // add FontRotation (if used)
1278 if(rFont.GetOrientation())
1279 {
1280 rTextTransform.rotate(-rFont.GetOrientation() * F_PI1800);
1281 }
1282 }
1283
1284 /** helper which takes complete care for creating the needed text primitives. It
1285 takes care of decorated stuff and all the geometry adaptions needed
1286 */
1287 void processMetaTextAction(
1288 const Point& rTextStartPosition,
1289 const OUString& rText,
1290 sal_uInt16 nTextStart,
1291 sal_uInt16 nTextLength,
1292 const ::std::vector< double >& rDXArray,
1293 TargetHolder& rTarget,
1294 PropertyHolder& rProperty)
1295 {
1296 drawinglayer::primitive2d::BasePrimitive2D* pResult = 0;
1297 const Font& rFont = rProperty.getFont();
1298 basegfx::B2DVector aAlignmentOffset(0.0, 0.0);
1299
1300 if(nTextLength)
1301 {
1302 drawinglayer::attribute::FontAttribute aFontAttribute;
1303 basegfx::B2DHomMatrix aTextTransform;
1304
1305 // fill parameters derived from current font
1306 createFontAttributeTransformAndAlignment(
1307 aFontAttribute,
1308 aTextTransform,
1309 aAlignmentOffset,
1310 rProperty);
1311
1312 // add TextStartPosition
1313 aTextTransform.translate(rTextStartPosition.X(), rTextStartPosition.Y());
1314
1315 // prepare FontColor and Locale
1316 const basegfx::BColor aFontColor(rProperty.getTextColor());
1317 const com::sun::star::lang::Locale aLocale(LanguageTag(rProperty.getLanguageType()).getLocale());
1318 const bool bWordLineMode(rFont.IsWordLineMode());
1319
1320 const bool bDecoratedIsNeeded(
1321 UNDERLINE_NONE != rFont.GetOverline()
1322 || UNDERLINE_NONE != rFont.GetUnderline()
1323 || STRIKEOUT_NONE != rFont.GetStrikeout()
1324 || EMPHASISMARK_NONE != (rFont.GetEmphasisMark() & EMPHASISMARK_STYLE)
1325 || RELIEF_NONE != rFont.GetRelief()
1326 || rFont.IsShadow()
1327 || bWordLineMode);
1328
1329 if(bDecoratedIsNeeded)
1330 {
1331 // prepare overline, underline and srikeout data
1332 const drawinglayer::primitive2d::TextLine eFontOverline(drawinglayer::primitive2d::mapFontUnderlineToTextLine(rFont.GetOverline()));
1333 const drawinglayer::primitive2d::TextLine eFontUnderline(drawinglayer::primitive2d::mapFontUnderlineToTextLine(rFont.GetUnderline()));
1334 const drawinglayer::primitive2d::TextStrikeout eTextStrikeout(drawinglayer::primitive2d::mapFontStrikeoutToTextStrikeout(rFont.GetStrikeout()));
1335
1336 // check UndelineAbove
1337 const bool bUnderlineAbove(drawinglayer::primitive2d::TEXT_LINE_NONE != eFontUnderline && isUnderlineAbove(rFont));
1338
1339 // prepare emphasis mark data
1340 drawinglayer::primitive2d::TextEmphasisMark eTextEmphasisMark(drawinglayer::primitive2d::TEXT_EMPHASISMARK_NONE);
1341
1342 switch(rFont.GetEmphasisMark() & EMPHASISMARK_STYLE)
1343 {
1344 case EMPHASISMARK_DOT : eTextEmphasisMark = drawinglayer::primitive2d::TEXT_EMPHASISMARK_DOT; break;
1345 case EMPHASISMARK_CIRCLE : eTextEmphasisMark = drawinglayer::primitive2d::TEXT_EMPHASISMARK_CIRCLE; break;
1346 case EMPHASISMARK_DISC : eTextEmphasisMark = drawinglayer::primitive2d::TEXT_EMPHASISMARK_DISC; break;
1347 case EMPHASISMARK_ACCENT : eTextEmphasisMark = drawinglayer::primitive2d::TEXT_EMPHASISMARK_ACCENT; break;
1348 }
1349
1350 const bool bEmphasisMarkAbove(rFont.GetEmphasisMark() & EMPHASISMARK_POS_ABOVE);
1351 const bool bEmphasisMarkBelow(rFont.GetEmphasisMark() & EMPHASISMARK_POS_BELOW);
1352
1353 // prepare font relief data
1354 drawinglayer::primitive2d::TextRelief eTextRelief(drawinglayer::primitive2d::TEXT_RELIEF_NONE);
1355
1356 switch(rFont.GetRelief())
1357 {
1358 case RELIEF_EMBOSSED : eTextRelief = drawinglayer::primitive2d::TEXT_RELIEF_EMBOSSED; break;
1359 case RELIEF_ENGRAVED : eTextRelief = drawinglayer::primitive2d::TEXT_RELIEF_ENGRAVED; break;
1360 default : break; // RELIEF_NONE, FontRelief_FORCE_EQUAL_SIZE
1361 }
1362
1363 // prepare shadow/outline data
1364 const bool bShadow(rFont.IsShadow());
1365
1366 // TextDecoratedPortionPrimitive2D is needed, create one
1367 pResult = new drawinglayer::primitive2d::TextDecoratedPortionPrimitive2D(
1368
1369 // attributes for TextSimplePortionPrimitive2D
1370 aTextTransform,
1371 rText,
1372 nTextStart,
1373 nTextLength,
1374 rDXArray,
1375 aFontAttribute,
1376 aLocale,
1377 aFontColor,
1378
1379 // attributes for TextDecoratedPortionPrimitive2D
1380 rProperty.getOverlineColorActive() ? rProperty.getOverlineColor() : aFontColor,
1381 rProperty.getTextLineColorActive() ? rProperty.getTextLineColor() : aFontColor,
1382 eFontOverline,
1383 eFontUnderline,
1384 bUnderlineAbove,
1385 eTextStrikeout,
1386 bWordLineMode,
1387 eTextEmphasisMark,
1388 bEmphasisMarkAbove,
1389 bEmphasisMarkBelow,
1390 eTextRelief,
1391 bShadow);
1392 }
1393 else
1394 {
1395 // TextSimplePortionPrimitive2D is enough
1396 pResult = new drawinglayer::primitive2d::TextSimplePortionPrimitive2D(
1397 aTextTransform,
1398 rText,
1399 nTextStart,
1400 nTextLength,
1401 rDXArray,
1402 aFontAttribute,
1403 aLocale,
1404 aFontColor);
1405 }
1406 }
1407
1408 if(pResult && rProperty.getTextFillColorActive())
1409 {
1410 // text background is requested, add and encapsulate both to new primitive
1411 drawinglayer::primitive2d::TextLayouterDevice aTextLayouterDevice;
1412 aTextLayouterDevice.setFont(rFont);
1413
1414 // get text width
1415 double fTextWidth(0.0);
1416
1417 if(rDXArray.empty())
1418 {
1419 fTextWidth = aTextLayouterDevice.getTextWidth(rText, nTextStart, nTextLength);
1420 }
1421 else
1422 {
1423 fTextWidth = rDXArray.back();
1424 }
1425
1426 if(basegfx::fTools::more(fTextWidth, 0.0))
1427 {
1428 // build text range
1429 const basegfx::B2DRange aTextRange(
1430 0.0, -aTextLayouterDevice.getFontAscent(),
1431 fTextWidth, aTextLayouterDevice.getFontDescent());
1432
1433 // create Transform
1434 basegfx::B2DHomMatrix aTextTransform;
1435
1436 aTextTransform.translate(aAlignmentOffset.getX(), aAlignmentOffset.getY());
1437
1438 if(rFont.GetOrientation())
1439 {
1440 aTextTransform.rotate(-rFont.GetOrientation() * F_PI1800);
1441 }
1442
1443 aTextTransform.translate(rTextStartPosition.X(), rTextStartPosition.Y());
1444
1445 // prepare Primitive2DSequence, put text in foreground
1446 drawinglayer::primitive2d::Primitive2DSequence aSequence(2);
1447 aSequence[1] = drawinglayer::primitive2d::Primitive2DReference(pResult);
1448
1449 // prepare filled polygon
1450 basegfx::B2DPolygon aOutline(basegfx::tools::createPolygonFromRect(aTextRange));
1451 aOutline.transform(aTextTransform);
1452
1453 aSequence[0] = drawinglayer::primitive2d::Primitive2DReference(
1454 new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
1455 basegfx::B2DPolyPolygon(aOutline),
1456 rProperty.getTextFillColor()));
1457
1458 // set as group at pResult
1459 pResult = new drawinglayer::primitive2d::GroupPrimitive2D(aSequence);
1460 }
1461 }
1462
1463 if(pResult)
1464 {
1465 // add created text primitive to target
1466 if(rProperty.getTransformation().isIdentity())
1467 {
1468 rTarget.append(pResult);
1469 }
1470 else
1471 {
1472 // when a transformation is set, embed to it
1473 const drawinglayer::primitive2d::Primitive2DReference aReference(pResult);
1474
1475 rTarget.append(
1476 new drawinglayer::primitive2d::TransformPrimitive2D(
1477 rProperty.getTransformation(),
1478 drawinglayer::primitive2d::Primitive2DSequence(&aReference, 1)));
1479 }
1480 }
1481 }
1482
1483 /** helper which takes complete care for creating the needed textLine primitives */
1484 void proccessMetaTextLineAction(
1485 const MetaTextLineAction& rAction,
1486 TargetHolder& rTarget,
1487 PropertyHolder& rProperty)
1488 {
1489 const double fLineWidth(fabs((double)rAction.GetWidth()));
1490
1491 if(fLineWidth > 0.0)
1492 {
1493 const drawinglayer::primitive2d::TextLine aOverlineMode(drawinglayer::primitive2d::mapFontUnderlineToTextLine(rAction.GetOverline()));
1494 const drawinglayer::primitive2d::TextLine aUnderlineMode(drawinglayer::primitive2d::mapFontUnderlineToTextLine(rAction.GetUnderline()));
1495 const drawinglayer::primitive2d::TextStrikeout aTextStrikeout(drawinglayer::primitive2d::mapFontStrikeoutToTextStrikeout(rAction.GetStrikeout()));
1496
1497 const bool bOverlineUsed(drawinglayer::primitive2d::TEXT_LINE_NONE != aOverlineMode);
1498 const bool bUnderlineUsed(drawinglayer::primitive2d::TEXT_LINE_NONE != aUnderlineMode);
1499 const bool bStrikeoutUsed(drawinglayer::primitive2d::TEXT_STRIKEOUT_NONE != aTextStrikeout);
1500
1501 if(bUnderlineUsed || bStrikeoutUsed || bOverlineUsed)
1502 {
1503 std::vector< drawinglayer::primitive2d::BasePrimitive2D* > aTargetVector;
1504 basegfx::B2DVector aAlignmentOffset(0.0, 0.0);
1505 drawinglayer::attribute::FontAttribute aFontAttribute;
1506 basegfx::B2DHomMatrix aTextTransform;
1507
1508 // fill parameters derived from current font
1509 createFontAttributeTransformAndAlignment(
1510 aFontAttribute,
1511 aTextTransform,
1512 aAlignmentOffset,
1513 rProperty);
1514
1515 // add TextStartPosition
1516 aTextTransform.translate(rAction.GetStartPoint().X(), rAction.GetStartPoint().Y());
1517
1518 // prepare TextLayouter (used in most cases)
1519 drawinglayer::primitive2d::TextLayouterDevice aTextLayouter;
1520 aTextLayouter.setFont(rProperty.getFont());
1521
1522 if(bOverlineUsed)
1523 {
1524 // create primitive geometry for overline
1525 aTargetVector.push_back(
1526 new drawinglayer::primitive2d::TextLinePrimitive2D(
1527 aTextTransform,
1528 fLineWidth,
1529 aTextLayouter.getOverlineOffset(),
1530 aTextLayouter.getOverlineHeight(),
1531 aOverlineMode,
1532 rProperty.getOverlineColor()));
1533 }
1534
1535 if(bUnderlineUsed)
1536 {
1537 // create primitive geometry for underline
1538 aTargetVector.push_back(
1539 new drawinglayer::primitive2d::TextLinePrimitive2D(
1540 aTextTransform,
1541 fLineWidth,
1542 aTextLayouter.getUnderlineOffset(),
1543 aTextLayouter.getUnderlineHeight(),
1544 aUnderlineMode,
1545 rProperty.getTextLineColor()));
1546 }
1547
1548 if(bStrikeoutUsed)
1549 {
1550 // create primitive geometry for strikeout
1551 if(drawinglayer::primitive2d::TEXT_STRIKEOUT_SLASH == aTextStrikeout
1552 || drawinglayer::primitive2d::TEXT_STRIKEOUT_X == aTextStrikeout)
1553 {
1554 // strikeout with character
1555 const sal_Unicode aStrikeoutChar(
1556 drawinglayer::primitive2d::TEXT_STRIKEOUT_SLASH == aTextStrikeout ? '/' : 'X');
1557 const com::sun::star::lang::Locale aLocale(LanguageTag(
1558 rProperty.getLanguageType()).getLocale());
1559
1560 aTargetVector.push_back(
1561 new drawinglayer::primitive2d::TextCharacterStrikeoutPrimitive2D(
1562 aTextTransform,
1563 fLineWidth,
1564 rProperty.getTextColor(),
1565 aStrikeoutChar,
1566 aFontAttribute,
1567 aLocale));
1568 }
1569 else
1570 {
1571 // strikeout with geometry
1572 aTargetVector.push_back(
1573 new drawinglayer::primitive2d::TextGeometryStrikeoutPrimitive2D(
1574 aTextTransform,
1575 fLineWidth,
1576 rProperty.getTextColor(),
1577 aTextLayouter.getUnderlineHeight(),
1578 aTextLayouter.getStrikeoutOffset(),
1579 aTextStrikeout));
1580 }
1581 }
1582
1583 if(!aTargetVector.empty())
1584 {
1585 // add created text primitive to target
1586 if(rProperty.getTransformation().isIdentity())
1587 {
1588 for(sal_uInt32 a(0); a < aTargetVector.size(); a++)
1589 {
1590 rTarget.append(aTargetVector[a]);
1591 }
1592 }
1593 else
1594 {
1595 // when a transformation is set, embed to it
1596 drawinglayer::primitive2d::Primitive2DSequence xTargets(aTargetVector.size());
1597
1598 for(sal_uInt32 a(0); a < aTargetVector.size(); a++)
1599 {
1600 xTargets[a] = drawinglayer::primitive2d::Primitive2DReference(aTargetVector[a]);
1601 }
1602
1603 rTarget.append(
1604 new drawinglayer::primitive2d::TransformPrimitive2D(
1605 rProperty.getTransformation(),
1606 xTargets));
1607 }
1608 }
1609 }
1610 }
1611
1612 }
1613
1614 /** This is the main interpreter method. It is designed to handle the given Metafile
1615 completely inside the given context and target. It may use and modify the context and
1616 target. This design allows to call itself recursively which adapted contexts and
1617 targets as e.g. needed for the META_FLOATTRANSPARENT_ACTION where the content is expressed
1618 as a metafile as sub-content.
1619
1620 This interpreter is as free of VCL functionality as possible. It uses VCL data classes
1621 (else reading the data would not be possible), but e.g. does NOT use a local OutputDevice
1622 as most other MetaFile interpreters/exporters do to hold and work with the current context.
1623 This is necessary to be able to get away from the strong internal VCL-binding.
1624
1625 It tries to combine e.g. pixel and/or point actions and to stitch together single line primitives
1626 where possible (which is not trivial with the possible line geometry definitions).
1627
1628 It tries to handle clipping no longer as Regions and spans of Rectangles, but as PolyPolygon
1629 ClipRegions with (where possible) high precision by using the best possible data quality
1630 from the Region. The Region is unavoidable as data container, but nowadays allows the transport
1631 of Polygon-based clip regions. Where this is not used, a Polygon is constructed from the
1632 Region ranges. All primitive clipping uses the MaskPrimitive2D with Polygon-based clipping.
1633
1634 I have marked the single MetaActions with:
1635
1636 SIMPLE, DONE:
1637 Simple, e.g nothing to do or value setting in the context
1638
1639 CHECKED, WORKS WELL:
1640 Thoroughly tested with extra written test code which created a replacement
1641 Metafile just to test this action in various combinations
1642
1643 NEEDS IMPLEMENTATION:
1644 Not implemented and asserted, but also no usage found, neither in own Metafile
1645 creations, nor in EMF/WMF imports (checked with a whole bunch of critical EMF/WMF
1646 bugdocs)
1647
1648 For more commens, see the single action implementations.
1649 */
1650 void interpretMetafile(
1651 const GDIMetaFile& rMetaFile,
1652 TargetHolders& rTargetHolders,
1653 PropertyHolders& rPropertyHolders,
1654 const drawinglayer::geometry::ViewInformation2D& rViewInformation)
1655 {
1656 const size_t nCount(rMetaFile.GetActionSize());
1657
1658 for(size_t nAction(0); nAction < nCount; nAction++)
1659 {
1660 MetaAction* pAction = rMetaFile.GetAction(nAction);
1661
1662 switch(pAction->GetType())
1663 {
1664 case META_NULL_ACTION :
1665 {
1666 /** SIMPLE, DONE */
1667 break;
1668 }
1669 case META_PIXEL_ACTION :
1670 {
1671 /** CHECKED, WORKS WELL */
1672 std::vector< basegfx::B2DPoint > aPositions;
1673 Color aLastColor(COL_BLACK);
1674
1675 while(META_PIXEL_ACTION == pAction->GetType() && nAction < nCount)
1676 {
1677 const MetaPixelAction* pA = (const MetaPixelAction*)pAction;
1678
1679 if(pA->GetColor() != aLastColor)
1680 {
1681 if(!aPositions.empty())
1682 {
1683 createPointArrayPrimitive(aPositions, rTargetHolders.Current(), rPropertyHolders.Current(), aLastColor.getBColor());
1684 aPositions.clear();
1685 }
1686
1687 aLastColor = pA->GetColor();
1688 }
1689
1690 const Point& rPoint = pA->GetPoint();
1691 aPositions.push_back(basegfx::B2DPoint(rPoint.X(), rPoint.Y()));
1692 nAction++; if(nAction < nCount) pAction = rMetaFile.GetAction(nAction);
1693 }
1694
1695 nAction--;
1696
1697 if(!aPositions.empty())
1698 {
1699 createPointArrayPrimitive(aPositions, rTargetHolders.Current(), rPropertyHolders.Current(), aLastColor.getBColor());
1700 }
1701
1702 break;
1703 }
1704 case META_POINT_ACTION :
1705 {
1706 /** CHECKED, WORKS WELL */
1707 if(rPropertyHolders.Current().getLineColorActive())
1708 {
1709 std::vector< basegfx::B2DPoint > aPositions;
1710
1711 while(META_POINT_ACTION == pAction->GetType() && nAction < nCount)
1712 {
1713 const MetaPointAction* pA = (const MetaPointAction*)pAction;
1714 const Point& rPoint = pA->GetPoint();
1715 aPositions.push_back(basegfx::B2DPoint(rPoint.X(), rPoint.Y()));
1716 nAction++; if(nAction < nCount) pAction = rMetaFile.GetAction(nAction);
1717 }
1718
1719 nAction--;
1720
1721 if(!aPositions.empty())
1722 {
1723 createPointArrayPrimitive(aPositions, rTargetHolders.Current(), rPropertyHolders.Current(), rPropertyHolders.Current().getLineColor());
1724 }
1725 }
1726
1727 break;
1728 }
1729 case META_LINE_ACTION :
1730 {
1731 /** CHECKED, WORKS WELL */
1732 if(rPropertyHolders.Current().getLineColorActive())
1733 {
1734 basegfx::B2DPolygon aLinePolygon;
1735 LineInfo aLineInfo;
1736
1737 while(META_LINE_ACTION == pAction->GetType() && nAction < nCount)
1738 {
1739 const MetaLineAction* pA = (const MetaLineAction*)pAction;
1740 const Point& rStartPoint = pA->GetStartPoint();
1741 const Point& rEndPoint = pA->GetEndPoint();
1742 const basegfx::B2DPoint aStart(rStartPoint.X(), rStartPoint.Y());
1743 const basegfx::B2DPoint aEnd(rEndPoint.X(), rEndPoint.Y());
1744
1745 if(aLinePolygon.count())
1746 {
1747 if(pA->GetLineInfo() == aLineInfo
1748 && aStart == aLinePolygon.getB2DPoint(aLinePolygon.count() - 1))
1749 {
1750 aLinePolygon.append(aEnd);
1751 }
1752 else
1753 {
1754 aLineInfo.SetLineJoin(basegfx::B2DLINEJOIN_NONE); // It were lines; force to NONE
1755 createLinePrimitive(aLinePolygon, aLineInfo, rTargetHolders.Current(), rPropertyHolders.Current());
1756 aLinePolygon.clear();
1757 aLineInfo = pA->GetLineInfo();
1758 aLinePolygon.append(aStart);
1759 aLinePolygon.append(aEnd);
1760 }
1761 }
1762 else
1763 {
1764 aLineInfo = pA->GetLineInfo();
1765 aLinePolygon.append(aStart);
1766 aLinePolygon.append(aEnd);
1767 }
1768
1769 nAction++; if(nAction < nCount) pAction = rMetaFile.GetAction(nAction);
1770 }
1771
1772 nAction--;
1773
1774 if(aLinePolygon.count())
1775 {
1776 aLineInfo.SetLineJoin(basegfx::B2DLINEJOIN_NONE); // It were lines; force to NONE
1777 createLinePrimitive(aLinePolygon, aLineInfo, rTargetHolders.Current(), rPropertyHolders.Current());
1778 }
1779 }
1780
1781 break;
1782 }
1783 case META_RECT_ACTION :
1784 {
1785 /** CHECKED, WORKS WELL */
1786 if(rPropertyHolders.Current().getLineOrFillActive())
1787 {
1788 const MetaRectAction* pA = (const MetaRectAction*)pAction;
1789 const Rectangle& rRectangle = pA->GetRect();
1790
1791 if(!rRectangle.IsEmpty())
1792 {
1793 const basegfx::B2DRange aRange(rRectangle.Left(), rRectangle.Top(), rRectangle.Right(), rRectangle.Bottom());
1794
1795 if(!aRange.isEmpty())
1796 {
1797 const basegfx::B2DPolygon aOutline(basegfx::tools::createPolygonFromRect(aRange));
1798 createHairlineAndFillPrimitive(aOutline, rTargetHolders.Current(), rPropertyHolders.Current());
1799 }
1800 }
1801 }
1802
1803 break;
1804 }
1805 case META_ROUNDRECT_ACTION :
1806 {
1807 /** CHECKED, WORKS WELL */
1808 /** The original OutputDevice::DrawRect paints nothing when nHor or nVer is zero; but just
1809 because the tools::Polygon operator creating the rounding does produce nonsense. I assume
1810 this an error and create an unrounded rectangle in that case (implicit in
1811 createPolygonFromRect)
1812 */
1813 if(rPropertyHolders.Current().getLineOrFillActive())
1814 {
1815 const MetaRoundRectAction* pA = (const MetaRoundRectAction*)pAction;
1816 const Rectangle& rRectangle = pA->GetRect();
1817
1818 if(!rRectangle.IsEmpty())
1819 {
1820 const basegfx::B2DRange aRange(rRectangle.Left(), rRectangle.Top(), rRectangle.Right(), rRectangle.Bottom());
1821
1822 if(!aRange.isEmpty())
1823 {
1824 const sal_uInt32 nHor(pA->GetHorzRound());
1825 const sal_uInt32 nVer(pA->GetVertRound());
1826 basegfx::B2DPolygon aOutline;
1827
1828 if(nHor || nVer)
1829 {
1830 double fRadiusX((nHor * 2.0) / (aRange.getWidth() > 0.0 ? aRange.getWidth() : 1.0));
1831 double fRadiusY((nVer * 2.0) / (aRange.getHeight() > 0.0 ? aRange.getHeight() : 1.0));
1832 fRadiusX = std::max(0.0, std::min(1.0, fRadiusX));
1833 fRadiusY = std::max(0.0, std::min(1.0, fRadiusY));
1834
1835 aOutline = basegfx::tools::createPolygonFromRect(aRange, fRadiusX, fRadiusY);
1836 }
1837 else
1838 {
1839 aOutline = basegfx::tools::createPolygonFromRect(aRange);
1840 }
1841
1842 createHairlineAndFillPrimitive(aOutline, rTargetHolders.Current(), rPropertyHolders.Current());
1843 }
1844 }
1845 }
1846
1847 break;
1848 }
1849 case META_ELLIPSE_ACTION :
1850 {
1851 /** CHECKED, WORKS WELL */
1852 if(rPropertyHolders.Current().getLineOrFillActive())
1853 {
1854 const MetaEllipseAction* pA = (const MetaEllipseAction*)pAction;
1855 const Rectangle& rRectangle = pA->GetRect();
1856
1857 if(!rRectangle.IsEmpty())
1858 {
1859 const basegfx::B2DRange aRange(rRectangle.Left(), rRectangle.Top(), rRectangle.Right(), rRectangle.Bottom());
1860
1861 if(!aRange.isEmpty())
1862 {
1863 const basegfx::B2DPolygon aOutline(basegfx::tools::createPolygonFromEllipse(
1864 aRange.getCenter(), aRange.getWidth() * 0.5, aRange.getHeight() * 0.5));
1865
1866 createHairlineAndFillPrimitive(aOutline, rTargetHolders.Current(), rPropertyHolders.Current());
1867 }
1868 }
1869 }
1870
1871 break;
1872 }
1873 case META_ARC_ACTION :
1874 {
1875 /** CHECKED, WORKS WELL */
1876 if(rPropertyHolders.Current().getLineColorActive())
1877 {
1878 const MetaArcAction* pA = (const MetaArcAction*)pAction;
1879 const Polygon aToolsPoly(pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint(), POLY_ARC);
1880 const basegfx::B2DPolygon aOutline(aToolsPoly.getB2DPolygon());
1881
1882 createHairlinePrimitive(aOutline, rTargetHolders.Current(), rPropertyHolders.Current());
1883 }
1884
1885 break;
1886 }
1887 case META_PIE_ACTION :
1888 {
1889 /** CHECKED, WORKS WELL */
1890 if(rPropertyHolders.Current().getLineOrFillActive())
1891 {
1892 const MetaPieAction* pA = (const MetaPieAction*)pAction;
1893 const Polygon aToolsPoly(pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint(), POLY_PIE);
1894 const basegfx::B2DPolygon aOutline(aToolsPoly.getB2DPolygon());
1895
1896 createHairlineAndFillPrimitive(aOutline, rTargetHolders.Current(), rPropertyHolders.Current());
1897 }
1898
1899 break;
1900 }
1901 case META_CHORD_ACTION :
1902 {
1903 /** CHECKED, WORKS WELL */
1904 if(rPropertyHolders.Current().getLineOrFillActive())
1905 {
1906 const MetaChordAction* pA = (const MetaChordAction*)pAction;
1907 const Polygon aToolsPoly(pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint(), POLY_CHORD);
1908 const basegfx::B2DPolygon aOutline(aToolsPoly.getB2DPolygon());
1909
1910 createHairlineAndFillPrimitive(aOutline, rTargetHolders.Current(), rPropertyHolders.Current());
1911 }
1912
1913 break;
1914 }
1915 case META_POLYLINE_ACTION :
1916 {
1917 /** CHECKED, WORKS WELL */
1918 if(rPropertyHolders.Current().getLineColorActive())
1919 {
1920 const MetaPolyLineAction* pA = (const MetaPolyLineAction*)pAction;
1921 createLinePrimitive(pA->GetPolygon().getB2DPolygon(), pA->GetLineInfo(), rTargetHolders.Current(), rPropertyHolders.Current());
1922 }
1923
1924 break;
1925 }
1926 case META_POLYGON_ACTION :
1927 {
1928 /** CHECKED, WORKS WELL */
1929 if(rPropertyHolders.Current().getLineOrFillActive())
1930 {
1931 const MetaPolygonAction* pA = (const MetaPolygonAction*)pAction;
1932 basegfx::B2DPolygon aOutline(pA->GetPolygon().getB2DPolygon());
1933
1934 // the metafile play interprets the polygons from MetaPolygonAction
1935 // always as closed and always paints an edge from last to first point,
1936 // so force to closed here to emulate that
1937 if(aOutline.count() > 1 && !aOutline.isClosed())
1938 {
1939 aOutline.setClosed(true);
1940 }
1941
1942 createHairlineAndFillPrimitive(aOutline, rTargetHolders.Current(), rPropertyHolders.Current());
1943 }
1944
1945 break;
1946 }
1947 case META_POLYPOLYGON_ACTION :
1948 {
1949 /** CHECKED, WORKS WELL */
1950 if(rPropertyHolders.Current().getLineOrFillActive())
1951 {
1952 const MetaPolyPolygonAction* pA = (const MetaPolyPolygonAction*)pAction;
1953 basegfx::B2DPolyPolygon aPolyPolygonOutline(pA->GetPolyPolygon().getB2DPolyPolygon());
1954
1955 // the metafile play interprets the single polygons from MetaPolyPolygonAction
1956 // always as closed and always paints an edge from last to first point,
1957 // so force to closed here to emulate that
1958 for(sal_uInt32 b(0); b < aPolyPolygonOutline.count(); b++)
1959 {
1960 basegfx::B2DPolygon aPolygonOutline(aPolyPolygonOutline.getB2DPolygon(b));
1961
1962 if(aPolygonOutline.count() > 1 && !aPolygonOutline.isClosed())
1963 {
1964 aPolygonOutline.setClosed(true);
1965 aPolyPolygonOutline.setB2DPolygon(b, aPolygonOutline);
1966 }
1967 }
1968
1969 createHairlineAndFillPrimitive(aPolyPolygonOutline, rTargetHolders.Current(), rPropertyHolders.Current());
1970 }
1971
1972 break;
1973 }
1974 case META_TEXT_ACTION :
1975 {
1976 /** CHECKED, WORKS WELL */
1977 const MetaTextAction* pA = (const MetaTextAction*)pAction;
1978 sal_uInt32 nTextLength(pA->GetLen());
1979 const sal_uInt32 nTextIndex(pA->GetIndex());
1980 const sal_uInt32 nStringLength(pA->GetText().getLength());
1981
1982 if(nTextLength + nTextIndex > nStringLength)
1983 {
1984 nTextLength = nStringLength - nTextIndex;
1985 }
1986
1987 if(nTextLength && rPropertyHolders.Current().getTextColorActive())
1988 {
1989 const std::vector< double > aDXArray;
1990 processMetaTextAction(
1991 pA->GetPoint(),
1992 pA->GetText(),
1993 nTextIndex,
1994 nTextLength,
1995 aDXArray,
1996 rTargetHolders.Current(),
1997 rPropertyHolders.Current());
1998 }
1999
2000 break;
2001 }
2002 case META_TEXTARRAY_ACTION :
2003 {
2004 /** CHECKED, WORKS WELL */
2005 const MetaTextArrayAction* pA = (const MetaTextArrayAction*)pAction;
2006 sal_uInt32 nTextLength(pA->GetLen());
2007 const sal_uInt32 nTextIndex(pA->GetIndex());
2008 const sal_uInt32 nStringLength(pA->GetText().getLength());
2009
2010 if(nTextLength + nTextIndex > nStringLength)
2011 {
2012 nTextLength = nTextIndex > nStringLength ? 0 : nStringLength - nTextIndex;
2013 }
2014
2015 if(nTextLength && rPropertyHolders.Current().getTextColorActive())
2016 {
2017 // preapare DXArray (if used)
2018 std::vector< double > aDXArray;
2019 sal_Int32* pDXArray = pA->GetDXArray();
2020
2021 if(pDXArray)
2022 {
2023 aDXArray.reserve(nTextLength);
2024
2025 for(sal_uInt32 a(0); a < nTextLength; a++)
2026 {
2027 aDXArray.push_back((double)(*(pDXArray + a)));
2028 }
2029 }
2030
2031 processMetaTextAction(
2032 pA->GetPoint(),
2033 pA->GetText(),
2034 nTextIndex,
2035 nTextLength,
2036 aDXArray,
2037 rTargetHolders.Current(),
2038 rPropertyHolders.Current());
2039 }
2040
2041 break;
2042 }
2043 case META_STRETCHTEXT_ACTION :
2044 {
2045 // #i108440# StarMath uses MetaStretchTextAction, thus support is needed.
2046 // It looks as if it pretty never really uses a width different from
2047 // the default text-layout width, but it's not possible to be sure.
2048 // Implemented getting the DXArray and checking for scale at all. If
2049 // scale is more than 3.5% different, scale the DXArray before usage.
2050 // New status:
2051
2052 /** CHECKED, WORKS WELL */
2053 const MetaStretchTextAction* pA = (const MetaStretchTextAction*)pAction;
2054 sal_uInt32 nTextLength(pA->GetLen());
2055 const sal_uInt32 nTextIndex(pA->GetIndex());
2056 const sal_uInt32 nStringLength(pA->GetText().getLength());
2057
2058 if(nTextLength + nTextIndex > nStringLength)
2059 {
2060 nTextLength = nStringLength - nTextIndex;
2061 }
2062
2063 if(nTextLength && rPropertyHolders.Current().getTextColorActive())
2064 {
2065 drawinglayer::primitive2d::TextLayouterDevice aTextLayouterDevice;
2066 aTextLayouterDevice.setFont(rPropertyHolders.Current().getFont());
2067
2068 ::std::vector< double > aTextArray(
2069 aTextLayouterDevice.getTextArray(
2070 pA->GetText(),
2071 nTextIndex,
2072 nTextLength));
2073
2074 if(!aTextArray.empty())
2075 {
2076 const double fTextLength(aTextArray.back());
2077
2078 if(0.0 != fTextLength && pA->GetWidth())
2079 {
2080 const double fRelative(pA->GetWidth() / fTextLength);
2081
2082 if(fabs(fRelative - 1.0) >= 0.035)
2083 {
2084 // when derivation is more than 3,5% from default text size,
2085 // scale the DXArray
2086 for(sal_uInt32 a(0); a < aTextArray.size(); a++)
2087 {
2088 aTextArray[a] *= fRelative;
2089 }
2090 }
2091 }
2092 }
2093
2094 processMetaTextAction(
2095 pA->GetPoint(),
2096 pA->GetText(),
2097 nTextIndex,
2098 nTextLength,
2099 aTextArray,
2100 rTargetHolders.Current(),
2101 rPropertyHolders.Current());
2102 }
2103
2104 break;
2105 }
2106 case META_TEXTRECT_ACTION :
2107 {
2108 /** CHECKED, WORKS WELL */
2109 // OSL_FAIL("META_TEXTRECT_ACTION requested (!)");
2110 const MetaTextRectAction* pA = (const MetaTextRectAction*)pAction;
2111 const Rectangle& rRectangle = pA->GetRect();
2112 const sal_uInt32 nStringLength(pA->GetText().getLength());
2113
2114 if(!rRectangle.IsEmpty() && 0 != nStringLength)
2115 {
2116 // The problem with this action is that it describes unlayouted text
2117 // and the layout capabilities are in EditEngine/Outliner in SVX. The
2118 // same problem is true for VCL which internally has implementations
2119 // to layout text in this case. There exists even a call
2120 // OutputDevice::AddTextRectActions(...) to create the needed actions
2121 // as 'sub-content' of a Metafile. Unfortunately i do not have an
2122 // OutputDevice here since this interpreter tries to work without
2123 // VCL AFAP.
2124 // Since AddTextRectActions is the only way as long as we do not have
2125 // a simple text layouter available, i will try to add it to the
2126 // TextLayouterDevice isloation.
2127 drawinglayer::primitive2d::TextLayouterDevice aTextLayouterDevice;
2128 aTextLayouterDevice.setFont(rPropertyHolders.Current().getFont());
2129 GDIMetaFile aGDIMetaFile;
2130
2131 aTextLayouterDevice.addTextRectActions(
2132 rRectangle, pA->GetText(), pA->GetStyle(), aGDIMetaFile);
2133
2134 if(aGDIMetaFile.GetActionSize())
2135 {
2136 // create sub-content
2137 drawinglayer::primitive2d::Primitive2DSequence xSubContent;
2138 {
2139 rTargetHolders.Push();
2140 // #i# for sub-Mteafile contents, do start with new, default render state
2141 rPropertyHolders.PushDefault();
2142 interpretMetafile(aGDIMetaFile, rTargetHolders, rPropertyHolders, rViewInformation);
2143 xSubContent = rTargetHolders.Current().getPrimitive2DSequence(rPropertyHolders.Current());
2144 rPropertyHolders.Pop();
2145 rTargetHolders.Pop();
2146 }
2147
2148 if(xSubContent.hasElements())
2149 {
2150 // add with transformation
2151 rTargetHolders.Current().append(
2152 new drawinglayer::primitive2d::TransformPrimitive2D(
2153 rPropertyHolders.Current().getTransformation(),
2154 xSubContent));
2155 }
2156 }
2157 }
2158
2159 break;
2160 }
2161 case META_BMP_ACTION :
2162 {
2163 /** CHECKED, WORKS WELL */
2164 const MetaBmpAction* pA = (const MetaBmpAction*)pAction;
2165 const BitmapEx aBitmapEx(pA->GetBitmap());
2166
2167 createBitmapExPrimitive(aBitmapEx, pA->GetPoint(), rTargetHolders.Current(), rPropertyHolders.Current());
2168
2169 break;
2170 }
2171 case META_BMPSCALE_ACTION :
2172 {
2173 /** CHECKED, WORKS WELL */
2174 const MetaBmpScaleAction* pA = (const MetaBmpScaleAction*)pAction;
2175 const Bitmap aBitmapEx(pA->GetBitmap());
2176
2177 createBitmapExPrimitive(aBitmapEx, pA->GetPoint(), pA->GetSize(), rTargetHolders.Current(), rPropertyHolders.Current());
2178
2179 break;
2180 }
2181 case META_BMPSCALEPART_ACTION :
2182 {
2183 /** CHECKED, WORKS WELL */
2184 const MetaBmpScalePartAction* pA = (const MetaBmpScalePartAction*)pAction;
2185 const Bitmap& rBitmap = pA->GetBitmap();
2186
2187 if(!rBitmap.IsEmpty())
2188 {
2189 Bitmap aCroppedBitmap(rBitmap);
2190 const Rectangle aCropRectangle(pA->GetSrcPoint(), pA->GetSrcSize());
2191
2192 if(!aCropRectangle.IsEmpty())
2193 {
2194 aCroppedBitmap.Crop(aCropRectangle);
2195 }
2196
2197 const BitmapEx aCroppedBitmapEx(aCroppedBitmap);
2198 createBitmapExPrimitive(aCroppedBitmapEx, pA->GetDestPoint(), pA->GetDestSize(), rTargetHolders.Current(), rPropertyHolders.Current());
2199 }
2200
2201 break;
2202 }
2203 case META_BMPEX_ACTION :
2204 {
2205 /** CHECKED, WORKS WELL: Simply same as META_BMP_ACTION */
2206 const MetaBmpExAction* pA = (const MetaBmpExAction*)pAction;
2207 const BitmapEx& rBitmapEx = pA->GetBitmapEx();
2208
2209 createBitmapExPrimitive(rBitmapEx, pA->GetPoint(), rTargetHolders.Current(), rPropertyHolders.Current());
2210
2211 break;
2212 }
2213 case META_BMPEXSCALE_ACTION :
2214 {
2215 /** CHECKED, WORKS WELL: Simply same as META_BMPSCALE_ACTION */
2216 const MetaBmpExScaleAction* pA = (const MetaBmpExScaleAction*)pAction;
2217 const BitmapEx& rBitmapEx = pA->GetBitmapEx();
2218
2219 createBitmapExPrimitive(rBitmapEx, pA->GetPoint(), pA->GetSize(), rTargetHolders.Current(), rPropertyHolders.Current());
2220
2221 break;
2222 }
2223 case META_BMPEXSCALEPART_ACTION :
2224 {
2225 /** CHECKED, WORKS WELL: Simply same as META_BMPSCALEPART_ACTION */
2226 const MetaBmpExScalePartAction* pA = (const MetaBmpExScalePartAction*)pAction;
2227 const BitmapEx& rBitmapEx = pA->GetBitmapEx();
2228
2229 if(!rBitmapEx.IsEmpty())
2230 {
2231 BitmapEx aCroppedBitmapEx(rBitmapEx);
2232 const Rectangle aCropRectangle(pA->GetSrcPoint(), pA->GetSrcSize());
2233
2234 if(!aCropRectangle.IsEmpty())
2235 {
2236 aCroppedBitmapEx.Crop(aCropRectangle);
2237 }
2238
2239 createBitmapExPrimitive(aCroppedBitmapEx, pA->GetDestPoint(), pA->GetDestSize(), rTargetHolders.Current(), rPropertyHolders.Current());
2240 }
2241
2242 break;
2243 }
2244 case META_MASK_ACTION :
2245 {
2246 /** CHECKED, WORKS WELL: Simply same as META_BMP_ACTION */
2247 const MetaMaskAction* pA = (const MetaMaskAction*)pAction;
2248 const BitmapEx aBitmapEx(createMaskBmpEx(pA->GetBitmap(), pA->GetColor()));
2249
2250 createBitmapExPrimitive(aBitmapEx, pA->GetPoint(), rTargetHolders.Current(), rPropertyHolders.Current());
2251
2252 break;
2253 }
2254 case META_MASKSCALE_ACTION :
2255 {
2256 /** CHECKED, WORKS WELL: Simply same as META_BMPSCALE_ACTION */
2257 const MetaMaskScaleAction* pA = (const MetaMaskScaleAction*)pAction;
2258 const BitmapEx aBitmapEx(createMaskBmpEx(pA->GetBitmap(), pA->GetColor()));
2259
2260 createBitmapExPrimitive(aBitmapEx, pA->GetPoint(), pA->GetSize(), rTargetHolders.Current(), rPropertyHolders.Current());
2261
2262 break;
2263 }
2264 case META_MASKSCALEPART_ACTION :
2265 {
2266 /** CHECKED, WORKS WELL: Simply same as META_BMPSCALEPART_ACTION */
2267 const MetaMaskScalePartAction* pA = (const MetaMaskScalePartAction*)pAction;
2268 const Bitmap& rBitmap = pA->GetBitmap();
2269
2270 if(!rBitmap.IsEmpty())
2271 {
2272 Bitmap aCroppedBitmap(rBitmap);
2273 const Rectangle aCropRectangle(pA->GetSrcPoint(), pA->GetSrcSize());
2274
2275 if(!aCropRectangle.IsEmpty())
2276 {
2277 aCroppedBitmap.Crop(aCropRectangle);
2278 }
2279
2280 const BitmapEx aCroppedBitmapEx(createMaskBmpEx(aCroppedBitmap, pA->GetColor()));
2281 createBitmapExPrimitive(aCroppedBitmapEx, pA->GetDestPoint(), pA->GetDestSize(), rTargetHolders.Current(), rPropertyHolders.Current());
2282 }
2283
2284 break;
2285 }
2286 case META_GRADIENT_ACTION :
2287 {
2288 /** CHECKED, WORKS WELL */
2289 const MetaGradientAction* pA = (const MetaGradientAction*)pAction;
2290 const Rectangle& rRectangle = pA->GetRect();
2291
2292 if(!rRectangle.IsEmpty())
2293 {
2294 basegfx::B2DRange aRange(rRectangle.Left(), rRectangle.Top(), rRectangle.Right(), rRectangle.Bottom());
2295
2296 if(!aRange.isEmpty())
2297 {
2298 const Gradient& rGradient = pA->GetGradient();
2299 const drawinglayer::attribute::FillGradientAttribute aAttribute(createFillGradientAttribute(rGradient));
2300 basegfx::B2DPolyPolygon aOutline(basegfx::tools::createPolygonFromRect(aRange));
2301
2302 if(aAttribute.getStartColor() == aAttribute.getEndColor())
2303 {
2304 // not really a gradient. Create filled rectangle
2305 createFillPrimitive(
2306 aOutline,
2307 rTargetHolders.Current(),
2308 rPropertyHolders.Current());
2309 }
2310 else
2311 {
2312 // really a gradient
2313 aRange.transform(rPropertyHolders.Current().getTransformation());
2314 drawinglayer::primitive2d::Primitive2DSequence xGradient(1);
2315
2316 if(rPropertyHolders.Current().isRasterOpInvert())
2317 {
2318 // use a special version of FillGradientPrimitive2D which creates
2319 // non-overlapping geometry on decomposition to makethe old XOR
2320 // paint 'trick' work.
2321 xGradient[0] = drawinglayer::primitive2d::Primitive2DReference(
2322 new drawinglayer::primitive2d::NonOverlappingFillGradientPrimitive2D(
2323 aRange,
2324 aAttribute));
2325 }
2326 else
2327 {
2328 xGradient[0] = drawinglayer::primitive2d::Primitive2DReference(
2329 new drawinglayer::primitive2d::FillGradientPrimitive2D(
2330 aRange,
2331 aAttribute));
2332 }
2333
2334 // #i112300# clip against polygon representing the rectangle from
2335 // the action. This is implicitely done using a temp Clipping in VCL
2336 // when a MetaGradientAction is executed
2337 aOutline.transform(rPropertyHolders.Current().getTransformation());
2338 rTargetHolders.Current().append(
2339 new drawinglayer::primitive2d::MaskPrimitive2D(
2340 aOutline,
2341 xGradient));
2342 }
2343 }
2344 }
2345
2346 break;
2347 }
2348 case META_HATCH_ACTION :
2349 {
2350 /** CHECKED, WORKS WELL */
2351 const MetaHatchAction* pA = (const MetaHatchAction*)pAction;
2352 basegfx::B2DPolyPolygon aOutline(pA->GetPolyPolygon().getB2DPolyPolygon());
2353
2354 if(aOutline.count())
2355 {
2356 const Hatch& rHatch = pA->GetHatch();
2357 const drawinglayer::attribute::FillHatchAttribute aAttribute(createFillHatchAttribute(rHatch));
2358
2359 aOutline.transform(rPropertyHolders.Current().getTransformation());
2360
2361 const basegfx::B2DRange aObjectRange(aOutline.getB2DRange());
2362 const drawinglayer::primitive2d::Primitive2DReference aFillHatch(
2363 new drawinglayer::primitive2d::FillHatchPrimitive2D(
2364 aObjectRange,
2365 basegfx::BColor(),
2366 aAttribute));
2367
2368 rTargetHolders.Current().append(
2369 new drawinglayer::primitive2d::MaskPrimitive2D(
2370 aOutline,
2371 drawinglayer::primitive2d::Primitive2DSequence(&aFillHatch, 1)));
2372 }
2373
2374 break;
2375 }
2376 case META_WALLPAPER_ACTION :
2377 {
2378 /** CHECKED, WORKS WELL */
2379 const MetaWallpaperAction* pA = (const MetaWallpaperAction*)pAction;
2380 Rectangle aWallpaperRectangle(pA->GetRect());
2381
2382 if(!aWallpaperRectangle.IsEmpty())
2383 {
2384 const Wallpaper& rWallpaper = pA->GetWallpaper();
2385 const WallpaperStyle eWallpaperStyle(rWallpaper.GetStyle());
2386 basegfx::B2DRange aWallpaperRange(
2387 aWallpaperRectangle.Left(), aWallpaperRectangle.Top(),
2388 aWallpaperRectangle.Right(), aWallpaperRectangle.Bottom());
2389
2390 if(WALLPAPER_NULL != eWallpaperStyle)
2391 {
2392 if(rWallpaper.IsBitmap())
2393 {
2394 // create bitmap background. Caution: This
2395 // also will create gradient/color background(s)
2396 // when the bitmap is transparent or not tiled
2397 CreateAndAppendBitmapWallpaper(
2398 aWallpaperRange,
2399 rWallpaper,
2400 rTargetHolders.Current(),
2401 rPropertyHolders.Current());
2402 }
2403 else if(rWallpaper.IsGradient())
2404 {
2405 // create gradient background
2406 rTargetHolders.Current().append(
2407 CreateGradientWallpaper(
2408 aWallpaperRange,
2409 rWallpaper.GetGradient(),
2410 rPropertyHolders.Current()));
2411 }
2412 else if(!rWallpaper.GetColor().GetTransparency())
2413 {
2414 // create color background
2415 rTargetHolders.Current().append(
2416 CreateColorWallpaper(
2417 aWallpaperRange,
2418 rWallpaper.GetColor().getBColor(),
2419 rPropertyHolders.Current()));
2420 }
2421 }
2422 }
2423
2424 break;
2425 }
2426 case META_CLIPREGION_ACTION :
2427 {
2428 /** CHECKED, WORKS WELL */
2429 const MetaClipRegionAction* pA = (const MetaClipRegionAction*)pAction;
2430
2431 if(pA->IsClipping())
2432 {
2433 // new clipping. Get PolyPolygon and transform with current transformation
2434 basegfx::B2DPolyPolygon aNewClipPolyPolygon(getB2DPolyPolygonFromRegion(pA->GetRegion()));
2435
2436 aNewClipPolyPolygon.transform(rPropertyHolders.Current().getTransformation());
2437 HandleNewClipRegion(aNewClipPolyPolygon, rTargetHolders, rPropertyHolders);
2438 }
2439 else
2440 {
2441 // end clipping
2442 const basegfx::B2DPolyPolygon aEmptyPolyPolygon;
2443
2444 HandleNewClipRegion(aEmptyPolyPolygon, rTargetHolders, rPropertyHolders);
2445 }
2446
2447 break;
2448 }
2449 case META_ISECTRECTCLIPREGION_ACTION :
2450 {
2451 /** CHECKED, WORKS WELL */
2452 const MetaISectRectClipRegionAction* pA = (const MetaISectRectClipRegionAction*)pAction;
2453 const Rectangle& rRectangle = pA->GetRect();
2454
2455 if(rRectangle.IsEmpty())
2456 {
2457 // intersect with empty rectangle will always give empty
2458 // ClipPolyPolygon; start new clipping with empty PolyPolygon
2459 const basegfx::B2DPolyPolygon aEmptyPolyPolygon;
2460
2461 HandleNewClipRegion(aEmptyPolyPolygon, rTargetHolders, rPropertyHolders);
2462 }
2463 else
2464 {
2465 // create transformed ClipRange
2466 basegfx::B2DRange aClipRange(
2467 rRectangle.Left(), rRectangle.Top(),
2468 rRectangle.Right(), rRectangle.Bottom());
2469
2470 aClipRange.transform(rPropertyHolders.Current().getTransformation());
2471
2472 if(rPropertyHolders.Current().getClipPolyPolygonActive())
2473 {
2474 if(0 == rPropertyHolders.Current().getClipPolyPolygon().count())
2475 {
2476 // nothing to do, empty active clipPolyPolygon will stay
2477 // empty when intersecting
2478 }
2479 else
2480 {
2481 // AND existing region and new ClipRange
2482 const basegfx::B2DPolyPolygon aOriginalPolyPolygon(
2483 rPropertyHolders.Current().getClipPolyPolygon());
2484 basegfx::B2DPolyPolygon aClippedPolyPolygon;
2485
2486 if(aOriginalPolyPolygon.count())
2487 {
2488 aClippedPolyPolygon = basegfx::tools::clipPolyPolygonOnRange(
2489 aOriginalPolyPolygon,
2490 aClipRange,
2491 true,
2492 false);
2493 }
2494
2495 if(aClippedPolyPolygon != aOriginalPolyPolygon)
2496 {
2497 // start new clipping with intersected region
2498 HandleNewClipRegion(
2499 aClippedPolyPolygon,
2500 rTargetHolders,
2501 rPropertyHolders);
2502 }
2503 }
2504 }
2505 else
2506 {
2507 // start new clipping with ClipRange
2508 const basegfx::B2DPolyPolygon aNewClipPolyPolygon(
2509 basegfx::tools::createPolygonFromRect(aClipRange));
2510
2511 HandleNewClipRegion(aNewClipPolyPolygon, rTargetHolders, rPropertyHolders);
2512 }
2513 }
2514
2515 break;
2516 }
2517 case META_ISECTREGIONCLIPREGION_ACTION :
2518 {
2519 /** CHECKED, WORKS WELL */
2520 const MetaISectRegionClipRegionAction* pA = (const MetaISectRegionClipRegionAction*)pAction;
2521 const Region& rNewRegion = pA->GetRegion();
2522
2523 if(rNewRegion.IsEmpty())
2524 {
2525 // intersect with empty region will always give empty
2526 // region; start new clipping with empty PolyPolygon
2527 const basegfx::B2DPolyPolygon aEmptyPolyPolygon;
2528
2529 HandleNewClipRegion(aEmptyPolyPolygon, rTargetHolders, rPropertyHolders);
2530 }
2531 else
2532 {
2533 // get new ClipPolyPolygon, transform it with current transformation
2534 basegfx::B2DPolyPolygon aNewClipPolyPolygon(getB2DPolyPolygonFromRegion(rNewRegion));
2535 aNewClipPolyPolygon.transform(rPropertyHolders.Current().getTransformation());
2536
2537 if(rPropertyHolders.Current().getClipPolyPolygonActive())
2538 {
2539 if(0 == rPropertyHolders.Current().getClipPolyPolygon().count())
2540 {
2541 // nothing to do, empty active clipPolyPolygon will stay empty
2542 // when intersecting with any region
2543 }
2544 else
2545 {
2546 // AND existing and new region
2547 const basegfx::B2DPolyPolygon aOriginalPolyPolygon(
2548 rPropertyHolders.Current().getClipPolyPolygon());
2549 basegfx::B2DPolyPolygon aClippedPolyPolygon;
2550
2551 if(aOriginalPolyPolygon.count())
2552 {
2553 aClippedPolyPolygon = basegfx::tools::clipPolyPolygonOnPolyPolygon(
2554 aOriginalPolyPolygon, aNewClipPolyPolygon, true, false);
2555 }
2556
2557 if(aClippedPolyPolygon != aOriginalPolyPolygon)
2558 {
2559 // start new clipping with intersected ClipPolyPolygon
2560 HandleNewClipRegion(aClippedPolyPolygon, rTargetHolders, rPropertyHolders);
2561 }
2562 }
2563 }
2564 else
2565 {
2566 // start new clipping with new ClipPolyPolygon
2567 HandleNewClipRegion(aNewClipPolyPolygon, rTargetHolders, rPropertyHolders);
2568 }
2569 }
2570
2571 break;
2572 }
2573 case META_MOVECLIPREGION_ACTION :
2574 {
2575 /** CHECKED, WORKS WELL */
2576 const MetaMoveClipRegionAction* pA = (const MetaMoveClipRegionAction*)pAction;
2577
2578 if(rPropertyHolders.Current().getClipPolyPolygonActive())
2579 {
2580 if(0 == rPropertyHolders.Current().getClipPolyPolygon().count())
2581 {
2582 // nothing to do
2583 }
2584 else
2585 {
2586 const sal_Int32 nHor(pA->GetHorzMove());
2587 const sal_Int32 nVer(pA->GetVertMove());
2588
2589 if(0 != nHor || 0 != nVer)
2590 {
2591 // prepare translation, add current transformation
2592 basegfx::B2DVector aVector(pA->GetHorzMove(), pA->GetVertMove());
2593 aVector *= rPropertyHolders.Current().getTransformation();
2594 basegfx::B2DHomMatrix aTransform(
2595 basegfx::tools::createTranslateB2DHomMatrix(aVector));
2596
2597 // transform existing region
2598 basegfx::B2DPolyPolygon aClipPolyPolygon(
2599 rPropertyHolders.Current().getClipPolyPolygon());
2600
2601 aClipPolyPolygon.transform(aTransform);
2602 HandleNewClipRegion(aClipPolyPolygon, rTargetHolders, rPropertyHolders);
2603 }
2604 }
2605 }
2606
2607 break;
2608 }
2609 case META_LINECOLOR_ACTION :
2610 {
2611 /** CHECKED, WORKS WELL */
2612 const MetaLineColorAction* pA = (const MetaLineColorAction*)pAction;
2613 const bool bActive(pA->IsSetting());
2614
2615 rPropertyHolders.Current().setLineColorActive(bActive);
2616 if(bActive)
2617 rPropertyHolders.Current().setLineColor(pA->GetColor().getBColor());
2618
2619 break;
2620 }
2621 case META_FILLCOLOR_ACTION :
2622 {
2623 /** CHECKED, WORKS WELL */
2624 const MetaFillColorAction* pA = (const MetaFillColorAction*)pAction;
2625 const bool bActive(pA->IsSetting());
2626
2627 rPropertyHolders.Current().setFillColorActive(bActive);
2628 if(bActive)
2629 rPropertyHolders.Current().setFillColor(pA->GetColor().getBColor());
2630
2631 break;
2632 }
2633 case META_TEXTCOLOR_ACTION :
2634 {
2635 /** SIMPLE, DONE */
2636 const MetaTextColorAction* pA = (const MetaTextColorAction*)pAction;
2637 const bool bActivate(COL_TRANSPARENT != pA->GetColor().GetColor());
2638
2639 rPropertyHolders.Current().setTextColorActive(bActivate);
2640 rPropertyHolders.Current().setTextColor(pA->GetColor().getBColor());
2641
2642 break;
2643 }
2644 case META_TEXTFILLCOLOR_ACTION :
2645 {
2646 /** SIMPLE, DONE */
2647 const MetaTextFillColorAction* pA = (const MetaTextFillColorAction*)pAction;
2648 const bool bWithColorArgument(pA->IsSetting());
2649
2650 if(bWithColorArgument)
2651 {
2652 // emulate OutputDevice::SetTextFillColor(...) WITH argument
2653 const Color& rFontFillColor = pA->GetColor();
2654 rPropertyHolders.Current().setTextFillColor(rFontFillColor.getBColor());
2655 rPropertyHolders.Current().setTextFillColorActive(COL_TRANSPARENT != rFontFillColor.GetColor());
2656 }
2657 else
2658 {
2659 // emulate SetFillColor() <- NO argument (!)
2660 rPropertyHolders.Current().setTextFillColorActive(false);
2661 }
2662
2663 break;
2664 }
2665 case META_TEXTALIGN_ACTION :
2666 {
2667 /** SIMPLE, DONE */
2668 const MetaTextAlignAction* pA = (const MetaTextAlignAction*)pAction;
2669 const TextAlign aNewTextAlign = pA->GetTextAlign();
2670
2671 // TextAlign is applied to the current font (as in
2672 // OutputDevice::SetTextAlign which would be used when
2673 // playing the Metafile)
2674 if(rPropertyHolders.Current().getFont().GetAlign() != aNewTextAlign)
2675 {
2676 Font aNewFont(rPropertyHolders.Current().getFont());
2677 aNewFont.SetAlign(aNewTextAlign);
2678 rPropertyHolders.Current().setFont(aNewFont);
2679 }
2680
2681 break;
2682 }
2683 case META_MAPMODE_ACTION :
2684 {
2685 /** CHECKED, WORKS WELL */
2686 // the most necessary MapMode to be interpreted is MAP_RELATIVE,
2687 // but also the others may occur. Even not yet supported ones
2688 // may need to be added here later
2689 const MetaMapModeAction* pA = (const MetaMapModeAction*)pAction;
2690 const MapMode& rMapMode = pA->GetMapMode();
2691 basegfx::B2DHomMatrix aMapping;
2692
2693 if(MAP_RELATIVE == rMapMode.GetMapUnit())
2694 {
2695 aMapping = getTransformFromMapMode(rMapMode);
2696 }
2697 else
2698 {
2699 switch(rMapMode.GetMapUnit())
2700 {
2701 case MAP_100TH_MM :
2702 {
2703 if(MAP_TWIP == rPropertyHolders.Current().getMapUnit())
2704 {
2705 // MAP_TWIP -> MAP_100TH_MM
2706 const double fTwipTo100thMm(127.0 / 72.0);
2707 aMapping.scale(fTwipTo100thMm, fTwipTo100thMm);
2708 }
2709 break;
2710 }
2711 case MAP_TWIP :
2712 {
2713 if(MAP_100TH_MM == rPropertyHolders.Current().getMapUnit())
2714 {
2715 // MAP_100TH_MM -> MAP_TWIP
2716 const double f100thMmToTwip(72.0 / 127.0);
2717 aMapping.scale(f100thMmToTwip, f100thMmToTwip);
2718 }
2719 break;
2720 }
2721 default :
2722 {
2723 OSL_FAIL("interpretMetafile: META_MAPMODE_ACTION with unsupported MapUnit (!)");
2724 break;
2725 }
2726 }
2727
2728 aMapping = getTransformFromMapMode(rMapMode) * aMapping;
2729 rPropertyHolders.Current().setMapUnit(rMapMode.GetMapUnit());
2730 }
2731
2732 if(!aMapping.isIdentity())
2733 {
2734 aMapping = aMapping * rPropertyHolders.Current().getTransformation();
2735 rPropertyHolders.Current().setTransformation(aMapping);
2736 }
2737
2738 break;
2739 }
2740 case META_FONT_ACTION :
2741 {
2742 /** SIMPLE, DONE */
2743 const MetaFontAction* pA = (const MetaFontAction*)pAction;
2744 rPropertyHolders.Current().setFont(pA->GetFont());
2745 Size aFontSize(pA->GetFont().GetSize());
2746
2747 if(0 == aFontSize.Height())
2748 {
2749 // this should not happen but i got Metafiles where this was the
2750 // case. A height needs to be guessed (similar to OutputDevice::ImplNewFont())
2751 Font aCorrectedFont(pA->GetFont());
2752
2753 // guess 16 pixel (as in VCL)
2754 aFontSize = Size(0, 16);
2755
2756 // convert to target MapUnit if not pixels
2757 aFontSize = Application::GetDefaultDevice()->LogicToLogic(
2758 aFontSize, MAP_PIXEL, rPropertyHolders.Current().getMapUnit());
2759
2760 aCorrectedFont.SetSize(aFontSize);
2761 rPropertyHolders.Current().setFont(aCorrectedFont);
2762 }
2763
2764 // older Metafiles have no META_TEXTCOLOR_ACTION which defines
2765 // the FontColor now, so use the Font's color when not transparent
2766 const Color& rFontColor = pA->GetFont().GetColor();
2767 const bool bActivate(COL_TRANSPARENT != rFontColor.GetColor());
2768
2769 if(bActivate)
2770 {
2771 rPropertyHolders.Current().setTextColor(rFontColor.getBColor());
2772 }
2773
2774 // caution: do NOT decativate here on transparet, see
2775 // OutputDevice::SetFont(..) for more info
2776 // rPropertyHolders.Current().setTextColorActive(bActivate);
2777
2778 // for fill color emulate a MetaTextFillColorAction with !transparent as bool,
2779 // see OutputDevice::SetFont(..) the if(mpMetaFile) case
2780 if(bActivate)
2781 {
2782 const Color& rFontFillColor = pA->GetFont().GetFillColor();
2783 rPropertyHolders.Current().setTextFillColor(rFontFillColor.getBColor());
2784 rPropertyHolders.Current().setTextFillColorActive(COL_TRANSPARENT != rFontFillColor.GetColor());
2785 }
2786 else
2787 {
2788 rPropertyHolders.Current().setTextFillColorActive(false);
2789 }
2790
2791 break;
2792 }
2793 case META_PUSH_ACTION :
2794 {
2795 /** CHECKED, WORKS WELL */
2796 const MetaPushAction* pA = (const MetaPushAction*)pAction;
2797 rPropertyHolders.Push(pA->GetFlags());
2798
2799 break;
2800 }
2801 case META_POP_ACTION :
2802 {
2803 /** CHECKED, WORKS WELL */
2804 const bool bRegionMayChange(rPropertyHolders.Current().getPushFlags() & PUSH_CLIPREGION);
2805 const bool bRasterOpMayChange(rPropertyHolders.Current().getPushFlags() & PUSH_RASTEROP);
2806
2807 if(bRegionMayChange && rPropertyHolders.Current().getClipPolyPolygonActive())
2808 {
2809 // end evtl. clipping
2810 const basegfx::B2DPolyPolygon aEmptyPolyPolygon;
2811
2812 HandleNewClipRegion(aEmptyPolyPolygon, rTargetHolders, rPropertyHolders);
2813 }
2814
2815 if(bRasterOpMayChange && rPropertyHolders.Current().isRasterOpActive())
2816 {
2817 // end evtl. RasterOp
2818 HandleNewRasterOp(ROP_OVERPAINT, rTargetHolders, rPropertyHolders);
2819 }
2820
2821 rPropertyHolders.Pop();
2822
2823 if(bRasterOpMayChange && rPropertyHolders.Current().isRasterOpActive())
2824 {
2825 // start evtl. RasterOp
2826 HandleNewRasterOp(rPropertyHolders.Current().getRasterOp(), rTargetHolders, rPropertyHolders);
2827 }
2828
2829 if(bRegionMayChange && rPropertyHolders.Current().getClipPolyPolygonActive())
2830 {
2831 // start evtl. clipping
2832 HandleNewClipRegion(
2833 rPropertyHolders.Current().getClipPolyPolygon(), rTargetHolders, rPropertyHolders);
2834 }
2835
2836 break;
2837 }
2838 case META_RASTEROP_ACTION :
2839 {
2840 /** CHECKED, WORKS WELL */
2841 const MetaRasterOpAction* pA = (const MetaRasterOpAction*)pAction;
2842 const RasterOp aRasterOp = pA->GetRasterOp();
2843
2844 HandleNewRasterOp(aRasterOp, rTargetHolders, rPropertyHolders);
2845
2846 break;
2847 }
2848 case META_TRANSPARENT_ACTION :
2849 {
2850 /** CHECKED, WORKS WELL */
2851 const MetaTransparentAction* pA = (const MetaTransparentAction*)pAction;
2852 const basegfx::B2DPolyPolygon aOutline(pA->GetPolyPolygon().getB2DPolyPolygon());
2853
2854 if(aOutline.count())
2855 {
2856 const sal_uInt16 nTransparence(pA->GetTransparence());
2857
2858 if(0 == nTransparence)
2859 {
2860 // not transparent
2861 createHairlineAndFillPrimitive(aOutline, rTargetHolders.Current(), rPropertyHolders.Current());
2862 }
2863 else if(nTransparence >= 100)
2864 {
2865 // fully or more than transparent
2866 }
2867 else
2868 {
2869 // transparent. Create new target
2870 rTargetHolders.Push();
2871
2872 // create primitives there and get them
2873 createHairlineAndFillPrimitive(aOutline, rTargetHolders.Current(), rPropertyHolders.Current());
2874 const drawinglayer::primitive2d::Primitive2DSequence aSubContent(
2875 rTargetHolders.Current().getPrimitive2DSequence(rPropertyHolders.Current()));
2876
2877 // back to old target
2878 rTargetHolders.Pop();
2879
2880 if(aSubContent.hasElements())
2881 {
2882 rTargetHolders.Current().append(
2883 new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
2884 aSubContent,
2885 nTransparence * 0.01));
2886 }
2887 }
2888 }
2889
2890 break;
2891 }
2892 case META_EPS_ACTION :
2893 {
2894 /** CHECKED, WORKS WELL */
2895 // To support this action, i have added a EpsPrimitive2D which will
2896 // by default decompose to the Metafile replacement data. To support
2897 // this EPS on screen, the renderer visualizing this has to support
2898 // that primitive and visualize the Eps file (e.g. printing)
2899 const MetaEPSAction* pA = (const MetaEPSAction*)pAction;
2900 const Rectangle aRectangle(pA->GetPoint(), pA->GetSize());
2901
2902 if(!aRectangle.IsEmpty())
2903 {
2904 // create object transform
2905 basegfx::B2DHomMatrix aObjectTransform;
2906
2907 aObjectTransform.set(0, 0, aRectangle.GetWidth());
2908 aObjectTransform.set(1, 1, aRectangle.GetHeight());
2909 aObjectTransform.set(0, 2, aRectangle.Left());
2910 aObjectTransform.set(1, 2, aRectangle.Top());
2911
2912 // add current transformation
2913 aObjectTransform = rPropertyHolders.Current().getTransformation() * aObjectTransform;
2914
2915 // embed using EpsPrimitive
2916 rTargetHolders.Current().append(
2917 new drawinglayer::primitive2d::EpsPrimitive2D(
2918 aObjectTransform,
2919 pA->GetLink(),
2920 pA->GetSubstitute()));
2921 }
2922
2923 break;
2924 }
2925 case META_REFPOINT_ACTION :
2926 {
2927 /** SIMPLE, DONE */
2928 // only used for hatch and line pattern offsets, pretty much no longer
2929 // supported today
2930 // const MetaRefPointAction* pA = (const MetaRefPointAction*)pAction;
2931 break;
2932 }
2933 case META_TEXTLINECOLOR_ACTION :
2934 {
2935 /** SIMPLE, DONE */
2936 const MetaTextLineColorAction* pA = (const MetaTextLineColorAction*)pAction;
2937 const bool bActive(pA->IsSetting());
2938
2939 rPropertyHolders.Current().setTextLineColorActive(bActive);
2940 if(bActive)
2941 rPropertyHolders.Current().setTextLineColor(pA->GetColor().getBColor());
2942
2943 break;
2944 }
2945 case META_TEXTLINE_ACTION :
2946 {
2947 /** CHECKED, WORKS WELL */
2948 // actually creates overline, underline and strikeouts, so
2949 // these should be isolated from TextDecoratedPortionPrimitive2D
2950 // to own primitives. Done, available now.
2951 //
2952 // This Metaaction seems not to be used (was not used in any
2953 // checked files). It's used in combination with the current
2954 // Font.
2955 const MetaTextLineAction* pA = (const MetaTextLineAction*)pAction;
2956
2957 proccessMetaTextLineAction(
2958 *pA,
2959 rTargetHolders.Current(),
2960 rPropertyHolders.Current());
2961
2962 break;
2963 }
2964 case META_FLOATTRANSPARENT_ACTION :
2965 {
2966 /** CHECKED, WORKS WELL */
2967 const MetaFloatTransparentAction* pA = (const MetaFloatTransparentAction*)pAction;
2968 const basegfx::B2DRange aTargetRange(
2969 pA->GetPoint().X(),
2970 pA->GetPoint().Y(),
2971 pA->GetPoint().X() + pA->GetSize().Width(),
2972 pA->GetPoint().Y() + pA->GetSize().Height());
2973
2974 if(!aTargetRange.isEmpty())
2975 {
2976 const GDIMetaFile& rContent = pA->GetGDIMetaFile();
2977
2978 if(rContent.GetActionSize())
2979 {
2980 // create the sub-content with no embedding specific to the
2981 // sub-metafile, this seems not to be used.
2982 drawinglayer::primitive2d::Primitive2DSequence xSubContent;
2983 {
2984 rTargetHolders.Push();
2985 // #i# for sub-Mteafile contents, do start with new, default render state
2986 rPropertyHolders.PushDefault();
2987 interpretMetafile(rContent, rTargetHolders, rPropertyHolders, rViewInformation);
2988 xSubContent = rTargetHolders.Current().getPrimitive2DSequence(rPropertyHolders.Current());
2989 rPropertyHolders.Pop();
2990 rTargetHolders.Pop();
2991 }
2992
2993 if(xSubContent.hasElements())
2994 {
2995 // create SourceRange
2996 const basegfx::B2DRange aSourceRange(
2997 rContent.GetPrefMapMode().GetOrigin().X(),
2998 rContent.GetPrefMapMode().GetOrigin().Y(),
2999 rContent.GetPrefMapMode().GetOrigin().X() + rContent.GetPrefSize().Width(),
3000 rContent.GetPrefMapMode().GetOrigin().Y() + rContent.GetPrefSize().Height());
3001
3002 // apply mapping if aTargetRange and aSourceRange are not equal
3003 if(!aSourceRange.equal(aTargetRange))
3004 {
3005 basegfx::B2DHomMatrix aTransform;
3006
3007 aTransform.translate(-aSourceRange.getMinX(), -aSourceRange.getMinY());
3008 aTransform.scale(
3009 aTargetRange.getWidth() / (basegfx::fTools::equalZero(aSourceRange.getWidth()) ? 1.0 : aSourceRange.getWidth()),
3010 aTargetRange.getHeight() / (basegfx::fTools::equalZero(aSourceRange.getHeight()) ? 1.0 : aSourceRange.getHeight()));
3011 aTransform.translate(aTargetRange.getMinX(), aTargetRange.getMinY());
3012
3013 const drawinglayer::primitive2d::Primitive2DReference aEmbeddedTransform(
3014 new drawinglayer::primitive2d::TransformPrimitive2D(
3015 aTransform,
3016 xSubContent));
3017
3018 xSubContent = drawinglayer::primitive2d::Primitive2DSequence(&aEmbeddedTransform, 1);
3019 }
3020
3021 // check if gradient is a real gradient
3022 const Gradient& rGradient = pA->GetGradient();
3023 const drawinglayer::attribute::FillGradientAttribute aAttribute(createFillGradientAttribute(rGradient));
3024
3025 if(aAttribute.getStartColor() == aAttribute.getEndColor())
3026 {
3027 // not really a gradient; create UnifiedTransparencePrimitive2D
3028 rTargetHolders.Current().append(
3029 new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
3030 xSubContent,
3031 aAttribute.getStartColor().luminance()));
3032 }
3033 else
3034 {
3035 // really a gradient. Create gradient sub-content (with correct scaling)
3036 basegfx::B2DRange aRange(aTargetRange);
3037 aRange.transform(rPropertyHolders.Current().getTransformation());
3038
3039 // prepare gradient for transparent content
3040 const drawinglayer::primitive2d::Primitive2DReference xTransparence(
3041 new drawinglayer::primitive2d::FillGradientPrimitive2D(
3042 aRange,
3043 aAttribute));
3044
3045 // create transparence primitive
3046 rTargetHolders.Current().append(
3047 new drawinglayer::primitive2d::TransparencePrimitive2D(
3048 xSubContent,
3049 drawinglayer::primitive2d::Primitive2DSequence(&xTransparence, 1)));
3050 }
3051 }
3052 }
3053 }
3054
3055 break;
3056 }
3057 case META_GRADIENTEX_ACTION :
3058 {
3059 /** SIMPLE, DONE */
3060 // This is only a data holder which is interpreted inside comment actions,
3061 // see META_COMMENT_ACTION for more info
3062 // const MetaGradientExAction* pA = (const MetaGradientExAction*)pAction;
3063 break;
3064 }
3065 case META_LAYOUTMODE_ACTION :
3066 {
3067 /** SIMPLE, DONE */
3068 const MetaLayoutModeAction* pA = (const MetaLayoutModeAction*)pAction;
3069 rPropertyHolders.Current().setLayoutMode(pA->GetLayoutMode());
3070 break;
3071 }
3072 case META_TEXTLANGUAGE_ACTION :
3073 {
3074 /** SIMPLE, DONE */
3075 const MetaTextLanguageAction* pA = (const MetaTextLanguageAction*)pAction;
3076 rPropertyHolders.Current().setLanguageType(pA->GetTextLanguage());
3077 break;
3078 }
3079 case META_OVERLINECOLOR_ACTION :
3080 {
3081 /** SIMPLE, DONE */
3082 const MetaOverlineColorAction* pA = (const MetaOverlineColorAction*)pAction;
3083 const bool bActive(pA->IsSetting());
3084
3085 rPropertyHolders.Current().setOverlineColorActive(bActive);
3086 if(bActive)
3087 rPropertyHolders.Current().setOverlineColor(pA->GetColor().getBColor());
3088
3089 break;
3090 }
3091 case META_COMMENT_ACTION :
3092 {
3093 /** CHECKED, WORKS WELL */
3094 // I already implemented
3095 // XPATHFILL_SEQ_BEGIN, XPATHFILL_SEQ_END
3096 // XPATHSTROKE_SEQ_BEGIN, XPATHSTROKE_SEQ_END,
3097 // but opted to remove these again; it works well without them
3098 // and makes the code less dependent from those Metafile Add-Ons
3099 const MetaCommentAction* pA = (const MetaCommentAction*)pAction;
3100
3101 if (pA->GetComment().equalsIgnoreAsciiCaseL(RTL_CONSTASCII_STRINGPARAM("XGRAD_SEQ_BEGIN")))
3102 {
3103 // XGRAD_SEQ_BEGIN, XGRAD_SEQ_END should be supported since the
3104 // pure recorded paint of the gradients uses the XOR paint functionality
3105 // ('trick'). This is (and will be) broblematic with AntAliasing, so it's
3106 // better to use this info
3107 const MetaGradientExAction* pMetaGradientExAction = 0;
3108 bool bDone(false);
3109 sal_uInt32 b(nAction + 1);
3110
3111 for(; !bDone && b < nCount; b++)
3112 {
3113 pAction = rMetaFile.GetAction(b);
3114
3115 if(META_GRADIENTEX_ACTION == pAction->GetType())
3116 {
3117 pMetaGradientExAction = (const MetaGradientExAction*)pAction;
3118 }
3119 else if(META_COMMENT_ACTION == pAction->GetType())
3120 {
3121 if (((const MetaCommentAction*)pAction)->GetComment().equalsIgnoreAsciiCaseL(RTL_CONSTASCII_STRINGPARAM("XGRAD_SEQ_END")))
3122 {
3123 bDone = true;
3124 }
3125 }
3126 }
3127
3128 if(bDone && pMetaGradientExAction)
3129 {
3130 // consume actions and skip forward
3131 nAction = b - 1;
3132
3133 // get geometry data
3134 basegfx::B2DPolyPolygon aPolyPolygon(pMetaGradientExAction->GetPolyPolygon().getB2DPolyPolygon());
3135
3136 if(aPolyPolygon.count())
3137 {
3138 // transform geometry
3139 aPolyPolygon.transform(rPropertyHolders.Current().getTransformation());
3140
3141 // get and check if gradient is a real gradient
3142 const Gradient& rGradient = pMetaGradientExAction->GetGradient();
3143 const drawinglayer::attribute::FillGradientAttribute aAttribute(createFillGradientAttribute(rGradient));
3144
3145 if(aAttribute.getStartColor() == aAttribute.getEndColor())
3146 {
3147 // not really a gradient
3148 rTargetHolders.Current().append(
3149 new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
3150 aPolyPolygon,
3151 aAttribute.getStartColor()));
3152 }
3153 else
3154 {
3155 // really a gradient
3156 rTargetHolders.Current().append(
3157 new drawinglayer::primitive2d::PolyPolygonGradientPrimitive2D(
3158 aPolyPolygon,
3159 aAttribute));
3160 }
3161 }
3162 }
3163 }
3164
3165 break;
3166 }
3167 default:
3168 {
3169 OSL_FAIL("Unknown MetaFile Action (!)");
3170 break;
3171 }
3172 }
3173 }
3174 }
3175 } // end of anonymous namespace
3176
3177 //////////////////////////////////////////////////////////////////////////////
3178
3179 namespace drawinglayer
3180 {
3181 namespace primitive2d
3182 {
3183 Primitive2DSequence MetafilePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
3184 {
3185 // prepare target and porperties; each will have one default entry
3186 TargetHolders aTargetHolders;
3187 PropertyHolders aPropertyHolders;
3188
3189 // set target MapUnit at Properties
3190 aPropertyHolders.Current().setMapUnit(getMetaFile().GetPrefMapMode().GetMapUnit());
3191
3192 // interpret the Metafile
3193 interpretMetafile(getMetaFile(), aTargetHolders, aPropertyHolders, rViewInformation);
3194
3195 // get the content. There should be only one target, as in the start condition,
3196 // but iterating will be the right thing to do when some push/pop is not closed
3197 Primitive2DSequence xRetval;
3198
3199 while(aTargetHolders.size() > 1)
3200 {
3201 appendPrimitive2DSequenceToPrimitive2DSequence(xRetval,
3202 aTargetHolders.Current().getPrimitive2DSequence(aPropertyHolders.Current()));
3203 aTargetHolders.Pop();
3204 }
3205
3206 appendPrimitive2DSequenceToPrimitive2DSequence(xRetval,
3207 aTargetHolders.Current().getPrimitive2DSequence(aPropertyHolders.Current()));
3208
3209 if(xRetval.hasElements())
3210 {
3211 // get target size
3212 const Rectangle aMtfTarget(getMetaFile().GetPrefMapMode().GetOrigin(), getMetaFile().GetPrefSize());
3213
3214 // create transformation
3215 basegfx::B2DHomMatrix aAdaptedTransform;
3216
3217 aAdaptedTransform.translate(-aMtfTarget.Left(), -aMtfTarget.Top());
3218 aAdaptedTransform.scale(
3219 aMtfTarget.getWidth() ? 1.0 / aMtfTarget.getWidth() : 1.0,
3220 aMtfTarget.getHeight() ? 1.0 / aMtfTarget.getHeight() : 1.0);
3221 aAdaptedTransform = getTransform() * aAdaptedTransform;
3222
3223 // embed to target transformation
3224 const Primitive2DReference aEmbeddedTransform(
3225 new TransformPrimitive2D(
3226 aAdaptedTransform,
3227 xRetval));
3228
3229 xRetval = Primitive2DSequence(&aEmbeddedTransform, 1);
3230 }
3231
3232 return xRetval;
3233 }
3234
3235 MetafilePrimitive2D::MetafilePrimitive2D(
3236 const basegfx::B2DHomMatrix& rMetaFileTransform,
3237 const GDIMetaFile& rMetaFile)
3238 : BufferedDecompositionPrimitive2D(),
3239 maMetaFileTransform(rMetaFileTransform),
3240 maMetaFile(rMetaFile)
3241 {
3242 }
3243
3244 bool MetafilePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
3245 {
3246 if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
3247 {
3248 const MetafilePrimitive2D& rCompare = (MetafilePrimitive2D&)rPrimitive;
3249
3250 return (getTransform() == rCompare.getTransform()
3251 && getMetaFile() == rCompare.getMetaFile());
3252 }
3253
3254 return false;
3255 }
3256
3257 basegfx::B2DRange MetafilePrimitive2D::getB2DRange(const geometry::ViewInformation2D& /*rViewInformation*/) const
3258 {
3259 // use own implementation to quickly answer the getB2DRange question. The
3260 // MetafilePrimitive2D assumes that all geometry is inside of the shape. If
3261 // this is not the case (i have already seen some wrong Metafiles) it should
3262 // be embedded to a MaskPrimitive2D
3263 basegfx::B2DRange aRetval(0.0, 0.0, 1.0, 1.0);
3264 aRetval.transform(getTransform());
3265
3266 return aRetval;
3267 }
3268
3269 // provide unique ID
3270 ImplPrimitive2DIDBlock(MetafilePrimitive2D, PRIMITIVE2D_ID_METAFILEPRIMITIVE2D)
3271
3272 } // end of namespace primitive2d
3273 } // end of namespace drawinglayer
3274
3275 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE