Line data Source code
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 "vclmetafileprocessor2d.hxx"
21 : #include <tools/gen.hxx>
22 : #include <vcl/virdev.hxx>
23 : #include <vcl/gdimtf.hxx>
24 : #include <vcl/gradient.hxx>
25 : #include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
26 : #include <drawinglayer/primitive2d/textprimitive2d.hxx>
27 : #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
28 : #include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
29 : #include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>
30 : #include <drawinglayer/primitive2d/maskprimitive2d.hxx>
31 : #include <drawinglayer/primitive2d/metafileprimitive2d.hxx>
32 : #include <basegfx/polygon/b2dpolygonclipper.hxx>
33 : #include <basegfx/polygon/b2dpolypolygontools.hxx>
34 : #include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx>
35 : #include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
36 : #include <drawinglayer/primitive2d/transparenceprimitive2d.hxx>
37 : #include <drawinglayer/primitive2d/fillgradientprimitive2d.hxx>
38 : #include "vclpixelprocessor2d.hxx"
39 : #include <tools/stream.hxx>
40 : #include <drawinglayer/primitive2d/transformprimitive2d.hxx>
41 : #include <drawinglayer/primitive2d/markerarrayprimitive2d.hxx>
42 : #include <drawinglayer/primitive2d/pointarrayprimitive2d.hxx>
43 : #include <vcl/graphictools.hxx>
44 : #include <vcl/metaact.hxx>
45 : #include <drawinglayer/primitive2d/texthierarchyprimitive2d.hxx>
46 : #include <drawinglayer/primitive2d/textdecoratedprimitive2d.hxx>
47 : #include <drawinglayer/primitive2d/openglprimitive2d.hxx>
48 : #include <comphelper/processfactory.hxx>
49 : #include <rtl/ustring.hxx>
50 : #include <com/sun/star/i18n/BreakIterator.hpp>
51 : #include <com/sun/star/i18n/CharacterIteratorMode.hpp>
52 : #include <com/sun/star/i18n/WordType.hpp>
53 : #include <drawinglayer/primitive2d/controlprimitive2d.hxx>
54 : #include <drawinglayer/primitive2d/graphicprimitive2d.hxx>
55 : #include <basegfx/polygon/b2dpolygontools.hxx>
56 : #include <drawinglayer/primitive2d/pagepreviewprimitive2d.hxx>
57 : #include <drawinglayer/primitive2d/epsprimitive2d.hxx>
58 : #include <basegfx/polygon/b2dlinegeometry.hxx>
59 : #include <vcl/dibtools.hxx>
60 :
61 : // for PDFExtOutDevData Graphic support
62 : #include <vcl/graph.hxx>
63 : #include <vcl/svapp.hxx>
64 : #include <toolkit/helper/formpdfexport.hxx>
65 :
66 : // for Control printing
67 : #include <com/sun/star/beans/XPropertySet.hpp>
68 :
69 : // for StructureTagPrimitive support in sd's unomodel.cxx
70 : #include <drawinglayer/primitive2d/structuretagprimitive2d.hxx>
71 :
72 : using namespace com::sun::star;
73 :
74 : // #112245# definition for maximum allowed point count due to Metafile target.
75 : // To be on the safe side with the old tools polygon, use slightly less then
76 : // the theoretical maximum (bad experiences with tools polygon)
77 :
78 : #define MAX_POLYGON_POINT_COUNT_METAFILE (0x0000fff0)
79 :
80 : namespace
81 : {
82 : // #112245# helper to split line polygon in half
83 0 : void splitLinePolygon(
84 : const basegfx::B2DPolygon& rBasePolygon,
85 : basegfx::B2DPolygon& o_aLeft,
86 : basegfx::B2DPolygon& o_aRight)
87 : {
88 0 : const sal_uInt32 nCount(rBasePolygon.count());
89 :
90 0 : if(nCount)
91 : {
92 0 : const sal_uInt32 nHalfCount((nCount - 1) >> 1);
93 :
94 0 : o_aLeft = basegfx::B2DPolygon(rBasePolygon, 0, nHalfCount + 1);
95 0 : o_aLeft.setClosed(false);
96 :
97 0 : o_aRight = basegfx::B2DPolygon(rBasePolygon, nHalfCount, nCount - nHalfCount);
98 0 : o_aRight.setClosed(false);
99 :
100 0 : if(rBasePolygon.isClosed())
101 : {
102 0 : o_aRight.append(rBasePolygon.getB2DPoint(0));
103 :
104 0 : if(rBasePolygon.areControlPointsUsed())
105 : {
106 : o_aRight.setControlPoints(
107 0 : o_aRight.count() - 1,
108 : rBasePolygon.getPrevControlPoint(0),
109 0 : rBasePolygon.getNextControlPoint(0));
110 : }
111 : }
112 : }
113 : else
114 : {
115 0 : o_aLeft.clear();
116 0 : o_aRight.clear();
117 : }
118 0 : }
119 :
120 : // #112245# helper to evtl. split filled polygons to maximum metafile point count
121 1490 : bool fillPolyPolygonNeededToBeSplit(basegfx::B2DPolyPolygon& rPolyPolygon)
122 : {
123 1490 : bool bRetval(false);
124 1490 : const sal_uInt32 nPolyCount(rPolyPolygon.count());
125 :
126 1490 : if(nPolyCount)
127 : {
128 1490 : basegfx::B2DPolyPolygon aSplitted;
129 :
130 4484 : for(sal_uInt32 a(0); a < nPolyCount; a++)
131 : {
132 2994 : const basegfx::B2DPolygon aCandidate(rPolyPolygon.getB2DPolygon(a));
133 2994 : const sal_uInt32 nPointCount(aCandidate.count());
134 2994 : bool bNeedToSplit(false);
135 :
136 2994 : if(aCandidate.areControlPointsUsed())
137 : {
138 : // compare with the maximum for bezier curved polygons
139 184 : bNeedToSplit = nPointCount > ((MAX_POLYGON_POINT_COUNT_METAFILE / 3L) - 1L);
140 : }
141 : else
142 : {
143 : // compare with the maximum for simple point polygons
144 2810 : bNeedToSplit = nPointCount > (MAX_POLYGON_POINT_COUNT_METAFILE - 1);
145 : }
146 :
147 2994 : if(bNeedToSplit)
148 : {
149 : // need to split the partial polygon
150 0 : const basegfx::B2DRange aRange(aCandidate.getB2DRange());
151 0 : const basegfx::B2DPoint aCenter(aRange.getCenter());
152 :
153 0 : if(aRange.getWidth() > aRange.getHeight())
154 : {
155 : // clip in left and right
156 : const basegfx::B2DPolyPolygon aLeft(
157 : basegfx::tools::clipPolygonOnParallelAxis(
158 : aCandidate,
159 : false,
160 : true,
161 : aCenter.getX(),
162 0 : false));
163 : const basegfx::B2DPolyPolygon aRight(
164 : basegfx::tools::clipPolygonOnParallelAxis(
165 : aCandidate,
166 : false,
167 : false,
168 : aCenter.getX(),
169 0 : false));
170 :
171 0 : aSplitted.append(aLeft);
172 0 : aSplitted.append(aRight);
173 : }
174 : else
175 : {
176 : // clip in top and bottom
177 : const basegfx::B2DPolyPolygon aTop(
178 : basegfx::tools::clipPolygonOnParallelAxis(
179 : aCandidate,
180 : true,
181 : true,
182 : aCenter.getY(),
183 0 : false));
184 : const basegfx::B2DPolyPolygon aBottom(
185 : basegfx::tools::clipPolygonOnParallelAxis(
186 : aCandidate,
187 : true,
188 : false,
189 : aCenter.getY(),
190 0 : false));
191 :
192 0 : aSplitted.append(aTop);
193 0 : aSplitted.append(aBottom);
194 0 : }
195 : }
196 : else
197 : {
198 2994 : aSplitted.append(aCandidate);
199 : }
200 2994 : }
201 :
202 1490 : if(aSplitted.count() != nPolyCount)
203 : {
204 0 : rPolyPolygon = aSplitted;
205 1490 : }
206 : }
207 :
208 1490 : return bRetval;
209 : }
210 :
211 : /** Filter input polypolygon for effectively empty sub-fills
212 :
213 : Needed to fix fdo#37559
214 :
215 : @param rPoly
216 : tools::PolyPolygon to filter
217 :
218 : @return converted tools PolyPolygon, w/o one-point fills
219 : */
220 48 : tools::PolyPolygon getFillPolyPolygon( const ::basegfx::B2DPolyPolygon& rPoly )
221 : {
222 : // filter input rPoly
223 48 : basegfx::B2DPolyPolygon aPoly;
224 48 : sal_uInt32 nCount(rPoly.count());
225 336 : for( sal_uInt32 i=0; i<nCount; ++i )
226 : {
227 288 : basegfx::B2DPolygon aCandidate(rPoly.getB2DPolygon(i));
228 288 : if( !aCandidate.isClosed() || aCandidate.count() > 1 )
229 206 : aPoly.append(aCandidate);
230 288 : }
231 48 : return tools::PolyPolygon(aPoly);
232 : }
233 :
234 : } // end of anonymous namespace
235 :
236 : namespace drawinglayer
237 : {
238 : namespace processor2d
239 : {
240 9 : Rectangle VclMetafileProcessor2D::impDumpToMetaFile(
241 : const primitive2d::Primitive2DSequence& rContent,
242 : GDIMetaFile& o_rContentMetafile)
243 : {
244 : // Prepare VDev, MetaFile and connections
245 9 : OutputDevice* pLastOutputDevice = mpOutputDevice;
246 9 : GDIMetaFile* pLastMetafile = mpMetaFile;
247 9 : basegfx::B2DRange aPrimitiveRange(primitive2d::getB2DRangeFromPrimitive2DSequence(rContent, getViewInformation2D()));
248 :
249 : // transform primitive range with current transformation (e.g shadow offset)
250 9 : aPrimitiveRange.transform(maCurrentTransformation);
251 :
252 : const Rectangle aPrimitiveRectangle(
253 18 : basegfx::fround(aPrimitiveRange.getMinX()), basegfx::fround(aPrimitiveRange.getMinY()),
254 27 : basegfx::fround(aPrimitiveRange.getMaxX()), basegfx::fround(aPrimitiveRange.getMaxY()));
255 9 : ScopedVclPtrInstance< VirtualDevice > aContentVDev;
256 18 : MapMode aNewMapMode(pLastOutputDevice->GetMapMode());
257 :
258 9 : mpOutputDevice = aContentVDev.get();
259 9 : mpMetaFile = &o_rContentMetafile;
260 9 : aContentVDev->EnableOutput(false);
261 9 : aContentVDev->SetMapMode(pLastOutputDevice->GetMapMode());
262 9 : o_rContentMetafile.Record(aContentVDev.get());
263 9 : aContentVDev->SetLineColor(pLastOutputDevice->GetLineColor());
264 9 : aContentVDev->SetFillColor(pLastOutputDevice->GetFillColor());
265 9 : aContentVDev->SetFont(pLastOutputDevice->GetFont());
266 9 : aContentVDev->SetDrawMode(pLastOutputDevice->GetDrawMode());
267 9 : aContentVDev->SetSettings(pLastOutputDevice->GetSettings());
268 9 : aContentVDev->SetRefPoint(pLastOutputDevice->GetRefPoint());
269 :
270 : // dump to MetaFile
271 9 : process(rContent);
272 :
273 : // cleanups
274 9 : o_rContentMetafile.Stop();
275 9 : o_rContentMetafile.WindStart();
276 9 : aNewMapMode.SetOrigin(aPrimitiveRectangle.TopLeft());
277 9 : o_rContentMetafile.SetPrefMapMode(aNewMapMode);
278 9 : o_rContentMetafile.SetPrefSize(aPrimitiveRectangle.GetSize());
279 9 : mpOutputDevice = pLastOutputDevice;
280 9 : mpMetaFile = pLastMetafile;
281 :
282 18 : return aPrimitiveRectangle;
283 : }
284 :
285 9 : void VclMetafileProcessor2D::impConvertFillGradientAttributeToVCLGradient(
286 : Gradient& o_rVCLGradient,
287 : const attribute::FillGradientAttribute& rFiGrAtt,
288 : bool bIsTransparenceGradient)
289 : {
290 9 : if(bIsTransparenceGradient)
291 : {
292 : // it's about transparence channel intensities (black/white), do not use color modifier
293 5 : o_rVCLGradient.SetStartColor(Color(rFiGrAtt.getStartColor()));
294 5 : o_rVCLGradient.SetEndColor(Color(rFiGrAtt.getEndColor()));
295 : }
296 : else
297 : {
298 : // use color modifier to influence start/end color of gradient
299 4 : o_rVCLGradient.SetStartColor(Color(maBColorModifierStack.getModifiedColor(rFiGrAtt.getStartColor())));
300 4 : o_rVCLGradient.SetEndColor(Color(maBColorModifierStack.getModifiedColor(rFiGrAtt.getEndColor())));
301 : }
302 :
303 9 : o_rVCLGradient.SetAngle(static_cast< sal_uInt16 >(rFiGrAtt.getAngle() * (1.0 / F_PI1800)));
304 9 : o_rVCLGradient.SetBorder(static_cast< sal_uInt16 >(rFiGrAtt.getBorder() * 100.0));
305 9 : o_rVCLGradient.SetOfsX(static_cast< sal_uInt16 >(rFiGrAtt.getOffsetX() * 100.0));
306 9 : o_rVCLGradient.SetOfsY(static_cast< sal_uInt16 >(rFiGrAtt.getOffsetY() * 100.0));
307 9 : o_rVCLGradient.SetSteps(rFiGrAtt.getSteps());
308 :
309 : // defaults for intensity; those were computed into the start/end colors already
310 9 : o_rVCLGradient.SetStartIntensity(100);
311 9 : o_rVCLGradient.SetEndIntensity(100);
312 :
313 9 : switch(rFiGrAtt.getStyle())
314 : {
315 : default : // attribute::GRADIENTSTYLE_LINEAR :
316 : {
317 7 : o_rVCLGradient.SetStyle(GradientStyle_LINEAR);
318 7 : break;
319 : }
320 : case attribute::GRADIENTSTYLE_AXIAL :
321 : {
322 2 : o_rVCLGradient.SetStyle(GradientStyle_AXIAL);
323 2 : break;
324 : }
325 : case attribute::GRADIENTSTYLE_RADIAL :
326 : {
327 0 : o_rVCLGradient.SetStyle(GradientStyle_RADIAL);
328 0 : break;
329 : }
330 : case attribute::GRADIENTSTYLE_ELLIPTICAL :
331 : {
332 0 : o_rVCLGradient.SetStyle(GradientStyle_ELLIPTICAL);
333 0 : break;
334 : }
335 : case attribute::GRADIENTSTYLE_SQUARE :
336 : {
337 0 : o_rVCLGradient.SetStyle(GradientStyle_SQUARE);
338 0 : break;
339 : }
340 : case attribute::GRADIENTSTYLE_RECT :
341 : {
342 0 : o_rVCLGradient.SetStyle(GradientStyle_RECT);
343 0 : break;
344 : }
345 : }
346 9 : }
347 :
348 48 : void VclMetafileProcessor2D::impStartSvtGraphicFill(SvtGraphicFill* pSvtGraphicFill)
349 : {
350 48 : if(pSvtGraphicFill && !mnSvtGraphicFillCount)
351 : {
352 48 : SvMemoryStream aMemStm;
353 :
354 48 : WriteSvtGraphicFill( aMemStm, *pSvtGraphicFill );
355 48 : mpMetaFile->AddAction(new MetaCommentAction("XPATHFILL_SEQ_BEGIN", 0, static_cast< const sal_uInt8* >(aMemStm.GetData()), aMemStm.Seek(STREAM_SEEK_TO_END)));
356 48 : mnSvtGraphicFillCount++;
357 : }
358 48 : }
359 :
360 48 : void VclMetafileProcessor2D::impEndSvtGraphicFill(SvtGraphicFill* pSvtGraphicFill)
361 : {
362 48 : if(pSvtGraphicFill && mnSvtGraphicFillCount)
363 : {
364 48 : mnSvtGraphicFillCount--;
365 48 : mpMetaFile->AddAction(new MetaCommentAction("XPATHFILL_SEQ_END"));
366 48 : delete pSvtGraphicFill;
367 : }
368 48 : }
369 :
370 2576 : double VclMetafileProcessor2D::getTransformedLineWidth( double fWidth ) const
371 : {
372 : // #i113922# the LineWidth is duplicated in the MetaPolylineAction,
373 : // and also inside the SvtGraphicStroke and needs transforming into
374 : // the same space as its co-ordinates here cf. fdo#61789
375 : // This is a partial fix. When a object transformation is used which
376 : // e.g. contains a scaleX != scaleY, an unproportional scaling will happen.
377 2576 : const basegfx::B2DVector aDiscreteUnit( maCurrentTransformation * basegfx::B2DVector( fWidth, 0.0 ) );
378 :
379 2576 : return aDiscreteUnit.getLength();
380 : }
381 :
382 2037 : SvtGraphicStroke* VclMetafileProcessor2D::impTryToCreateSvtGraphicStroke(
383 : const basegfx::B2DPolygon& rB2DPolygon,
384 : const basegfx::BColor* pColor,
385 : const attribute::LineAttribute* pLineAttribute,
386 : const attribute::StrokeAttribute* pStrokeAttribute,
387 : const attribute::LineStartEndAttribute* pStart,
388 : const attribute::LineStartEndAttribute* pEnd)
389 : {
390 2037 : SvtGraphicStroke* pRetval = 0;
391 :
392 2037 : if(rB2DPolygon.count() && !mnSvtGraphicStrokeCount)
393 : {
394 1981 : basegfx::B2DPolygon aLocalPolygon(rB2DPolygon);
395 3962 : basegfx::BColor aStrokeColor;
396 3962 : basegfx::B2DPolyPolygon aStartArrow;
397 3962 : basegfx::B2DPolyPolygon aEndArrow;
398 :
399 1981 : if(pColor)
400 : {
401 0 : aStrokeColor = *pColor;
402 : }
403 1981 : else if(pLineAttribute)
404 : {
405 1981 : aStrokeColor = maBColorModifierStack.getModifiedColor(pLineAttribute->getColor());
406 : }
407 :
408 : // It IS needed to record the stroke color at all in the metafile,
409 : // SvtGraphicStroke has NO entry for stroke color(!)
410 1981 : mpOutputDevice->SetLineColor(Color(aStrokeColor));
411 :
412 1981 : if(!aLocalPolygon.isClosed())
413 : {
414 511 : double fPolyLength(0.0);
415 511 : double fStart(0.0);
416 511 : double fEnd(0.0);
417 :
418 511 : if(pStart && pStart->isActive())
419 : {
420 45 : fPolyLength = basegfx::tools::getLength(aLocalPolygon);
421 :
422 135 : aStartArrow = basegfx::tools::createAreaGeometryForLineStartEnd(
423 45 : aLocalPolygon, pStart->getB2DPolyPolygon(), true, pStart->getWidth(),
424 90 : fPolyLength, pStart->isCentered() ? 0.5 : 0.0, &fStart);
425 : }
426 :
427 511 : if(pEnd && pEnd->isActive())
428 : {
429 56 : if(basegfx::fTools::equalZero(fPolyLength))
430 : {
431 37 : fPolyLength = basegfx::tools::getLength(aLocalPolygon);
432 : }
433 :
434 168 : aEndArrow = basegfx::tools::createAreaGeometryForLineStartEnd(
435 56 : aLocalPolygon, pEnd->getB2DPolyPolygon(), false, pEnd->getWidth(),
436 112 : fPolyLength, pEnd->isCentered() ? 0.5 : 0.0, &fEnd);
437 : }
438 :
439 511 : if(0.0 != fStart || 0.0 != fEnd)
440 : {
441 : // build new poly, consume something from old poly
442 56 : aLocalPolygon = basegfx::tools::getSnippetAbsolute(aLocalPolygon, fStart, fPolyLength - fEnd, fPolyLength);
443 : }
444 : }
445 :
446 1981 : SvtGraphicStroke::JoinType eJoin(SvtGraphicStroke::joinNone);
447 1981 : SvtGraphicStroke::CapType eCap(SvtGraphicStroke::capButt);
448 1981 : double fLineWidth(0.0);
449 1981 : double fMiterLength(0.0);
450 3962 : SvtGraphicStroke::DashArray aDashArray;
451 :
452 1981 : if(pLineAttribute)
453 : {
454 1981 : fLineWidth = fMiterLength = getTransformedLineWidth( pLineAttribute->getWidth() );
455 :
456 : // get Join
457 1981 : switch(pLineAttribute->getLineJoin())
458 : {
459 : default : // basegfx::B2DLineJoin::NONE :
460 : {
461 3 : eJoin = SvtGraphicStroke::joinNone;
462 3 : break;
463 : }
464 : case basegfx::B2DLineJoin::Bevel :
465 : {
466 156 : eJoin = SvtGraphicStroke::joinBevel;
467 156 : break;
468 : }
469 : case basegfx::B2DLineJoin::Middle :
470 : case basegfx::B2DLineJoin::Miter :
471 : {
472 190 : eJoin = SvtGraphicStroke::joinMiter;
473 : // ATM 15 degrees is assumed
474 190 : fMiterLength /= rtl::math::sin(M_PI * (15.0 / 360.0));
475 190 : break;
476 : }
477 : case basegfx::B2DLineJoin::Round :
478 : {
479 1632 : eJoin = SvtGraphicStroke::joinRound;
480 1632 : break;
481 : }
482 : }
483 :
484 : // get stroke
485 1981 : switch(pLineAttribute->getLineCap())
486 : {
487 : default: /* com::sun::star::drawing::LineCap_BUTT */
488 : {
489 1978 : eCap = SvtGraphicStroke::capButt;
490 1978 : break;
491 : }
492 : case com::sun::star::drawing::LineCap_ROUND:
493 : {
494 3 : eCap = SvtGraphicStroke::capRound;
495 3 : break;
496 : }
497 : case com::sun::star::drawing::LineCap_SQUARE:
498 : {
499 0 : eCap = SvtGraphicStroke::capSquare;
500 0 : break;
501 : }
502 : }
503 : }
504 :
505 1981 : if(pStrokeAttribute)
506 : {
507 : // copy dash array
508 1981 : aDashArray = pStrokeAttribute->getDotDashArray();
509 : }
510 :
511 : // #i101734# apply current object transformation to created geometry.
512 : // This is a partial fix. When a object transformation is used which
513 : // e.g. contains a scaleX != scaleY, an unproportional scaling would
514 : // have to be applied to the evtl. existing fat line. The current
515 : // concept of PDF export and SvtGraphicStroke usage does simply not
516 : // allow handling such definitions. The only clean way would be to
517 : // add the transformation to SvtGraphicStroke and to handle it there
518 1981 : aLocalPolygon.transform(maCurrentTransformation);
519 1981 : aStartArrow.transform(maCurrentTransformation);
520 1981 : aEndArrow.transform(maCurrentTransformation);
521 :
522 : pRetval = new SvtGraphicStroke(
523 : Polygon(aLocalPolygon),
524 : tools::PolyPolygon(aStartArrow),
525 : tools::PolyPolygon(aEndArrow),
526 : mfCurrentUnifiedTransparence,
527 : fLineWidth,
528 : eCap,
529 : eJoin,
530 : fMiterLength,
531 3962 : aDashArray);
532 : }
533 :
534 2037 : return pRetval;
535 : }
536 :
537 2037 : void VclMetafileProcessor2D::impStartSvtGraphicStroke(SvtGraphicStroke* pSvtGraphicStroke)
538 : {
539 2037 : if(pSvtGraphicStroke && !mnSvtGraphicStrokeCount)
540 : {
541 1981 : SvMemoryStream aMemStm;
542 :
543 1981 : WriteSvtGraphicStroke( aMemStm, *pSvtGraphicStroke );
544 1981 : mpMetaFile->AddAction(new MetaCommentAction("XPATHSTROKE_SEQ_BEGIN", 0, static_cast< const sal_uInt8* >(aMemStm.GetData()), aMemStm.Seek(STREAM_SEEK_TO_END)));
545 1981 : mnSvtGraphicStrokeCount++;
546 : }
547 2037 : }
548 :
549 2037 : void VclMetafileProcessor2D::impEndSvtGraphicStroke(SvtGraphicStroke* pSvtGraphicStroke)
550 : {
551 2037 : if(pSvtGraphicStroke && mnSvtGraphicStrokeCount)
552 : {
553 1981 : mnSvtGraphicStrokeCount--;
554 1981 : mpMetaFile->AddAction(new MetaCommentAction("XPATHSTROKE_SEQ_END"));
555 1981 : delete pSvtGraphicStroke;
556 : }
557 2037 : }
558 :
559 : // init static break iterator
560 251 : uno::Reference< ::com::sun::star::i18n::XBreakIterator > VclMetafileProcessor2D::mxBreakIterator;
561 :
562 871 : VclMetafileProcessor2D::VclMetafileProcessor2D(const geometry::ViewInformation2D& rViewInformation, OutputDevice& rOutDev)
563 : : VclProcessor2D(rViewInformation, rOutDev),
564 871 : mpMetaFile(rOutDev.GetConnectMetaFile()),
565 : mnSvtGraphicFillCount(0),
566 : mnSvtGraphicStrokeCount(0),
567 : mfCurrentUnifiedTransparence(0.0),
568 1742 : mpPDFExtOutDevData(dynamic_cast< vcl::PDFExtOutDevData* >(rOutDev.GetExtOutDevData()))
569 : {
570 : OSL_ENSURE(rOutDev.GetConnectMetaFile(), "VclMetafileProcessor2D: Used on OutDev which has no MetaFile Target (!)");
571 : // draw to logic coordinates, do not initialize maCurrentTransformation to viewTransformation
572 : // but only to ObjectTransformation. Do not change MapMode of destination.
573 871 : maCurrentTransformation = rViewInformation.getObjectTransformation();
574 871 : }
575 :
576 1742 : VclMetafileProcessor2D::~VclMetafileProcessor2D()
577 : {
578 : // MapMode was not changed, no restore necessary
579 1742 : }
580 :
581 : /***********************************************************************************************
582 :
583 : Support of MetaCommentActions in the VclMetafileProcessor2D
584 : Found MetaCommentActions and how they are supported:
585 :
586 : XGRAD_SEQ_BEGIN, XGRAD_SEQ_END:
587 :
588 : Used inside OutputDevice::DrawGradient to mark the start and end of a MetaGradientEx action.
589 : It is used in various exporters/importers to have direct access to the gradient before it
590 : is rendered by VCL (and thus fragmented to polygon color actions and others). On that base, e.g.
591 : the Metafile to SdrObject import creates it's gradient objects.
592 : Best (and safest) way to support it here is to use PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D,
593 : map it back to the corresponding tools tools::PolyPolygon and the Gradient and just call
594 : OutputDevice::DrawGradient which creates the necessary compatible actions.
595 :
596 : XPATHFILL_SEQ_BEGIN, XPATHFILL_SEQ_END:
597 :
598 : Two producers, one is vcl/source/gdi/gdimtf.cxx, line 1273. There, it is transformed
599 : inside GDIMetaFile::Rotate, nothing to take care of here.
600 : The second producer is in graphics/svx/source/svdraw/impgrfll.cxx, line 374. This is used
601 : with each incarnation of Imp_GraphicFill when a metafile is recorded, fillstyle is not
602 : XFILL_NONE and not completely transparent. It creates a SvtGraphicFill and streams it
603 : to the comment action. A closing end token is created in the destructor.
604 : Usages of Imp_GraphicFill are in Do_Paint_Object-methods of SdrCircObj, SdrPathObj and
605 : SdrRectObj.
606 : The token users pick various actions from SvtGraphicFill, so it may need to be added for all kind
607 : of filled objects, even simple colored polygons. It is added as extra information; the
608 : Metafile actions between the two tokens are interpreted as output generated from those
609 : fills. Thus, users have the choice to use the SvtGraphicFill info or the created output
610 : actions.
611 : Even for XFillTransparenceItem it is used, thus it may need to be supported in
612 : UnifiedTransparencePrimitive2D, too, when interpreted as normally filled PolyPolygon.
613 : Implemented for:
614 : PRIMITIVE2D_ID_POLYPOLYGONGRAPHICPRIMITIVE2D,
615 : PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D,
616 : PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D,
617 : PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D,
618 : and for PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D when detected unified transparence
619 :
620 : XPATHSTROKE_SEQ_BEGIN, XPATHSTROKE_SEQ_END:
621 :
622 : Similar to pathfill, but using SvtGraphicStroke instead. It also has two producers where one
623 : is also the GDIMetaFile::Rotate. Another user is MetaCommentAction::Move which modifies the
624 : contained path accordingly.
625 : The other one is SdrObject::Imp_DrawLineGeometry. It's done when MetaFile is set at OutDev and
626 : only when geometry is a single polygon (!). I see no reason for that; in the PS exporter this
627 : would hinder to make use of tools::PolyPolygon strokes. I will need to add support at:
628 : PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D
629 : PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D
630 : PRIMITIVE2D_ID_POLYGONSTROKEARROWPRIMITIVE2D
631 : This can be done hierarchical, too.
632 : Okay, base implementation done based on those three primitives.
633 :
634 : FIELD_SEQ_BEGIN, FIELD_SEQ_END
635 :
636 : Used from slideshow for URLs, created from diverse SvxField implementations inside
637 : createBeginComment()/createEndComment(). createBeginComment() is used from editeng\impedit3.cxx
638 : inside ImpEditEngine::Paint.
639 : Created TextHierarchyFieldPrimitive2D and added needed infos there; it is an group primitive and wraps
640 : text primitives (but is not limited to that). It contains the field type if special actions for the
641 : support of FIELD_SEQ_BEGIN/END are needed; this is the case for Page and URL fields. If more is
642 : needed, it may be supported there.
643 : FIELD_SEQ_BEGIN;PageField
644 : FIELD_SEQ_END
645 : Okay, these are now completely supported by TextHierarchyFieldPrimitive2D. URL works, too.
646 :
647 : XTEXT
648 :
649 : XTEXT_EOC(i) end of character
650 : XTEXT_EOW(i) end of word
651 : XTEXT_EOS(i) end of sentence
652 :
653 : this three are with index and are created with the help of a i18n::XBreakIterator in
654 : ImplDrawWithComments. Simplifying, moving out text painting, reworking to create some
655 : data structure for holding those TEXT infos.
656 : Supported directly by TextSimplePortionPrimitive2D with adding a Locale to the basic text
657 : primitive. In the MetaFileRenderer, the creation is now done (see below). This has the advantage
658 : that this creations do not need to be done for all paints all the time. This would be
659 : expensive since the BreakIterator and it's usage is expensive and for each paint also the
660 : whole character stops would need to be created.
661 : Created only for TextDecoratedPortionPrimitive2D due to XTEXT_EOL and XTEXT_EOP (see below)
662 :
663 : XTEXT_EOL() end of line
664 : XTEXT_EOP() end of paragraph
665 :
666 : First try with boolean marks at TextDecoratedPortionPrimitive2D did not work too well,
667 : i decided to solve it with structure. I added the TextHierarchyPrimitives for this,
668 : namely:
669 : - TextHierarchyLinePrimitive2D: Encapsulates single line
670 : - TextHierarchyParagraphPrimitive2D: Encapsulates single paragraph
671 : - TextHierarchyBlockPrimitive2D: encapsulates object texts (only one ATM)
672 : Those are now supported in hierarchy. This means the MetaFile renderer will support them
673 : by using them, reculrively using their content and adding MetaFile comments as needed.
674 : This also means that when another text layouter will be used it will be necessary to
675 : create/support the same HierarchyPrimitives to support users.
676 : To transport the information using this hierarchy is best suited to all future needs;
677 : the slideshow will be able to profit from it directly when using primitives; all other
678 : renderers not interested in the text structure will just ignore the encapsulations.
679 :
680 : XTEXT_PAINTSHAPE_BEGIN, XTEXT_PAINTSHAPE_END
681 : Supported now by the TextHierarchyBlockPrimitive2D.
682 :
683 : EPSReplacementGraphic:
684 : Only used in goodies\source\filter.vcl\ieps\ieps.cxx and svx\source\xml\xmlgrhlp.cxx to
685 : hold the original EPS which was imported in the same MetaFile as first 2 entries. Only
686 : used to export the original again (if exists).
687 : Not necessary to support with MetaFuleRenderer.
688 :
689 : XTEXT_SCROLLRECT, XTEXT_PAINTRECT
690 : Currently used to get extra MetaFile infos using GraphicExporter which again uses
691 : SdrTextObj::GetTextScrollMetaFileAndRectangle(). ATM works with primitives since
692 : the rectangle data is added directly by the GraphicsExporter as comment. Does not need
693 : to be adapted at once.
694 : When adapting later, the only user - the diashow - should directly use the provided
695 : Anination infos in the appropriate primitives (e.g. AnimatedSwitchPrimitive2D)
696 :
697 : PRNSPOOL_TRANSPARENTBITMAP_BEGIN, PRNSPOOL_TRANSPARENTBITMAP_END
698 : VCL usage when printing PL -> THB. Okay, THB confirms that it is only used as
699 : a fix (hack) while VCL printing. It is needed to not downscale a bitmap which
700 : was explicitly created for the printer already again to some default maximum
701 : bitmap sizes.
702 : Nothing to do here for the primitive renderer.
703 :
704 : Support for vcl::PDFExtOutDevData:
705 : PL knows that SJ did that stuff, it's used to hold a pointer to PDFExtOutDevData at
706 : the OutDev. When set, some extra data is written there. Trying simple PDF export and
707 : watching if i get those infos.
708 : Well, a PDF export does not use e.g. ImpEditEngine::Paint since the PdfFilter uses
709 : the SdXImpressDocument::render and thus uses the VclMetafileProcessor2D. I will check
710 : if i get a PDFExtOutDevData at the target output device.
711 : Indeed, i get one. Checking what all may be done when that extra-device-info is there.
712 :
713 : All in all i have to talk to SJ. I will need to emulate some of those actions, but
714 : i need to discuss which ones.
715 : In the future, all those infos would be taken from the primitive sequence anyways,
716 : thus these extensions would potentially be temporary, too.
717 : Discussed with SJ, added the necessary support and tested it. Details follow.
718 :
719 : - In ImpEditEngine::Paint, paragraph infos and URL stuff is added.
720 : Added in primitive MetaFile renderer.
721 : Checking URL: Indeed, current version exports it, but it is missing in primitive
722 : CWS version. Adding support.
723 : Okay, URLs work. Checked, Done.
724 :
725 : - UnoControlPDFExportContact is only created when PDFExtOutDevData is used at the
726 : target and uno control data is created in UnoControlPDFExportContact::do_PaintObject.
727 : This may be added in primitive MetaFile renderer.
728 : Adding support...
729 : OOps, the necessary helper stuff is in svx/source/form/formpdxexport.cxx in namespace
730 : svxform. Have to talk to FS if this has to be like that. Especially since
731 : vcl::PDFWriter::AnyWidget is filled out, which is already part of vcl.
732 : Wrote an eMail to FS, he is on vacation currently. I see no reason why not to move
733 : that stuff to somewhere else, maybe tools or svtools ?!? We will see...
734 : Moved to toolkit, so i have to link against it. I tried VCL first, but it did
735 : not work since VCLUnoHelper::CreateFont is unresolved in VCL (!). Other then the name
736 : may imply, it is defined in toolkit (!). Since toolkit is linked against VCL itself,
737 : the lowest move,ment plave is toolkit.
738 : Checked form control export, it works well. Done.
739 :
740 : - In goodies, in GraphicObject::Draw, when the used Graphic is linked, infos are
741 : generated. I will need to check what happens here with primitives.
742 : To support, use of GraphicPrimitive2D (PRIMITIVE2D_ID_GRAPHICPRIMITIVE2D) may be needed.
743 : Added support, but feature is broken in main version, so i cannot test at all.
744 : Writing a bug to CL (or SJ) and seeing what happens (#i80380#).
745 : SJ took a look and we got it working. Tested VCL MetaFile Renderer based export,
746 : as intended, the original file is exported. Works, Done.
747 :
748 :
749 :
750 :
751 : To be done:
752 :
753 : - Maybe there are more places to take care of for vcl::PDFExtOutDevData!
754 :
755 :
756 :
757 : ****************************************************************************************************/
758 :
759 15967 : void VclMetafileProcessor2D::processBasePrimitive2D(const primitive2d::BasePrimitive2D& rCandidate)
760 : {
761 15967 : switch(rCandidate.getPrimitive2DID())
762 : {
763 : case PRIMITIVE2D_ID_WRONGSPELLPRIMITIVE2D :
764 : {
765 : // directdraw of wrong spell primitive
766 : // Ignore for VclMetafileProcessor2D, this is for printing and MetaFile recording only
767 0 : break;
768 : }
769 : case PRIMITIVE2D_ID_GRAPHICPRIMITIVE2D :
770 : {
771 151 : const primitive2d::GraphicPrimitive2D& rGraphicPrimitive = static_cast< const primitive2d::GraphicPrimitive2D& >(rCandidate);
772 151 : bool bUsingPDFExtOutDevData(false);
773 302 : basegfx::B2DVector aTranslate, aScale;
774 : static bool bSuppressPDFExtOutDevDataSupport(false);
775 :
776 151 : if(mpPDFExtOutDevData && !bSuppressPDFExtOutDevDataSupport)
777 : {
778 : // emulate data handling from UnoControlPDFExportContact, original see
779 : // svtools/source/graphic/grfmgr.cxx
780 0 : const Graphic& rGraphic = rGraphicPrimitive.getGraphicObject().GetGraphic();
781 :
782 0 : if(rGraphic.IsLink())
783 : {
784 0 : const GraphicAttr& rAttr = rGraphicPrimitive.getGraphicAttr();
785 :
786 0 : if(!rAttr.IsSpecialDrawMode() && !rAttr.IsAdjusted())
787 : {
788 0 : const basegfx::B2DHomMatrix& rTransform = rGraphicPrimitive.getTransform();
789 : double fRotate, fShearX;
790 0 : rTransform.decompose(aScale, aTranslate, fRotate, fShearX);
791 :
792 0 : if( basegfx::fTools::equalZero( fRotate ) && ( aScale.getX() > 0.0 ) && ( aScale.getY() > 0.0 ) )
793 : {
794 0 : bUsingPDFExtOutDevData = true;
795 0 : mpPDFExtOutDevData->BeginGroup();
796 : }
797 : }
798 : }
799 : }
800 :
801 : // process recursively and add MetaFile comment
802 151 : process(rGraphicPrimitive.get2DDecomposition(getViewInformation2D()));
803 :
804 151 : if(bUsingPDFExtOutDevData)
805 : {
806 : // emulate data handling from UnoControlPDFExportContact, original see
807 : // svtools/source/graphic/grfmgr.cxx
808 : const basegfx::B2DRange aCurrentRange(
809 : aTranslate.getX(), aTranslate.getY(),
810 0 : aTranslate.getX() + aScale.getX(), aTranslate.getY() + aScale.getY());
811 : const Rectangle aCurrentRect(
812 0 : sal_Int32(floor(aCurrentRange.getMinX())), sal_Int32(floor(aCurrentRange.getMinY())),
813 0 : sal_Int32(ceil(aCurrentRange.getMaxX())), sal_Int32(ceil(aCurrentRange.getMaxY())));
814 0 : const GraphicAttr& rAttr = rGraphicPrimitive.getGraphicAttr();
815 : // fdo#72530 don't pass empty Rectangle to EndGroup
816 0 : Rectangle aCropRect(aCurrentRect);
817 :
818 0 : if(rAttr.IsCropped())
819 : {
820 : // calculate scalings between real image size and logic object size. This
821 : // is necessary since the crop values are relative to original bitmap size
822 0 : double fFactorX(1.0);
823 0 : double fFactorY(1.0);
824 :
825 : {
826 0 : const MapMode aMapMode100thmm(MAP_100TH_MM);
827 : const Size aBitmapSize(OutputDevice::LogicToLogic(
828 0 : rGraphicPrimitive.getGraphicObject().GetPrefSize(),
829 0 : rGraphicPrimitive.getGraphicObject().GetPrefMapMode(), aMapMode100thmm));
830 0 : const double fDivX(aBitmapSize.Width() - rAttr.GetLeftCrop() - rAttr.GetRightCrop());
831 0 : const double fDivY(aBitmapSize.Height() - rAttr.GetTopCrop() - rAttr.GetBottomCrop());
832 :
833 0 : if(!basegfx::fTools::equalZero(fDivX))
834 : {
835 0 : fFactorX = aScale.getX() / fDivX;
836 : }
837 :
838 0 : if(!basegfx::fTools::equalZero(fDivY))
839 : {
840 0 : fFactorY = aScale.getY() / fDivY;
841 0 : }
842 : }
843 :
844 : // calculate crop range and rect
845 0 : basegfx::B2DRange aCropRange;
846 0 : aCropRange.expand(aCurrentRange.getMinimum() - basegfx::B2DPoint(rAttr.GetLeftCrop() * fFactorX, rAttr.GetTopCrop() * fFactorY));
847 0 : aCropRange.expand(aCurrentRange.getMaximum() + basegfx::B2DPoint(rAttr.GetRightCrop() * fFactorX, rAttr.GetBottomCrop() * fFactorY));
848 :
849 : aCropRect = Rectangle(
850 0 : sal_Int32(floor(aCropRange.getMinX())), sal_Int32(floor(aCropRange.getMinY())),
851 0 : sal_Int32(ceil(aCropRange.getMaxX())), sal_Int32(ceil(aCropRange.getMaxY())));
852 : }
853 :
854 : // #i123295# 3rd param is uncropped rect, 4th is cropped. The primitive has the cropped
855 : // object transformation, thus aCurrentRect *is* the clip region while aCropRect is the expanded,
856 : // uncropped region. Thus, correct order is aCropRect, aCurrentRect
857 0 : mpPDFExtOutDevData->EndGroup(rGraphicPrimitive.getGraphicObject().GetGraphic(),
858 0 : rAttr.GetTransparency(),
859 : aCropRect,
860 0 : aCurrentRect);
861 : }
862 :
863 302 : break;
864 : }
865 : case PRIMITIVE2D_ID_CONTROLPRIMITIVE2D :
866 : {
867 1 : const primitive2d::ControlPrimitive2D& rControlPrimitive = static_cast< const primitive2d::ControlPrimitive2D& >(rCandidate);
868 1 : const uno::Reference< awt::XControl >& rXControl(rControlPrimitive.getXControl());
869 1 : bool bIsPrintableControl(false);
870 :
871 : // find out if control is printable
872 1 : if(rXControl.is())
873 : {
874 : try
875 : {
876 1 : uno::Reference< beans::XPropertySet > xModelProperties(rXControl->getModel(), uno::UNO_QUERY);
877 1 : uno::Reference< beans::XPropertySetInfo > xPropertyInfo(xModelProperties.is()
878 1 : ? xModelProperties->getPropertySetInfo()
879 3 : : uno::Reference< beans::XPropertySetInfo >());
880 2 : const OUString sPrintablePropertyName("Printable");
881 :
882 1 : if(xPropertyInfo.is() && xPropertyInfo->hasPropertyByName(sPrintablePropertyName))
883 : {
884 1 : OSL_VERIFY(xModelProperties->getPropertyValue(sPrintablePropertyName) >>= bIsPrintableControl);
885 1 : }
886 : }
887 0 : catch(const uno::Exception&)
888 : {
889 : OSL_FAIL("VclMetafileProcessor2D: No access to printable flag of Control, caught an exception!");
890 : }
891 : }
892 :
893 : // PDF export and printing only for printable controls
894 1 : if(bIsPrintableControl)
895 : {
896 1 : const bool bPDFExport(mpPDFExtOutDevData && mpPDFExtOutDevData->GetIsExportFormFields());
897 1 : bool bDoProcessRecursively(true);
898 :
899 1 : if(bPDFExport)
900 : {
901 : // PDF export. Emulate data handling from UnoControlPDFExportContact
902 : // I have now moved describePDFControl to toolkit, thus i can implement the PDF
903 : // form control support now as follows
904 : ::std::unique_ptr< vcl::PDFWriter::AnyWidget > pPDFControl(
905 0 : ::toolkitform::describePDFControl( rXControl, *mpPDFExtOutDevData ) );
906 :
907 0 : if(pPDFControl.get())
908 : {
909 : // still need to fill in the location (is a class Rectangle)
910 0 : const basegfx::B2DRange aRangeLogic(rControlPrimitive.getB2DRange(getViewInformation2D()));
911 : const Rectangle aRectLogic(
912 0 : (sal_Int32)floor(aRangeLogic.getMinX()), (sal_Int32)floor(aRangeLogic.getMinY()),
913 0 : (sal_Int32)ceil(aRangeLogic.getMaxX()), (sal_Int32)ceil(aRangeLogic.getMaxY()));
914 0 : pPDFControl->Location = aRectLogic;
915 :
916 0 : Size aFontSize(pPDFControl->TextFont.GetSize());
917 0 : aFontSize = OutputDevice::LogicToLogic(aFontSize, MapMode(MAP_POINT), mpOutputDevice->GetMapMode());
918 0 : pPDFControl->TextFont.SetSize(aFontSize);
919 :
920 0 : mpPDFExtOutDevData->BeginStructureElement(vcl::PDFWriter::Form);
921 0 : mpPDFExtOutDevData->CreateControl(*pPDFControl.get());
922 0 : mpPDFExtOutDevData->EndStructureElement();
923 :
924 : // no normal paint needed (see original UnoControlPDFExportContact::do_PaintObject);
925 : // do not process recursively
926 0 : bDoProcessRecursively = false;
927 : }
928 : else
929 : {
930 : // PDF export did not work, try simple output.
931 : // Fallback to printer output by not setting bDoProcessRecursively
932 : // to false.
933 0 : }
934 : }
935 :
936 : // #i93169# used flag the wrong way; true means that nothing was done yet
937 1 : if(bDoProcessRecursively)
938 : {
939 : // printer output
940 : try
941 : {
942 : // remember old graphics and create new
943 1 : uno::Reference< awt::XView > xControlView(rXControl, uno::UNO_QUERY_THROW);
944 2 : const uno::Reference< awt::XGraphics > xOriginalGraphics(xControlView->getGraphics());
945 2 : const uno::Reference< awt::XGraphics > xNewGraphics(mpOutputDevice->CreateUnoGraphics());
946 :
947 1 : if(xNewGraphics.is())
948 : {
949 : // link graphics and view
950 1 : xControlView->setGraphics(xNewGraphics);
951 :
952 : // get position
953 1 : const basegfx::B2DHomMatrix aObjectToDiscrete(getViewInformation2D().getObjectToViewTransformation() * rControlPrimitive.getTransform());
954 2 : const basegfx::B2DPoint aTopLeftDiscrete(aObjectToDiscrete * basegfx::B2DPoint(0.0, 0.0));
955 :
956 : // draw it
957 1 : xControlView->draw(basegfx::fround(aTopLeftDiscrete.getX()), basegfx::fround(aTopLeftDiscrete.getY()));
958 1 : bDoProcessRecursively = false;
959 :
960 : // restore original graphics
961 2 : xControlView->setGraphics(xOriginalGraphics);
962 1 : }
963 : }
964 0 : catch( const uno::Exception& )
965 : {
966 : OSL_FAIL("VclMetafileProcessor2D: Printing of Control failed, caught an exception!");
967 : }
968 : }
969 :
970 : // process recursively if not done yet to export as decomposition (bitmap)
971 1 : if(bDoProcessRecursively)
972 : {
973 0 : process(rControlPrimitive.get2DDecomposition(getViewInformation2D()));
974 : }
975 : }
976 :
977 1 : break;
978 : }
979 : case PRIMITIVE2D_ID_TEXTHIERARCHYFIELDPRIMITIVE2D :
980 : {
981 : // support for FIELD_SEQ_BEGIN, FIELD_SEQ_END and URL. It wraps text primitives (but is not limited to)
982 : // thus do the MetafileAction embedding stuff but just handle recursively.
983 8 : const primitive2d::TextHierarchyFieldPrimitive2D& rFieldPrimitive = static_cast< const primitive2d::TextHierarchyFieldPrimitive2D& >(rCandidate);
984 8 : const OString aCommentStringCommon("FIELD_SEQ_BEGIN");
985 16 : const OString aCommentStringPage("FIELD_SEQ_BEGIN;PageField");
986 16 : const OString aCommentStringEnd("FIELD_SEQ_END");
987 :
988 8 : switch(rFieldPrimitive.getType())
989 : {
990 : default : // case drawinglayer::primitive2d::FIELD_TYPE_COMMON :
991 : {
992 8 : mpMetaFile->AddAction(new MetaCommentAction(aCommentStringCommon));
993 8 : break;
994 : }
995 : case drawinglayer::primitive2d::FIELD_TYPE_PAGE :
996 : {
997 0 : mpMetaFile->AddAction(new MetaCommentAction(aCommentStringPage));
998 0 : break;
999 : }
1000 : case drawinglayer::primitive2d::FIELD_TYPE_URL :
1001 : {
1002 0 : const OUString& rURL = rFieldPrimitive.getString();
1003 0 : const OUString aOldString(rURL);
1004 0 : mpMetaFile->AddAction(new MetaCommentAction(aCommentStringCommon, 0, reinterpret_cast< const sal_uInt8* >(aOldString.getStr()), 2 * aOldString.getLength()));
1005 0 : break;
1006 : }
1007 : }
1008 :
1009 : // process recursively
1010 8 : const primitive2d::Primitive2DSequence rContent = rFieldPrimitive.get2DDecomposition(getViewInformation2D());
1011 8 : process(rContent);
1012 :
1013 : // for the end comment the type is not relevant yet, they are all the same. Just add.
1014 8 : mpMetaFile->AddAction(new MetaCommentAction(aCommentStringEnd));
1015 :
1016 8 : if(mpPDFExtOutDevData && drawinglayer::primitive2d::FIELD_TYPE_URL == rFieldPrimitive.getType())
1017 : {
1018 : // emulate data handling from ImpEditEngine::Paint
1019 0 : const basegfx::B2DRange aViewRange(primitive2d::getB2DRangeFromPrimitive2DSequence(rContent, getViewInformation2D()));
1020 : const Rectangle aRectLogic(
1021 0 : (sal_Int32)floor(aViewRange.getMinX()), (sal_Int32)floor(aViewRange.getMinY()),
1022 0 : (sal_Int32)ceil(aViewRange.getMaxX()), (sal_Int32)ceil(aViewRange.getMaxY()));
1023 0 : vcl::PDFExtOutDevBookmarkEntry aBookmark;
1024 0 : aBookmark.nLinkId = mpPDFExtOutDevData->CreateLink(aRectLogic);
1025 0 : aBookmark.aBookmark = rFieldPrimitive.getString();
1026 0 : std::vector< vcl::PDFExtOutDevBookmarkEntry >& rBookmarks = mpPDFExtOutDevData->GetBookmarks();
1027 0 : rBookmarks.push_back( aBookmark );
1028 : }
1029 :
1030 16 : break;
1031 : }
1032 : case PRIMITIVE2D_ID_TEXTHIERARCHYLINEPRIMITIVE2D :
1033 : {
1034 523 : const primitive2d::TextHierarchyLinePrimitive2D& rLinePrimitive = static_cast< const primitive2d::TextHierarchyLinePrimitive2D& >(rCandidate);
1035 523 : const OString aCommentString("XTEXT_EOL");
1036 :
1037 : // process recursively and add MetaFile comment
1038 523 : process(rLinePrimitive.get2DDecomposition(getViewInformation2D()));
1039 523 : mpMetaFile->AddAction(new MetaCommentAction(aCommentString));
1040 :
1041 523 : break;
1042 : }
1043 : case PRIMITIVE2D_ID_TEXTHIERARCHYBULLETPRIMITIVE2D :
1044 : {
1045 : // in Outliner::PaintBullet(), a MetafileComment for bullets is added, too. The
1046 : // "XTEXT_EOC" is used, use here, too.
1047 18 : const primitive2d::TextHierarchyBulletPrimitive2D& rBulletPrimitive = static_cast< const primitive2d::TextHierarchyBulletPrimitive2D& >(rCandidate);
1048 18 : const OString aCommentString("XTEXT_EOC");
1049 :
1050 : // process recursively and add MetaFile comment
1051 18 : process(rBulletPrimitive.get2DDecomposition(getViewInformation2D()));
1052 18 : mpMetaFile->AddAction(new MetaCommentAction(aCommentString));
1053 :
1054 18 : break;
1055 : }
1056 : case PRIMITIVE2D_ID_TEXTHIERARCHYPARAGRAPHPRIMITIVE2D :
1057 : {
1058 493 : const primitive2d::TextHierarchyParagraphPrimitive2D& rParagraphPrimitive = static_cast< const primitive2d::TextHierarchyParagraphPrimitive2D& >(rCandidate);
1059 493 : const OString aCommentString("XTEXT_EOP");
1060 :
1061 493 : if(mpPDFExtOutDevData)
1062 : {
1063 : // emulate data handling from ImpEditEngine::Paint
1064 0 : mpPDFExtOutDevData->BeginStructureElement( vcl::PDFWriter::Paragraph );
1065 : }
1066 :
1067 : // process recursively and add MetaFile comment
1068 493 : process(rParagraphPrimitive.get2DDecomposition(getViewInformation2D()));
1069 493 : mpMetaFile->AddAction(new MetaCommentAction(aCommentString));
1070 :
1071 493 : if(mpPDFExtOutDevData)
1072 : {
1073 : // emulate data handling from ImpEditEngine::Paint
1074 0 : mpPDFExtOutDevData->EndStructureElement();
1075 : }
1076 :
1077 493 : break;
1078 : }
1079 : case PRIMITIVE2D_ID_TEXTHIERARCHYBLOCKPRIMITIVE2D :
1080 : {
1081 466 : const primitive2d::TextHierarchyBlockPrimitive2D& rBlockPrimitive = static_cast< const primitive2d::TextHierarchyBlockPrimitive2D& >(rCandidate);
1082 466 : const OString aCommentStringA("XTEXT_PAINTSHAPE_BEGIN");
1083 932 : const OString aCommentStringB("XTEXT_PAINTSHAPE_END");
1084 :
1085 : // add MetaFile comment, process recursively and add MetaFile comment
1086 466 : mpMetaFile->AddAction(new MetaCommentAction(aCommentStringA));
1087 466 : process(rBlockPrimitive.get2DDecomposition(getViewInformation2D()));
1088 466 : mpMetaFile->AddAction(new MetaCommentAction(aCommentStringB));
1089 :
1090 932 : break;
1091 : }
1092 : case PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D :
1093 : case PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D :
1094 : {
1095 : // for supporting TEXT_ MetaFile actions there is more to do here; get the candidate
1096 641 : const primitive2d::TextSimplePortionPrimitive2D& rTextCandidate = static_cast< const primitive2d::TextSimplePortionPrimitive2D& >(rCandidate);
1097 : // const primitive2d::TextDecoratedPortionPrimitive2D* pTextDecoratedCandidate = dynamic_cast< const primitive2d::TextDecoratedPortionPrimitive2D* >(&rCandidate);
1098 :
1099 : // Adapt evtl. used special DrawMode
1100 641 : const DrawModeFlags nOriginalDrawMode(mpOutputDevice->GetDrawMode());
1101 641 : adaptTextToFillDrawMode();
1102 :
1103 : // directdraw of text simple portion; use default processing
1104 641 : RenderTextSimpleOrDecoratedPortionPrimitive2D(rTextCandidate);
1105 :
1106 : // restore DrawMode
1107 641 : mpOutputDevice->SetDrawMode(nOriginalDrawMode);
1108 :
1109 : // #i101169# if(pTextDecoratedCandidate)
1110 : {
1111 : // support for TEXT_ MetaFile actions only for decorated texts
1112 641 : if(!mxBreakIterator.is())
1113 : {
1114 12 : uno::Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
1115 12 : mxBreakIterator = i18n::BreakIterator::create(xContext);
1116 : }
1117 :
1118 641 : const OUString& rTxt = rTextCandidate.getText();
1119 641 : const sal_Int32 nTextLength(rTextCandidate.getTextLength()); // rTxt.getLength());
1120 :
1121 641 : if(nTextLength)
1122 : {
1123 641 : const ::com::sun::star::lang::Locale& rLocale = rTextCandidate.getLocale();
1124 641 : const sal_Int32 nTextPosition(rTextCandidate.getTextPosition());
1125 :
1126 : sal_Int32 nDone;
1127 641 : sal_Int32 nNextCellBreak(mxBreakIterator->nextCharacters(rTxt, nTextPosition, rLocale, ::com::sun::star::i18n::CharacterIteratorMode::SKIPCELL, 0, nDone));
1128 641 : ::com::sun::star::i18n::Boundary nNextWordBoundary(mxBreakIterator->getWordBoundary(rTxt, nTextPosition, rLocale, ::com::sun::star::i18n::WordType::ANY_WORD, sal_True));
1129 641 : sal_Int32 nNextSentenceBreak(mxBreakIterator->endOfSentence(rTxt, nTextPosition, rLocale));
1130 641 : const OString aCommentStringA("XTEXT_EOC");
1131 1282 : const OString aCommentStringB("XTEXT_EOW");
1132 1282 : const OString aCommentStringC("XTEXT_EOS");
1133 :
1134 5746 : for(sal_Int32 i(nTextPosition); i < nTextPosition + nTextLength; i++)
1135 : {
1136 : // create the entries for the respective break positions
1137 5105 : if(i == nNextCellBreak)
1138 : {
1139 5105 : mpMetaFile->AddAction(new MetaCommentAction(aCommentStringA, i - nTextPosition));
1140 5105 : nNextCellBreak = mxBreakIterator->nextCharacters(rTxt, i, rLocale, ::com::sun::star::i18n::CharacterIteratorMode::SKIPCELL, 1, nDone);
1141 : }
1142 5105 : if(i == nNextWordBoundary.endPos)
1143 : {
1144 556 : mpMetaFile->AddAction(new MetaCommentAction(aCommentStringB, i - nTextPosition));
1145 556 : nNextWordBoundary = mxBreakIterator->getWordBoundary(rTxt, i + 1, rLocale, ::com::sun::star::i18n::WordType::ANY_WORD, sal_True);
1146 : }
1147 5105 : if(i == nNextSentenceBreak)
1148 : {
1149 40 : mpMetaFile->AddAction(new MetaCommentAction(aCommentStringC, i - nTextPosition));
1150 40 : nNextSentenceBreak = mxBreakIterator->endOfSentence(rTxt, i + 1, rLocale);
1151 : }
1152 641 : }
1153 : }
1154 : }
1155 :
1156 641 : break;
1157 : }
1158 : case PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D :
1159 : {
1160 3420 : const primitive2d::PolygonHairlinePrimitive2D& rHairlinePrimitive = static_cast< const primitive2d::PolygonHairlinePrimitive2D& >(rCandidate);
1161 3420 : const basegfx::B2DPolygon& rBasePolygon = rHairlinePrimitive.getB2DPolygon();
1162 :
1163 3420 : if(rBasePolygon.count() > (MAX_POLYGON_POINT_COUNT_METAFILE - 1))
1164 : {
1165 : // #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
1166 : // per polygon. If there are more, split the polygon in half and call recursively
1167 0 : basegfx::B2DPolygon aLeft, aRight;
1168 0 : splitLinePolygon(rBasePolygon, aLeft, aRight);
1169 0 : const primitive2d::PolygonHairlinePrimitive2D aPLeft(aLeft, rHairlinePrimitive.getBColor());
1170 0 : const primitive2d::PolygonHairlinePrimitive2D aPRight(aRight, rHairlinePrimitive.getBColor());
1171 :
1172 0 : processBasePrimitive2D(aPLeft);
1173 0 : processBasePrimitive2D(aPRight);
1174 : }
1175 : else
1176 : {
1177 : // direct draw of hairline; use default processing
1178 : // support SvtGraphicStroke MetaCommentAction
1179 3420 : const basegfx::BColor aLineColor(maBColorModifierStack.getModifiedColor(rHairlinePrimitive.getBColor()));
1180 3420 : SvtGraphicStroke* pSvtGraphicStroke = 0;
1181 :
1182 : // #i121267# Not needed, does not give better quality compared with
1183 : // the MetaActionType::POLYPOLYGON written by RenderPolygonHairlinePrimitive2D
1184 : // below
1185 3420 : bool bSupportSvtGraphicStroke(false);
1186 :
1187 3420 : if(bSupportSvtGraphicStroke)
1188 : {
1189 : pSvtGraphicStroke = impTryToCreateSvtGraphicStroke(
1190 0 : rHairlinePrimitive.getB2DPolygon(),
1191 : &aLineColor,
1192 0 : 0, 0, 0, 0);
1193 :
1194 0 : impStartSvtGraphicStroke(pSvtGraphicStroke);
1195 : }
1196 :
1197 3420 : RenderPolygonHairlinePrimitive2D(static_cast< const primitive2d::PolygonHairlinePrimitive2D& >(rCandidate), false);
1198 :
1199 3420 : if(bSupportSvtGraphicStroke)
1200 : {
1201 0 : impEndSvtGraphicStroke(pSvtGraphicStroke);
1202 3420 : }
1203 : }
1204 3420 : break;
1205 : }
1206 : case PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D :
1207 : {
1208 1981 : const primitive2d::PolygonStrokePrimitive2D& rStrokePrimitive = static_cast< const primitive2d::PolygonStrokePrimitive2D& >(rCandidate);
1209 1981 : const basegfx::B2DPolygon& rBasePolygon = rStrokePrimitive.getB2DPolygon();
1210 :
1211 1981 : if(rBasePolygon.count() > (MAX_POLYGON_POINT_COUNT_METAFILE - 1))
1212 : {
1213 : // #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
1214 : // per polygon. If there are more, split the polygon in half and call recursively
1215 0 : basegfx::B2DPolygon aLeft, aRight;
1216 0 : splitLinePolygon(rBasePolygon, aLeft, aRight);
1217 : const primitive2d::PolygonStrokePrimitive2D aPLeft(
1218 0 : aLeft, rStrokePrimitive.getLineAttribute(), rStrokePrimitive.getStrokeAttribute());
1219 : const primitive2d::PolygonStrokePrimitive2D aPRight(
1220 0 : aRight, rStrokePrimitive.getLineAttribute(), rStrokePrimitive.getStrokeAttribute());
1221 :
1222 0 : processBasePrimitive2D(aPLeft);
1223 0 : processBasePrimitive2D(aPRight);
1224 : }
1225 : else
1226 : {
1227 : // support SvtGraphicStroke MetaCommentAction
1228 : SvtGraphicStroke* pSvtGraphicStroke = impTryToCreateSvtGraphicStroke(
1229 : rBasePolygon, 0,
1230 1981 : &rStrokePrimitive.getLineAttribute(),
1231 1981 : &rStrokePrimitive.getStrokeAttribute(),
1232 1981 : 0, 0);
1233 :
1234 1981 : impStartSvtGraphicStroke(pSvtGraphicStroke);
1235 1981 : const attribute::LineAttribute& rLine = rStrokePrimitive.getLineAttribute();
1236 :
1237 : // create MetaPolyLineActions, but without LINE_DASH
1238 1981 : if(basegfx::fTools::more(rLine.getWidth(), 0.0))
1239 : {
1240 595 : const attribute::StrokeAttribute& rStroke = rStrokePrimitive.getStrokeAttribute();
1241 595 : basegfx::B2DPolyPolygon aHairLinePolyPolygon;
1242 :
1243 595 : if(0.0 == rStroke.getFullDotDashLen())
1244 : {
1245 595 : aHairLinePolyPolygon.append(rBasePolygon);
1246 : }
1247 : else
1248 : {
1249 : basegfx::tools::applyLineDashing(
1250 0 : rBasePolygon, rStroke.getDotDashArray(),
1251 0 : &aHairLinePolyPolygon, 0, rStroke.getFullDotDashLen());
1252 : }
1253 :
1254 1190 : const basegfx::BColor aHairlineColor(maBColorModifierStack.getModifiedColor(rLine.getColor()));
1255 595 : mpOutputDevice->SetLineColor(Color(aHairlineColor));
1256 595 : mpOutputDevice->SetFillColor();
1257 595 : aHairLinePolyPolygon.transform(maCurrentTransformation);
1258 :
1259 : // use the transformed line width
1260 1190 : LineInfo aLineInfo(LINE_SOLID, basegfx::fround(getTransformedLineWidth(rLine.getWidth())));
1261 595 : aLineInfo.SetLineJoin(rLine.getLineJoin());
1262 595 : aLineInfo.SetLineCap(rLine.getLineCap());
1263 :
1264 1190 : for(sal_uInt32 a(0); a < aHairLinePolyPolygon.count(); a++)
1265 : {
1266 595 : const basegfx::B2DPolygon aCandidate(aHairLinePolyPolygon.getB2DPolygon(a));
1267 :
1268 595 : if(aCandidate.count() > 1)
1269 : {
1270 343 : const Polygon aToolsPolygon(aCandidate);
1271 :
1272 343 : mpMetaFile->AddAction(new MetaPolyLineAction(aToolsPolygon, aLineInfo));
1273 : }
1274 1190 : }
1275 : }
1276 : else
1277 : {
1278 1386 : process(rCandidate.get2DDecomposition(getViewInformation2D()));
1279 : }
1280 :
1281 1981 : impEndSvtGraphicStroke(pSvtGraphicStroke);
1282 : }
1283 :
1284 1981 : break;
1285 : }
1286 : case PRIMITIVE2D_ID_POLYGONSTROKEARROWPRIMITIVE2D :
1287 : {
1288 56 : const primitive2d::PolygonStrokeArrowPrimitive2D& rStrokeArrowPrimitive = static_cast< const primitive2d::PolygonStrokeArrowPrimitive2D& >(rCandidate);
1289 56 : const basegfx::B2DPolygon& rBasePolygon = rStrokeArrowPrimitive.getB2DPolygon();
1290 :
1291 56 : if(rBasePolygon.count() > (MAX_POLYGON_POINT_COUNT_METAFILE - 1))
1292 : {
1293 : // #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
1294 : // per polygon. If there are more, split the polygon in half and call recursively
1295 0 : basegfx::B2DPolygon aLeft, aRight;
1296 0 : splitLinePolygon(rBasePolygon, aLeft, aRight);
1297 0 : const attribute::LineStartEndAttribute aEmpty;
1298 : const primitive2d::PolygonStrokeArrowPrimitive2D aPLeft(
1299 : aLeft,
1300 0 : rStrokeArrowPrimitive.getLineAttribute(),
1301 0 : rStrokeArrowPrimitive.getStrokeAttribute(),
1302 0 : rStrokeArrowPrimitive.getStart(),
1303 0 : aEmpty);
1304 : const primitive2d::PolygonStrokeArrowPrimitive2D aPRight(
1305 : aRight,
1306 0 : rStrokeArrowPrimitive.getLineAttribute(),
1307 0 : rStrokeArrowPrimitive.getStrokeAttribute(),
1308 : aEmpty,
1309 0 : rStrokeArrowPrimitive.getEnd());
1310 :
1311 0 : processBasePrimitive2D(aPLeft);
1312 0 : processBasePrimitive2D(aPRight);
1313 : }
1314 : else
1315 : {
1316 : // support SvtGraphicStroke MetaCommentAction
1317 : SvtGraphicStroke* pSvtGraphicStroke = impTryToCreateSvtGraphicStroke(
1318 : rBasePolygon, 0,
1319 56 : &rStrokeArrowPrimitive.getLineAttribute(),
1320 56 : &rStrokeArrowPrimitive.getStrokeAttribute(),
1321 56 : &rStrokeArrowPrimitive.getStart(),
1322 112 : &rStrokeArrowPrimitive.getEnd());
1323 :
1324 : // write LineGeometry start marker
1325 56 : impStartSvtGraphicStroke(pSvtGraphicStroke);
1326 :
1327 : // #i116162# When B&W is set as DrawMode, DrawModeFlags::WhiteFill is used
1328 : // to let all fills be just white; for lines DrawModeFlags::BlackLine is used
1329 : // so all line geometry is supposed to get black. Since in the in-between
1330 : // stages of line geometry drawing filled polygons are used (e.g. line
1331 : // start/ends) it is necessary to change these drawmodes to preserve
1332 : // that lines shall be black; thus change DrawModeFlags::WhiteFill to
1333 : // DrawModeFlags::BlackFill during line geometry processing to have line geometry
1334 : // parts filled black.
1335 56 : const DrawModeFlags nOldDrawMode(mpOutputDevice->GetDrawMode());
1336 56 : const bool bDrawmodeChange(nOldDrawMode & DrawModeFlags::WhiteFill && mnSvtGraphicStrokeCount);
1337 :
1338 56 : if(bDrawmodeChange)
1339 : {
1340 0 : mpOutputDevice->SetDrawMode((nOldDrawMode & ~DrawModeFlags::WhiteFill) | DrawModeFlags::BlackFill);
1341 : }
1342 :
1343 : // process sub-line geometry (evtl. filled PolyPolygons)
1344 56 : process(rCandidate.get2DDecomposition(getViewInformation2D()));
1345 :
1346 56 : if(bDrawmodeChange)
1347 : {
1348 0 : mpOutputDevice->SetDrawMode(nOldDrawMode);
1349 : }
1350 :
1351 : // write LineGeometry end marker
1352 56 : impEndSvtGraphicStroke(pSvtGraphicStroke);
1353 : }
1354 :
1355 56 : break;
1356 : }
1357 : case PRIMITIVE2D_ID_BITMAPPRIMITIVE2D :
1358 : {
1359 : // direct draw of transformed BitmapEx primitive; use default processing, but without
1360 : // former testing if graphic content is inside discrete local viewport; this is not
1361 : // setup for metafile targets (metafile renderer tries to render in logic coordinates,
1362 : // the mapping is kept to the OutputDevice for better Metafile recording)
1363 474 : RenderBitmapPrimitive2D(static_cast< const primitive2d::BitmapPrimitive2D& >(rCandidate));
1364 474 : break;
1365 : }
1366 : case PRIMITIVE2D_ID_POLYPOLYGONGRAPHICPRIMITIVE2D :
1367 : {
1368 : // need to handle PolyPolygonGraphicPrimitive2D here to support XPATHFILL_SEQ_BEGIN/XPATHFILL_SEQ_END
1369 43 : const primitive2d::PolyPolygonGraphicPrimitive2D& rBitmapCandidate = static_cast< const primitive2d::PolyPolygonGraphicPrimitive2D& >(rCandidate);
1370 43 : basegfx::B2DPolyPolygon aLocalPolyPolygon(rBitmapCandidate.getB2DPolyPolygon());
1371 :
1372 43 : if(fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon))
1373 : {
1374 : // #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
1375 : // per polygon. If there are more use the splitted polygon and call recursively
1376 : const primitive2d::PolyPolygonGraphicPrimitive2D aSplitted(
1377 : aLocalPolyPolygon,
1378 0 : rBitmapCandidate.getFillGraphic());
1379 :
1380 0 : processBasePrimitive2D(aSplitted);
1381 : }
1382 : else
1383 : {
1384 43 : SvtGraphicFill* pSvtGraphicFill = 0;
1385 :
1386 43 : if(!mnSvtGraphicFillCount && aLocalPolyPolygon.count())
1387 : {
1388 : // #121194# Changed implementation and checked usages fo convert to metafile,
1389 : // presentation start (uses SvtGraphicFill) and printing.
1390 :
1391 : // calculate transformation. Get real object size, all values in FillGraphicAttribute
1392 : // are relative to the unified object
1393 43 : aLocalPolyPolygon.transform(maCurrentTransformation);
1394 43 : const basegfx::B2DVector aOutlineSize(aLocalPolyPolygon.getB2DRange().getRange());
1395 :
1396 : // the scaling needs scale from pixel to logic coordinate system
1397 43 : const attribute::FillGraphicAttribute& rFillGraphicAttribute = rBitmapCandidate.getFillGraphic();
1398 43 : const Size aBmpSizePixel(rFillGraphicAttribute.getGraphic().GetSizePixel());
1399 :
1400 : // setup transformation like in impgrfll. Multiply with aOutlineSize
1401 : // to get from unit coordinates in rFillGraphicAttribute.getGraphicRange()
1402 : // to object coordinates with object's top left being at (0,0). Divide
1403 : // by pixel size so that scale from pixel to logic will work in SvtGraphicFill.
1404 : const basegfx::B2DVector aTransformScale(
1405 129 : rFillGraphicAttribute.getGraphicRange().getRange() /
1406 : basegfx::B2DVector(
1407 86 : std::max(1.0, double(aBmpSizePixel.Width())),
1408 172 : std::max(1.0, double(aBmpSizePixel.Height()))) *
1409 86 : aOutlineSize);
1410 : const basegfx::B2DPoint aTransformPosition(
1411 86 : rFillGraphicAttribute.getGraphicRange().getMinimum() * aOutlineSize);
1412 :
1413 : // setup transformation like in impgrfll
1414 43 : SvtGraphicFill::Transform aTransform;
1415 :
1416 : // scale values are divided by bitmap pixel sizes
1417 43 : aTransform.matrix[0] = aTransformScale.getX();
1418 43 : aTransform.matrix[4] = aTransformScale.getY();
1419 :
1420 : // translates are absolute
1421 43 : aTransform.matrix[2] = aTransformPosition.getX();
1422 43 : aTransform.matrix[5] = aTransformPosition.getY();
1423 :
1424 : pSvtGraphicFill = new SvtGraphicFill(
1425 : getFillPolyPolygon(aLocalPolyPolygon),
1426 : Color(),
1427 : 0.0,
1428 : SvtGraphicFill::fillEvenOdd,
1429 : SvtGraphicFill::fillTexture,
1430 : aTransform,
1431 43 : rFillGraphicAttribute.getTiling(),
1432 : SvtGraphicFill::hatchSingle,
1433 : Color(),
1434 : SvtGraphicFill::gradientLinear,
1435 : Color(),
1436 : Color(),
1437 : 0,
1438 129 : rFillGraphicAttribute.getGraphic());
1439 : }
1440 :
1441 : // Do use decomposition; encapsulate with SvtGraphicFill
1442 43 : impStartSvtGraphicFill(pSvtGraphicFill);
1443 43 : process(rCandidate.get2DDecomposition(getViewInformation2D()));
1444 43 : impEndSvtGraphicFill(pSvtGraphicFill);
1445 : }
1446 :
1447 43 : break;
1448 : }
1449 : case PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D :
1450 : {
1451 : // need to handle PolyPolygonHatchPrimitive2D here to support XPATHFILL_SEQ_BEGIN/XPATHFILL_SEQ_END
1452 7 : const primitive2d::PolyPolygonHatchPrimitive2D& rHatchCandidate = static_cast< const primitive2d::PolyPolygonHatchPrimitive2D& >(rCandidate);
1453 7 : const attribute::FillHatchAttribute& rFillHatchAttribute = rHatchCandidate.getFillHatch();
1454 7 : basegfx::B2DPolyPolygon aLocalPolyPolygon(rHatchCandidate.getB2DPolyPolygon());
1455 :
1456 7 : if(aLocalPolyPolygon.getB2DRange() != rHatchCandidate.getDefinitionRange())
1457 : {
1458 : // the range which defines the hatch is different from the range of the
1459 : // geometry (used for writer frames). This cannot be done calling vcl, thus use
1460 : // decomposition here
1461 6 : process(rCandidate.get2DDecomposition(getViewInformation2D()));
1462 6 : break;
1463 : }
1464 :
1465 : // #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
1466 : // per polygon. Split polygon until there are less than that
1467 1 : while(fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon))
1468 : ;
1469 :
1470 1 : if(rFillHatchAttribute.isFillBackground())
1471 : {
1472 : // with fixing #i111954# (see below) the possible background
1473 : // fill of a hatched object was lost.Generate a background fill
1474 : // primitive and render it
1475 : const primitive2d::Primitive2DReference xBackground(
1476 : new primitive2d::PolyPolygonColorPrimitive2D(
1477 : aLocalPolyPolygon,
1478 0 : rHatchCandidate.getBackgroundColor()));
1479 :
1480 0 : process(primitive2d::Primitive2DSequence(&xBackground, 1));
1481 : }
1482 :
1483 1 : SvtGraphicFill* pSvtGraphicFill = 0;
1484 1 : aLocalPolyPolygon.transform(maCurrentTransformation);
1485 :
1486 1 : if(!mnSvtGraphicFillCount && aLocalPolyPolygon.count())
1487 : {
1488 : // re-create a VCL hatch as base data
1489 1 : SvtGraphicFill::HatchType eHatch(SvtGraphicFill::hatchSingle);
1490 :
1491 1 : switch(rFillHatchAttribute.getStyle())
1492 : {
1493 : default: // attribute::HATCHSTYLE_SINGLE :
1494 : {
1495 1 : eHatch = SvtGraphicFill::hatchSingle;
1496 1 : break;
1497 : }
1498 : case attribute::HATCHSTYLE_DOUBLE :
1499 : {
1500 0 : eHatch = SvtGraphicFill::hatchDouble;
1501 0 : break;
1502 : }
1503 : case attribute::HATCHSTYLE_TRIPLE :
1504 : {
1505 0 : eHatch = SvtGraphicFill::hatchTriple;
1506 0 : break;
1507 : }
1508 : }
1509 :
1510 1 : SvtGraphicFill::Transform aTransform;
1511 :
1512 : // scale
1513 1 : aTransform.matrix[0] *= rFillHatchAttribute.getDistance();
1514 1 : aTransform.matrix[4] *= rFillHatchAttribute.getDistance();
1515 :
1516 : // rotate (was never correct in impgrfll anyways, use correct angle now)
1517 1 : aTransform.matrix[0] *= cos(rFillHatchAttribute.getAngle());
1518 1 : aTransform.matrix[1] *= -sin(rFillHatchAttribute.getAngle());
1519 1 : aTransform.matrix[3] *= sin(rFillHatchAttribute.getAngle());
1520 1 : aTransform.matrix[4] *= cos(rFillHatchAttribute.getAngle());
1521 :
1522 : pSvtGraphicFill = new SvtGraphicFill(
1523 : getFillPolyPolygon(aLocalPolyPolygon),
1524 : Color(),
1525 : 0.0,
1526 : SvtGraphicFill::fillEvenOdd,
1527 : SvtGraphicFill::fillHatch,
1528 : aTransform,
1529 : false,
1530 : eHatch,
1531 1 : Color(rFillHatchAttribute.getColor()),
1532 : SvtGraphicFill::gradientLinear,
1533 : Color(),
1534 : Color(),
1535 : 0,
1536 2 : Graphic());
1537 : }
1538 :
1539 : // Do use decomposition; encapsulate with SvtGraphicFill
1540 1 : impStartSvtGraphicFill(pSvtGraphicFill);
1541 :
1542 : // #i111954# do NOT use decomposition, but use direct VCL-command
1543 : // process(rCandidate.get2DDecomposition(getViewInformation2D()));
1544 1 : const tools::PolyPolygon aToolsPolyPolygon(basegfx::tools::adaptiveSubdivideByAngle(aLocalPolyPolygon));
1545 : const HatchStyle aHatchStyle(
1546 1 : attribute::HATCHSTYLE_SINGLE == rFillHatchAttribute.getStyle() ? HATCH_SINGLE :
1547 0 : attribute::HATCHSTYLE_DOUBLE == rFillHatchAttribute.getStyle() ? HATCH_DOUBLE :
1548 1 : HATCH_TRIPLE);
1549 :
1550 : mpOutputDevice->DrawHatch(aToolsPolyPolygon,
1551 : Hatch(aHatchStyle,
1552 1 : Color(rFillHatchAttribute.getColor()),
1553 1 : basegfx::fround(rFillHatchAttribute.getDistance()),
1554 3 : basegfx::fround(rFillHatchAttribute.getAngle() / F_PI1800)));
1555 :
1556 1 : impEndSvtGraphicFill(pSvtGraphicFill);
1557 :
1558 1 : break;
1559 : }
1560 : case PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D :
1561 : {
1562 18 : basegfx::B2DVector aScale, aTranslate;
1563 : double fRotate, fShearX;
1564 :
1565 9 : maCurrentTransformation.decompose(aScale, aTranslate, fRotate, fShearX);
1566 :
1567 9 : if(!basegfx::fTools::equalZero(fRotate) || !basegfx::fTools::equalZero(fShearX))
1568 : {
1569 : // #i121185# When rotation or shear is used, a VCL Gradient cannot be used directly.
1570 : // This is because VCL Gradient mechanism does *not* support to rotate the gradient
1571 : // with objects and this case is not expressable in a Metafile (and cannot be added
1572 : // since the FileFormats used, e.g. *.wmf, do not support it either).
1573 : // Such cases happen when a graphic object uses a Metafile as graphic information or
1574 : // a fill style definition uses a Metafile. In this cases the graphic content is
1575 : // rotated with the graphic or filled object; this is not supported by the target
1576 : // format of this conversion renderer - Metafiles.
1577 : // To solve this, not a Gradient is written, but the decomposition of this object
1578 : // is written to the Metafile. This is the PolyPolygons building the gradient fill.
1579 : // These will need more space and time, but the result will be as if the Gradient
1580 : // was rotated with the object.
1581 : // This mechanism is used by all exporters still not using Primtives (e.g. Print,
1582 : // Slideshow, Export rto PDF, export to Picture, ...) but relying on Metafile
1583 : // transfers. One more reason to *change* these to primitives.
1584 : // BTW: One more example how useful the principles of primitives are; the decomposition
1585 : // is by definition a simpler, maybe more expensive representation of the same content.
1586 0 : process(rCandidate.get2DDecomposition(getViewInformation2D()));
1587 0 : break;
1588 : }
1589 :
1590 9 : const primitive2d::PolyPolygonGradientPrimitive2D& rGradientCandidate = static_cast< const primitive2d::PolyPolygonGradientPrimitive2D& >(rCandidate);
1591 18 : basegfx::B2DPolyPolygon aLocalPolyPolygon(rGradientCandidate.getB2DPolyPolygon());
1592 :
1593 9 : if(aLocalPolyPolygon.getB2DRange() != rGradientCandidate.getDefinitionRange())
1594 : {
1595 : // the range which defines the gradient is different from the range of the
1596 : // geometry (used for writer frames). This cannot be done calling vcl, thus use
1597 : // decomposition here
1598 5 : process(rCandidate.get2DDecomposition(getViewInformation2D()));
1599 5 : break;
1600 : }
1601 :
1602 : // #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
1603 : // per polygon. Split polygon until there are less than that
1604 4 : while(fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon))
1605 : ;
1606 :
1607 : // for support of MetaCommentActions of the form XGRAD_SEQ_BEGIN, XGRAD_SEQ_END
1608 : // it is safest to use the VCL OutputDevice::DrawGradient method which creates those.
1609 : // re-create a VCL-gradient from FillGradientPrimitive2D and the needed tools PolyPolygon
1610 8 : Gradient aVCLGradient;
1611 4 : impConvertFillGradientAttributeToVCLGradient(aVCLGradient, rGradientCandidate.getFillGradient(), false);
1612 4 : aLocalPolyPolygon.transform(maCurrentTransformation);
1613 :
1614 : // #i82145# ATM VCL printing of gradients using curved shapes does not work,
1615 : // i submitted the bug with the given ID to THB. When that task is fixed it is
1616 : // necessary to again remove this subdivision since it decreases possible
1617 : // printing quality (not even resolution-dependent for now). THB will tell
1618 : // me when that task is fixed in the master
1619 : const tools::PolyPolygon aToolsPolyPolygon(
1620 : getFillPolyPolygon(
1621 8 : basegfx::tools::adaptiveSubdivideByAngle(aLocalPolyPolygon)));
1622 :
1623 :
1624 : // XPATHFILL_SEQ_BEGIN/XPATHFILL_SEQ_END support
1625 4 : SvtGraphicFill* pSvtGraphicFill = 0;
1626 :
1627 4 : if(!mnSvtGraphicFillCount && aLocalPolyPolygon.count())
1628 : {
1629 : // setup gradient stuff like in like in impgrfll
1630 4 : SvtGraphicFill::GradientType eGrad(SvtGraphicFill::gradientLinear);
1631 :
1632 4 : switch(aVCLGradient.GetStyle())
1633 : {
1634 : default : // GradientStyle_LINEAR:
1635 : case GradientStyle_AXIAL:
1636 4 : eGrad = SvtGraphicFill::gradientLinear;
1637 4 : break;
1638 : case GradientStyle_RADIAL:
1639 : case GradientStyle_ELLIPTICAL:
1640 0 : eGrad = SvtGraphicFill::gradientRadial;
1641 0 : break;
1642 : case GradientStyle_SQUARE:
1643 : case GradientStyle_RECT:
1644 0 : eGrad = SvtGraphicFill::gradientRectangular;
1645 0 : break;
1646 : }
1647 :
1648 : pSvtGraphicFill = new SvtGraphicFill(
1649 : aToolsPolyPolygon,
1650 : Color(),
1651 : 0.0,
1652 : SvtGraphicFill::fillEvenOdd,
1653 : SvtGraphicFill::fillGradient,
1654 : SvtGraphicFill::Transform(),
1655 : false,
1656 : SvtGraphicFill::hatchSingle,
1657 : Color(),
1658 : eGrad,
1659 4 : aVCLGradient.GetStartColor(),
1660 4 : aVCLGradient.GetEndColor(),
1661 4 : aVCLGradient.GetSteps(),
1662 16 : Graphic());
1663 : }
1664 :
1665 : // call VCL directly; encapsulate with SvtGraphicFill
1666 4 : impStartSvtGraphicFill(pSvtGraphicFill);
1667 4 : mpOutputDevice->DrawGradient(aToolsPolyPolygon, aVCLGradient);
1668 4 : impEndSvtGraphicFill(pSvtGraphicFill);
1669 :
1670 13 : break;
1671 : }
1672 : case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D :
1673 : {
1674 1403 : const primitive2d::PolyPolygonColorPrimitive2D& rPolygonCandidate(static_cast< const primitive2d::PolyPolygonColorPrimitive2D& >(rCandidate));
1675 1403 : basegfx::B2DPolyPolygon aLocalPolyPolygon(rPolygonCandidate.getB2DPolyPolygon());
1676 :
1677 : // #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
1678 : // per polygon. Split polygon until there are less than that
1679 1403 : while(fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon))
1680 : ;
1681 :
1682 2806 : const basegfx::BColor aPolygonColor(maBColorModifierStack.getModifiedColor(rPolygonCandidate.getBColor()));
1683 1403 : aLocalPolyPolygon.transform(maCurrentTransformation);
1684 :
1685 : // XPATHFILL_SEQ_BEGIN/XPATHFILL_SEQ_END support
1686 1403 : SvtGraphicFill* pSvtGraphicFill = 0;
1687 :
1688 : // #i121267# Not needed, does not give better quality compared with
1689 : // the MetaActionType::POLYPOLYGON written by the DrawPolyPolygon command
1690 : // below
1691 1403 : bool bSupportSvtGraphicFill(false);
1692 :
1693 1403 : if(bSupportSvtGraphicFill && !mnSvtGraphicFillCount && aLocalPolyPolygon.count())
1694 : {
1695 : // setup simple color fill stuff like in impgrfll
1696 : pSvtGraphicFill = new SvtGraphicFill(
1697 : getFillPolyPolygon(aLocalPolyPolygon),
1698 : Color(aPolygonColor),
1699 : 0.0,
1700 : SvtGraphicFill::fillEvenOdd,
1701 : SvtGraphicFill::fillSolid,
1702 : SvtGraphicFill::Transform(),
1703 : false,
1704 : SvtGraphicFill::hatchSingle,
1705 : Color(),
1706 : SvtGraphicFill::gradientLinear,
1707 : Color(),
1708 : Color(),
1709 : 0,
1710 0 : Graphic());
1711 : }
1712 :
1713 : // set line and fill color
1714 1403 : mpOutputDevice->SetFillColor(Color(aPolygonColor));
1715 1403 : mpOutputDevice->SetLineColor();
1716 :
1717 : // call VCL directly; encapsulate with SvtGraphicFill
1718 1403 : if(bSupportSvtGraphicFill)
1719 : {
1720 0 : impStartSvtGraphicFill(pSvtGraphicFill);
1721 : }
1722 :
1723 1403 : mpOutputDevice->DrawPolyPolygon(aLocalPolyPolygon);
1724 :
1725 1403 : if(bSupportSvtGraphicFill)
1726 : {
1727 0 : impEndSvtGraphicFill(pSvtGraphicFill);
1728 : }
1729 :
1730 2806 : break;
1731 : }
1732 : case PRIMITIVE2D_ID_METAFILEPRIMITIVE2D :
1733 : {
1734 : static bool bUseMetaFilePrimitiveDecomposition(true);
1735 84 : const primitive2d::MetafilePrimitive2D& aMetafile = static_cast< const primitive2d::MetafilePrimitive2D& >(rCandidate);
1736 :
1737 84 : if(bUseMetaFilePrimitiveDecomposition && !aMetafile.getMetaFile().GetUseCanvas())
1738 : {
1739 : // Use new Metafile decomposition.
1740 : // TODO EMF+ stuffed into METACOMMENT support required
1741 42 : process(rCandidate.get2DDecomposition(getViewInformation2D()));
1742 : }
1743 : else
1744 : {
1745 : // direct draw of MetaFile, use default processing
1746 42 : RenderMetafilePrimitive2D(aMetafile);
1747 : }
1748 :
1749 84 : break;
1750 : }
1751 : case PRIMITIVE2D_ID_MASKPRIMITIVE2D :
1752 : {
1753 : // mask group. Special handling for MetaFiles.
1754 62 : const primitive2d::MaskPrimitive2D& rMaskCandidate = static_cast< const primitive2d::MaskPrimitive2D& >(rCandidate);
1755 :
1756 62 : if(rMaskCandidate.getChildren().hasElements())
1757 : {
1758 62 : basegfx::B2DPolyPolygon aMask(rMaskCandidate.getMask());
1759 :
1760 62 : if(aMask.count())
1761 : {
1762 : // prepare new mask polygon and rescue current one
1763 62 : aMask.transform(maCurrentTransformation);
1764 62 : const basegfx::B2DPolyPolygon aLastClipPolyPolygon(maClipPolyPolygon);
1765 :
1766 62 : if(maClipPolyPolygon.count())
1767 : {
1768 : // there is already a clip polygon set; build clipped union of
1769 : // current mask polygon and new one
1770 8 : maClipPolyPolygon = basegfx::tools::clipPolyPolygonOnPolyPolygon(
1771 : aMask,
1772 : maClipPolyPolygon,
1773 : true, // #i106516# we want the inside of aMask, not the outside
1774 4 : false);
1775 : }
1776 : else
1777 : {
1778 : // use mask directly
1779 58 : maClipPolyPolygon = aMask;
1780 : }
1781 :
1782 62 : if(maClipPolyPolygon.count())
1783 : {
1784 : // set VCL clip region; subdivide before conversion to tools polygon. Subdivision necessary (!)
1785 : // Removed subdivision and fixed in vcl::Region::ImplPolyPolyRegionToBandRegionFunc() in VCL where
1786 : // the ClipRegion is built from the Polygon. A AdaptiveSubdivide on the source polygon was missing there
1787 62 : mpOutputDevice->Push(PushFlags::CLIPREGION);
1788 62 : mpOutputDevice->SetClipRegion(vcl::Region(maClipPolyPolygon));
1789 :
1790 : // recursively paint content
1791 : // #i121267# Only need to process sub-content when clip polygon is *not* empty.
1792 : // If it is empty, the clip is empty and there can be nothing inside.
1793 62 : process(rMaskCandidate.getChildren());
1794 :
1795 : // restore VCL clip region
1796 62 : mpOutputDevice->Pop();
1797 : }
1798 :
1799 : // restore to rescued clip polygon
1800 62 : maClipPolyPolygon = aLastClipPolyPolygon;
1801 : }
1802 : else
1803 : {
1804 : // no mask, no clipping. recursively paint content
1805 0 : process(rMaskCandidate.getChildren());
1806 62 : }
1807 : }
1808 :
1809 62 : break;
1810 : }
1811 : case PRIMITIVE2D_ID_MODIFIEDCOLORPRIMITIVE2D :
1812 : {
1813 : // modified color group. Force output to unified color. Use default pocessing.
1814 0 : RenderModifiedColorPrimitive2D(static_cast< const primitive2d::ModifiedColorPrimitive2D& >(rCandidate));
1815 0 : break;
1816 : }
1817 : case PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D :
1818 : {
1819 : // for metafile: Need to examine what the pure vcl version is doing here actually
1820 : // - uses DrawTransparent with metafile for content and a gradient
1821 : // - uses DrawTransparent for single PolyPoylgons directly. Can be detected by
1822 : // checking the content for single PolyPolygonColorPrimitive2D
1823 43 : const primitive2d::UnifiedTransparencePrimitive2D& rUniTransparenceCandidate = static_cast< const primitive2d::UnifiedTransparencePrimitive2D& >(rCandidate);
1824 43 : const primitive2d::Primitive2DSequence rContent = rUniTransparenceCandidate.getChildren();
1825 :
1826 43 : if(rContent.hasElements())
1827 : {
1828 43 : if(0.0 == rUniTransparenceCandidate.getTransparence())
1829 : {
1830 : // not transparent at all, use content
1831 0 : process(rUniTransparenceCandidate.getChildren());
1832 : }
1833 43 : else if(rUniTransparenceCandidate.getTransparence() > 0.0 && rUniTransparenceCandidate.getTransparence() < 1.0)
1834 : {
1835 : // try to identify a single PolyPolygonColorPrimitive2D in the
1836 : // content part of the transparence primitive
1837 43 : const primitive2d::PolyPolygonColorPrimitive2D* pPoPoColor = 0;
1838 : static bool bForceToMetafile(false);
1839 :
1840 43 : if(!bForceToMetafile && 1 == rContent.getLength())
1841 : {
1842 43 : const primitive2d::Primitive2DReference xReference(rContent[0]);
1843 43 : pPoPoColor = dynamic_cast< const primitive2d::PolyPolygonColorPrimitive2D* >(xReference.get());
1844 : }
1845 :
1846 : // PolyPolygonGradientPrimitive2D, PolyPolygonHatchPrimitive2D and
1847 : // PolyPolygonGraphicPrimitive2D are derived from PolyPolygonColorPrimitive2D.
1848 : // Check also for correct ID to exclude derived implementations
1849 43 : if(pPoPoColor && PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D == pPoPoColor->getPrimitive2DID())
1850 : {
1851 : // single transparent tools::PolyPolygon identified, use directly
1852 39 : const basegfx::BColor aPolygonColor(maBColorModifierStack.getModifiedColor(pPoPoColor->getBColor()));
1853 78 : basegfx::B2DPolyPolygon aLocalPolyPolygon(pPoPoColor->getB2DPolyPolygon());
1854 :
1855 : // #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
1856 : // per polygon. Split polygon until there are less than that
1857 39 : while(fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon))
1858 : ;
1859 :
1860 : // now transform
1861 39 : aLocalPolyPolygon.transform(maCurrentTransformation);
1862 :
1863 : // XPATHFILL_SEQ_BEGIN/XPATHFILL_SEQ_END support
1864 39 : SvtGraphicFill* pSvtGraphicFill = 0;
1865 :
1866 : // #i121267# Not needed, does not give better quality compared with
1867 : // the MetaActionType::POLYPOLYGON written by the DrawPolyPolygon command
1868 : // below
1869 39 : bool bSupportSvtGraphicFill(false);
1870 :
1871 39 : if(bSupportSvtGraphicFill && !mnSvtGraphicFillCount && aLocalPolyPolygon.count())
1872 : {
1873 : // setup simple color with transparence fill stuff like in impgrfll
1874 : pSvtGraphicFill = new SvtGraphicFill(
1875 : getFillPolyPolygon(aLocalPolyPolygon),
1876 : Color(aPolygonColor),
1877 : rUniTransparenceCandidate.getTransparence(),
1878 : SvtGraphicFill::fillEvenOdd,
1879 : SvtGraphicFill::fillSolid,
1880 : SvtGraphicFill::Transform(),
1881 : false,
1882 : SvtGraphicFill::hatchSingle,
1883 : Color(),
1884 : SvtGraphicFill::gradientLinear,
1885 : Color(),
1886 : Color(),
1887 : 0,
1888 0 : Graphic());
1889 : }
1890 :
1891 : // set line and fill color
1892 39 : const sal_uInt16 nTransPercentVcl((sal_uInt16)basegfx::fround(rUniTransparenceCandidate.getTransparence() * 100.0));
1893 39 : mpOutputDevice->SetFillColor(Color(aPolygonColor));
1894 39 : mpOutputDevice->SetLineColor();
1895 :
1896 : // call VCL directly; encapsulate with SvtGraphicFill
1897 39 : if(bSupportSvtGraphicFill)
1898 : {
1899 0 : impStartSvtGraphicFill(pSvtGraphicFill);
1900 : }
1901 :
1902 : mpOutputDevice->DrawTransparent(
1903 : tools::PolyPolygon(aLocalPolyPolygon),
1904 39 : nTransPercentVcl);
1905 :
1906 39 : if(bSupportSvtGraphicFill)
1907 : {
1908 0 : impEndSvtGraphicFill(pSvtGraphicFill);
1909 39 : }
1910 : }
1911 : else
1912 : {
1913 : // svae old mfCurrentUnifiedTransparence and set new one
1914 : // so that contained SvtGraphicStroke may use the current one
1915 4 : const double fLastCurrentUnifiedTransparence(mfCurrentUnifiedTransparence);
1916 : // #i105377# paint the content metafile opaque as the transparency gets
1917 : // split of into the gradient below
1918 : // mfCurrentUnifiedTransparence = rUniTransparenceCandidate.getTransparence();
1919 4 : mfCurrentUnifiedTransparence = 0;
1920 :
1921 : // various content, create content-metafile
1922 4 : GDIMetaFile aContentMetafile;
1923 4 : const Rectangle aPrimitiveRectangle(impDumpToMetaFile(rContent, aContentMetafile));
1924 :
1925 : // restore mfCurrentUnifiedTransparence; it may have been used
1926 : // while processing the sub-content in impDumpToMetaFile
1927 4 : mfCurrentUnifiedTransparence = fLastCurrentUnifiedTransparence;
1928 :
1929 : // create uniform VCL gradient for uniform transparency
1930 8 : Gradient aVCLGradient;
1931 4 : const sal_uInt8 nTransPercentVcl((sal_uInt8)basegfx::fround(rUniTransparenceCandidate.getTransparence() * 255.0));
1932 4 : const Color aTransColor(nTransPercentVcl, nTransPercentVcl, nTransPercentVcl);
1933 :
1934 4 : aVCLGradient.SetStyle(GradientStyle_LINEAR);
1935 4 : aVCLGradient.SetStartColor(aTransColor);
1936 4 : aVCLGradient.SetEndColor(aTransColor);
1937 4 : aVCLGradient.SetAngle(0);
1938 4 : aVCLGradient.SetBorder(0);
1939 4 : aVCLGradient.SetOfsX(0);
1940 4 : aVCLGradient.SetOfsY(0);
1941 4 : aVCLGradient.SetStartIntensity(100);
1942 4 : aVCLGradient.SetEndIntensity(100);
1943 4 : aVCLGradient.SetSteps(2);
1944 :
1945 : // render it to VCL
1946 : mpOutputDevice->DrawTransparent(
1947 : aContentMetafile, aPrimitiveRectangle.TopLeft(),
1948 8 : aPrimitiveRectangle.GetSize(), aVCLGradient);
1949 : }
1950 : }
1951 : }
1952 :
1953 43 : break;
1954 : }
1955 : case PRIMITIVE2D_ID_TRANSPARENCEPRIMITIVE2D :
1956 : {
1957 : // for metafile: Need to examine what the pure vcl version is doing here actually
1958 : // - uses DrawTransparent with metafile for content and a gradient
1959 : // i can detect this here with checking the gradient part for a single
1960 : // FillGradientPrimitive2D and reconstruct the gradient.
1961 : // If that detection goes wrong, i have to create an transparence-blended bitmap. Eventually
1962 : // do that in stripes, else RenderTransparencePrimitive2D may just be used
1963 5 : const primitive2d::TransparencePrimitive2D& rTransparenceCandidate = static_cast< const primitive2d::TransparencePrimitive2D& >(rCandidate);
1964 5 : const primitive2d::Primitive2DSequence rContent = rTransparenceCandidate.getChildren();
1965 10 : const primitive2d::Primitive2DSequence rTransparence = rTransparenceCandidate.getTransparence();
1966 :
1967 5 : if(rContent.hasElements() && rTransparence.hasElements())
1968 : {
1969 : // try to identify a single FillGradientPrimitive2D in the
1970 : // transparence part of the primitive
1971 5 : const primitive2d::FillGradientPrimitive2D* pFiGradient = 0;
1972 : static bool bForceToBigTransparentVDev(false);
1973 :
1974 5 : if(!bForceToBigTransparentVDev && 1 == rTransparence.getLength())
1975 : {
1976 5 : const primitive2d::Primitive2DReference xReference(rTransparence[0]);
1977 5 : pFiGradient = dynamic_cast< const primitive2d::FillGradientPrimitive2D* >(xReference.get());
1978 : }
1979 :
1980 : // Check also for correct ID to exclude derived implementations
1981 5 : if(pFiGradient && PRIMITIVE2D_ID_FILLGRADIENTPRIMITIVE2D == pFiGradient->getPrimitive2DID())
1982 : {
1983 : // various content, create content-metafile
1984 5 : GDIMetaFile aContentMetafile;
1985 5 : const Rectangle aPrimitiveRectangle(impDumpToMetaFile(rContent, aContentMetafile));
1986 :
1987 : // re-create a VCL-gradient from FillGradientPrimitive2D
1988 10 : Gradient aVCLGradient;
1989 5 : impConvertFillGradientAttributeToVCLGradient(aVCLGradient, pFiGradient->getFillGradient(), true);
1990 :
1991 : // render it to VCL
1992 : mpOutputDevice->DrawTransparent(
1993 : aContentMetafile, aPrimitiveRectangle.TopLeft(),
1994 10 : aPrimitiveRectangle.GetSize(), aVCLGradient);
1995 : }
1996 : else
1997 : {
1998 : // sub-transparence group. Draw to VDev first.
1999 : // this may get refined to tiling when resolution is too big here
2000 :
2001 : // need to avoid switching off MapMode stuff here; maybe need another
2002 : // tooling class, cannot just do the same as with the pixel renderer.
2003 : // Need to experiment...
2004 :
2005 : // Okay, basic implementation finished and tested. The DPI stuff was hard
2006 : // and not easy to find out that it's needed.
2007 : // Since this will not yet happen normally (as long as no one constructs
2008 : // transparence primitives with non-trivial transparence content) i will for now not
2009 : // refine to tiling here.
2010 :
2011 0 : basegfx::B2DRange aViewRange(primitive2d::getB2DRangeFromPrimitive2DSequence(rContent, getViewInformation2D()));
2012 0 : aViewRange.transform(maCurrentTransformation);
2013 : const Rectangle aRectLogic(
2014 0 : (sal_Int32)floor(aViewRange.getMinX()), (sal_Int32)floor(aViewRange.getMinY()),
2015 0 : (sal_Int32)ceil(aViewRange.getMaxX()), (sal_Int32)ceil(aViewRange.getMaxY()));
2016 0 : const Rectangle aRectPixel(mpOutputDevice->LogicToPixel(aRectLogic));
2017 0 : Size aSizePixel(aRectPixel.GetSize());
2018 0 : const Point aEmptyPoint;
2019 0 : ScopedVclPtrInstance< VirtualDevice > aBufferDevice;
2020 0 : const sal_uInt32 nMaxQuadratPixels(500000);
2021 0 : const sal_uInt32 nViewVisibleArea(aSizePixel.getWidth() * aSizePixel.getHeight());
2022 0 : double fReduceFactor(1.0);
2023 :
2024 0 : if(nViewVisibleArea > nMaxQuadratPixels)
2025 : {
2026 : // reduce render size
2027 0 : fReduceFactor = sqrt((double)nMaxQuadratPixels / (double)nViewVisibleArea);
2028 0 : aSizePixel = Size(basegfx::fround((double)aSizePixel.getWidth() * fReduceFactor),
2029 0 : basegfx::fround((double)aSizePixel.getHeight() * fReduceFactor));
2030 : }
2031 :
2032 0 : if(aBufferDevice->SetOutputSizePixel(aSizePixel))
2033 : {
2034 : // create and set MapModes for target devices
2035 0 : MapMode aNewMapMode(mpOutputDevice->GetMapMode());
2036 0 : aNewMapMode.SetOrigin(Point(-aRectLogic.Left(), -aRectLogic.Top()));
2037 0 : aBufferDevice->SetMapMode(aNewMapMode);
2038 :
2039 : // prepare view transformation for target renderers
2040 : // ATTENTION! Need to apply another scaling because of the potential DPI differences
2041 : // between Printer and VDev (mpOutputDevice and aBufferDevice here).
2042 : // To get the DPI, LogicToPixel from (1,1) from MAP_INCH needs to be used.
2043 0 : basegfx::B2DHomMatrix aViewTransform(aBufferDevice->GetViewTransformation());
2044 0 : const Size aDPIOld(mpOutputDevice->LogicToPixel(Size(1, 1), MAP_INCH));
2045 0 : const Size aDPINew(aBufferDevice->LogicToPixel(Size(1, 1), MAP_INCH));
2046 0 : const double fDPIXChange((double)aDPIOld.getWidth() / (double)aDPINew.getWidth());
2047 0 : const double fDPIYChange((double)aDPIOld.getHeight() / (double)aDPINew.getHeight());
2048 :
2049 0 : if(!basegfx::fTools::equal(fDPIXChange, 1.0) || !basegfx::fTools::equal(fDPIYChange, 1.0))
2050 : {
2051 0 : aViewTransform.scale(fDPIXChange, fDPIYChange);
2052 : }
2053 :
2054 : // also take scaling from Size reduction into acount
2055 0 : if(!basegfx::fTools::equal(fReduceFactor, 1.0))
2056 : {
2057 0 : aViewTransform.scale(fReduceFactor, fReduceFactor);
2058 : }
2059 :
2060 : // create view information and pixel renderer. Reuse known ViewInformation
2061 : // except new transformation and range
2062 : const geometry::ViewInformation2D aViewInfo(
2063 0 : getViewInformation2D().getObjectTransformation(),
2064 : aViewTransform,
2065 : aViewRange,
2066 0 : getViewInformation2D().getVisualizedPage(),
2067 0 : getViewInformation2D().getViewTime(),
2068 0 : getViewInformation2D().getExtendedInformationSequence());
2069 :
2070 0 : VclPixelProcessor2D aBufferProcessor(aViewInfo, *aBufferDevice.get());
2071 :
2072 : // draw content using pixel renderer
2073 0 : aBufferProcessor.process(rContent);
2074 0 : const Bitmap aBmContent(aBufferDevice->GetBitmap(aEmptyPoint, aSizePixel));
2075 :
2076 : // draw transparence using pixel renderer
2077 0 : aBufferDevice->Erase();
2078 0 : aBufferProcessor.process(rTransparence);
2079 0 : const AlphaMask aBmAlpha(aBufferDevice->GetBitmap(aEmptyPoint, aSizePixel));
2080 :
2081 : // paint
2082 : mpOutputDevice->DrawBitmapEx(
2083 : aRectLogic.TopLeft(),
2084 : aRectLogic.GetSize(),
2085 0 : BitmapEx(aBmContent, aBmAlpha));
2086 0 : }
2087 : }
2088 : }
2089 :
2090 10 : break;
2091 : }
2092 : case PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D :
2093 : {
2094 : // use default transform group pocessing
2095 378 : RenderTransformPrimitive2D(static_cast< const primitive2d::TransformPrimitive2D& >(rCandidate));
2096 378 : break;
2097 : }
2098 : case PRIMITIVE2D_ID_PAGEPREVIEWPRIMITIVE2D :
2099 : {
2100 : // new XDrawPage for ViewInformation2D
2101 0 : RenderPagePreviewPrimitive2D(static_cast< const primitive2d::PagePreviewPrimitive2D& >(rCandidate));
2102 0 : break;
2103 : }
2104 : case PRIMITIVE2D_ID_MARKERARRAYPRIMITIVE2D :
2105 : {
2106 : // use default marker array pocessing
2107 0 : RenderMarkerArrayPrimitive2D(static_cast< const primitive2d::MarkerArrayPrimitive2D& >(rCandidate));
2108 0 : break;
2109 : }
2110 : case PRIMITIVE2D_ID_POINTARRAYPRIMITIVE2D :
2111 : {
2112 : // use default point array pocessing
2113 0 : RenderPointArrayPrimitive2D(static_cast< const primitive2d::PointArrayPrimitive2D& >(rCandidate));
2114 0 : break;
2115 : }
2116 : case PRIMITIVE2D_ID_STRUCTURETAGPRIMITIVE2D :
2117 : {
2118 : // structured tag primitive
2119 0 : const primitive2d::StructureTagPrimitive2D& rStructureTagCandidate = static_cast< const primitive2d::StructureTagPrimitive2D& >(rCandidate);
2120 0 : const vcl::PDFWriter::StructElement& rTagElement(rStructureTagCandidate.getStructureElement());
2121 0 : const bool bTagUsed(vcl::PDFWriter::NonStructElement != rTagElement);
2122 :
2123 0 : if(mpPDFExtOutDevData && bTagUsed)
2124 : {
2125 : // write start tag
2126 0 : mpPDFExtOutDevData->BeginStructureElement(rTagElement);
2127 : }
2128 :
2129 : // process children normally
2130 0 : process(rStructureTagCandidate.getChildren());
2131 :
2132 0 : if(mpPDFExtOutDevData && bTagUsed)
2133 : {
2134 : // write end tag
2135 0 : mpPDFExtOutDevData->EndStructureElement();
2136 : }
2137 :
2138 0 : break;
2139 : }
2140 : case PRIMITIVE2D_ID_EPSPRIMITIVE2D :
2141 : {
2142 0 : RenderEpsPrimitive2D(static_cast< const primitive2d::EpsPrimitive2D& >(rCandidate));
2143 0 : break;
2144 : }
2145 : case PRIMITIVE2D_ID_OPENGLPRIMITIVE2D:
2146 : {
2147 0 : RenderOpenGLPrimitive2D(static_cast< const primitive2d::OpenGLPrimitive2D& >(rCandidate));
2148 0 : break;
2149 : }
2150 : default :
2151 : {
2152 : // process recursively
2153 5701 : process(rCandidate.get2DDecomposition(getViewInformation2D()));
2154 5701 : break;
2155 : }
2156 : }
2157 15967 : }
2158 : } // end of namespace processor2d
2159 753 : } // end of namespace drawinglayer
2160 :
2161 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
