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 <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
21 : #include <basegfx/polygon/b2dpolypolygontools.hxx>
22 : #include <basegfx/tools/canvastools.hxx>
23 : #include <drawinglayer/primitive2d/fillgradientprimitive2d.hxx>
24 : #include <drawinglayer/primitive2d/maskprimitive2d.hxx>
25 : #include <drawinglayer/primitive2d/fillhatchprimitive2d.hxx>
26 : #include <basegfx/matrix/b2dhommatrix.hxx>
27 : #include <drawinglayer/primitive2d/fillgraphicprimitive2d.hxx>
28 : #include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
29 : #include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
30 : #include <basegfx/matrix/b2dhommatrixtools.hxx>
31 : #include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
32 : #include <drawinglayer/geometry/viewinformation2d.hxx>
33 : #include <vcl/graph.hxx>
34 :
35 :
36 :
37 : using namespace com::sun::star;
38 :
39 :
40 :
41 : namespace drawinglayer
42 : {
43 : namespace primitive2d
44 : {
45 10515 : Primitive2DSequence PolyPolygonHairlinePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
46 : {
47 10515 : const basegfx::B2DPolyPolygon aPolyPolygon(getB2DPolyPolygon());
48 10515 : const sal_uInt32 nCount(aPolyPolygon.count());
49 :
50 10515 : if(nCount)
51 : {
52 10515 : Primitive2DSequence aRetval(nCount);
53 :
54 39160 : for(sal_uInt32 a(0L); a < nCount; a++)
55 : {
56 28645 : aRetval[a] = Primitive2DReference(new PolygonHairlinePrimitive2D(aPolyPolygon.getB2DPolygon(a), getBColor()));
57 : }
58 :
59 10515 : return aRetval;
60 : }
61 : else
62 : {
63 0 : return Primitive2DSequence();
64 10515 : }
65 : }
66 :
67 30452 : PolyPolygonHairlinePrimitive2D::PolyPolygonHairlinePrimitive2D(const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::BColor& rBColor)
68 : : BufferedDecompositionPrimitive2D(),
69 : maPolyPolygon(rPolyPolygon),
70 30452 : maBColor(rBColor)
71 : {
72 30452 : }
73 :
74 1364 : bool PolyPolygonHairlinePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
75 : {
76 1364 : if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
77 : {
78 1364 : const PolyPolygonHairlinePrimitive2D& rCompare = static_cast<const PolyPolygonHairlinePrimitive2D&>(rPrimitive);
79 :
80 1364 : return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
81 1364 : && getBColor() == rCompare.getBColor());
82 : }
83 :
84 0 : return false;
85 : }
86 :
87 76317 : basegfx::B2DRange PolyPolygonHairlinePrimitive2D::getB2DRange(const geometry::ViewInformation2D& /*rViewInformation*/) const
88 : {
89 : // return range
90 76317 : return basegfx::tools::getRange(getB2DPolyPolygon());
91 : }
92 :
93 : // provide unique ID
94 15533 : ImplPrimitive2DIDBlock(PolyPolygonHairlinePrimitive2D, PRIMITIVE2D_ID_POLYPOLYGONHAIRLINEPRIMITIVE2D)
95 :
96 : } // end of namespace primitive2d
97 : } // end of namespace drawinglayer
98 :
99 :
100 :
101 : namespace drawinglayer
102 : {
103 : namespace primitive2d
104 : {
105 0 : Primitive2DSequence PolyPolygonMarkerPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
106 : {
107 0 : const basegfx::B2DPolyPolygon aPolyPolygon(getB2DPolyPolygon());
108 0 : const sal_uInt32 nCount(aPolyPolygon.count());
109 :
110 0 : if(nCount)
111 : {
112 0 : Primitive2DSequence aRetval(nCount);
113 :
114 0 : for(sal_uInt32 a(0L); a < nCount; a++)
115 : {
116 0 : aRetval[a] = Primitive2DReference(
117 : new PolygonMarkerPrimitive2D(
118 : aPolyPolygon.getB2DPolygon(a),
119 : getRGBColorA(),
120 : getRGBColorB(),
121 0 : getDiscreteDashLength()));
122 : }
123 :
124 0 : return aRetval;
125 : }
126 : else
127 : {
128 0 : return Primitive2DSequence();
129 0 : }
130 : }
131 :
132 0 : PolyPolygonMarkerPrimitive2D::PolyPolygonMarkerPrimitive2D(
133 : const basegfx::B2DPolyPolygon& rPolyPolygon,
134 : const basegfx::BColor& rRGBColorA,
135 : const basegfx::BColor& rRGBColorB,
136 : double fDiscreteDashLength)
137 : : BufferedDecompositionPrimitive2D(),
138 : maPolyPolygon(rPolyPolygon),
139 : maRGBColorA(rRGBColorA),
140 : maRGBColorB(rRGBColorB),
141 0 : mfDiscreteDashLength(fDiscreteDashLength)
142 : {
143 0 : }
144 :
145 0 : bool PolyPolygonMarkerPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
146 : {
147 0 : if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
148 : {
149 0 : const PolyPolygonMarkerPrimitive2D& rCompare = static_cast<const PolyPolygonMarkerPrimitive2D&>(rPrimitive);
150 :
151 0 : return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
152 0 : && getRGBColorA() == rCompare.getRGBColorA()
153 0 : && getRGBColorB() == rCompare.getRGBColorB()
154 0 : && getDiscreteDashLength() == rCompare.getDiscreteDashLength());
155 : }
156 :
157 0 : return false;
158 : }
159 :
160 0 : basegfx::B2DRange PolyPolygonMarkerPrimitive2D::getB2DRange(const geometry::ViewInformation2D& /*rViewInformation*/) const
161 : {
162 : // return range
163 0 : return basegfx::tools::getRange(getB2DPolyPolygon());
164 : }
165 :
166 : // provide unique ID
167 0 : ImplPrimitive2DIDBlock(PolyPolygonMarkerPrimitive2D, PRIMITIVE2D_ID_POLYPOLYGONMARKERPRIMITIVE2D)
168 :
169 : } // end of namespace primitive2d
170 : } // end of namespace drawinglayer
171 :
172 :
173 :
174 : namespace drawinglayer
175 : {
176 : namespace primitive2d
177 : {
178 372 : Primitive2DSequence PolyPolygonStrokePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
179 : {
180 372 : const basegfx::B2DPolyPolygon aPolyPolygon(getB2DPolyPolygon());
181 372 : const sal_uInt32 nCount(aPolyPolygon.count());
182 :
183 372 : if(nCount)
184 : {
185 372 : Primitive2DSequence aRetval(nCount);
186 :
187 787 : for(sal_uInt32 a(0L); a < nCount; a++)
188 : {
189 830 : aRetval[a] = Primitive2DReference(
190 : new PolygonStrokePrimitive2D(
191 1245 : aPolyPolygon.getB2DPolygon(a), getLineAttribute(), getStrokeAttribute()));
192 : }
193 :
194 372 : return aRetval;
195 : }
196 : else
197 : {
198 0 : return Primitive2DSequence();
199 372 : }
200 : }
201 :
202 161 : PolyPolygonStrokePrimitive2D::PolyPolygonStrokePrimitive2D(
203 : const basegfx::B2DPolyPolygon& rPolyPolygon,
204 : const attribute::LineAttribute& rLineAttribute,
205 : const attribute::StrokeAttribute& rStrokeAttribute)
206 : : BufferedDecompositionPrimitive2D(),
207 : maPolyPolygon(rPolyPolygon),
208 : maLineAttribute(rLineAttribute),
209 161 : maStrokeAttribute(rStrokeAttribute)
210 : {
211 161 : }
212 :
213 219 : PolyPolygonStrokePrimitive2D::PolyPolygonStrokePrimitive2D(
214 : const basegfx::B2DPolyPolygon& rPolyPolygon,
215 : const attribute::LineAttribute& rLineAttribute)
216 : : BufferedDecompositionPrimitive2D(),
217 : maPolyPolygon(rPolyPolygon),
218 : maLineAttribute(rLineAttribute),
219 219 : maStrokeAttribute()
220 : {
221 219 : }
222 :
223 6 : bool PolyPolygonStrokePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
224 : {
225 6 : if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
226 : {
227 6 : const PolyPolygonStrokePrimitive2D& rCompare = static_cast<const PolyPolygonStrokePrimitive2D&>(rPrimitive);
228 :
229 6 : return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
230 6 : && getLineAttribute() == rCompare.getLineAttribute()
231 12 : && getStrokeAttribute() == rCompare.getStrokeAttribute());
232 : }
233 :
234 0 : return false;
235 : }
236 :
237 417 : basegfx::B2DRange PolyPolygonStrokePrimitive2D::getB2DRange(const geometry::ViewInformation2D& /*rViewInformation*/) const
238 : {
239 : // get range of it (subdivided)
240 417 : basegfx::B2DRange aRetval(basegfx::tools::getRange(getB2DPolyPolygon()));
241 :
242 : // if width, grow by line width
243 417 : if(getLineAttribute().getWidth())
244 : {
245 417 : aRetval.grow(getLineAttribute().getWidth() / 2.0);
246 : }
247 :
248 417 : return aRetval;
249 : }
250 :
251 : // provide unique ID
252 634 : ImplPrimitive2DIDBlock(PolyPolygonStrokePrimitive2D, PRIMITIVE2D_ID_POLYPOLYGONSTROKEPRIMITIVE2D)
253 :
254 : } // end of namespace primitive2d
255 : } // end of namespace drawinglayer
256 :
257 :
258 :
259 : namespace drawinglayer
260 : {
261 : namespace primitive2d
262 : {
263 172305 : PolyPolygonColorPrimitive2D::PolyPolygonColorPrimitive2D(
264 : const basegfx::B2DPolyPolygon& rPolyPolygon,
265 : const basegfx::BColor& rBColor)
266 : : BasePrimitive2D(),
267 : maPolyPolygon(rPolyPolygon),
268 172305 : maBColor(rBColor)
269 : {
270 172305 : }
271 :
272 1682 : bool PolyPolygonColorPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
273 : {
274 1682 : if(BasePrimitive2D::operator==(rPrimitive))
275 : {
276 1682 : const PolyPolygonColorPrimitive2D& rCompare = static_cast<const PolyPolygonColorPrimitive2D&>(rPrimitive);
277 :
278 1682 : return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
279 1682 : && getBColor() == rCompare.getBColor());
280 : }
281 :
282 0 : return false;
283 : }
284 :
285 170765 : basegfx::B2DRange PolyPolygonColorPrimitive2D::getB2DRange(const geometry::ViewInformation2D& /*rViewInformation*/) const
286 : {
287 : // return range
288 170765 : return basegfx::tools::getRange(getB2DPolyPolygon());
289 : }
290 :
291 : // provide unique ID
292 147014 : ImplPrimitive2DIDBlock(PolyPolygonColorPrimitive2D, PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D)
293 :
294 : } // end of namespace primitive2d
295 : } // end of namespace drawinglayer
296 :
297 :
298 :
299 : namespace drawinglayer
300 : {
301 : namespace primitive2d
302 : {
303 702 : Primitive2DSequence PolyPolygonGradientPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
304 : {
305 702 : if(!getFillGradient().isDefault())
306 : {
307 : // create SubSequence with FillGradientPrimitive2D
308 702 : const basegfx::B2DRange aPolyPolygonRange(getB2DPolyPolygon().getB2DRange());
309 : FillGradientPrimitive2D* pNewGradient = new FillGradientPrimitive2D(
310 : aPolyPolygonRange,
311 : getDefinitionRange(),
312 702 : getFillGradient());
313 702 : const Primitive2DReference xSubRef(pNewGradient);
314 1404 : const Primitive2DSequence aSubSequence(&xSubRef, 1L);
315 :
316 : // create mask primitive
317 702 : MaskPrimitive2D* pNewMask = new MaskPrimitive2D(getB2DPolyPolygon(), aSubSequence);
318 1404 : const Primitive2DReference xRef(pNewMask);
319 :
320 1404 : return Primitive2DSequence(&xRef, 1);
321 : }
322 : else
323 : {
324 0 : return Primitive2DSequence();
325 : }
326 : }
327 :
328 0 : PolyPolygonGradientPrimitive2D::PolyPolygonGradientPrimitive2D(
329 : const basegfx::B2DPolyPolygon& rPolyPolygon,
330 : const attribute::FillGradientAttribute& rFillGradient)
331 : : BufferedDecompositionPrimitive2D(),
332 : maPolyPolygon(rPolyPolygon),
333 : maDefinitionRange(rPolyPolygon.getB2DRange()),
334 0 : maFillGradient(rFillGradient)
335 : {
336 0 : }
337 :
338 702 : PolyPolygonGradientPrimitive2D::PolyPolygonGradientPrimitive2D(
339 : const basegfx::B2DPolyPolygon& rPolyPolygon,
340 : const basegfx::B2DRange& rDefinitionRange,
341 : const attribute::FillGradientAttribute& rFillGradient)
342 : : BufferedDecompositionPrimitive2D(),
343 : maPolyPolygon(rPolyPolygon),
344 : maDefinitionRange(rDefinitionRange),
345 702 : maFillGradient(rFillGradient)
346 : {
347 702 : }
348 :
349 0 : bool PolyPolygonGradientPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
350 : {
351 0 : if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
352 : {
353 0 : const PolyPolygonGradientPrimitive2D& rCompare = static_cast<const PolyPolygonGradientPrimitive2D&>(rPrimitive);
354 :
355 0 : return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
356 0 : && getDefinitionRange() == rCompare.getDefinitionRange()
357 0 : && getFillGradient() == rCompare.getFillGradient());
358 : }
359 :
360 0 : return false;
361 : }
362 :
363 : // provide unique ID
364 132 : ImplPrimitive2DIDBlock(PolyPolygonGradientPrimitive2D, PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D)
365 :
366 : } // end of namespace primitive2d
367 : } // end of namespace drawinglayer
368 :
369 :
370 :
371 : namespace drawinglayer
372 : {
373 : namespace primitive2d
374 : {
375 543 : Primitive2DSequence PolyPolygonHatchPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
376 : {
377 543 : if(!getFillHatch().isDefault())
378 : {
379 : // create SubSequence with FillHatchPrimitive2D
380 543 : const basegfx::B2DRange aPolyPolygonRange(getB2DPolyPolygon().getB2DRange());
381 : FillHatchPrimitive2D* pNewHatch = new FillHatchPrimitive2D(
382 : aPolyPolygonRange,
383 : getDefinitionRange(),
384 : getBackgroundColor(),
385 543 : getFillHatch());
386 543 : const Primitive2DReference xSubRef(pNewHatch);
387 1086 : const Primitive2DSequence aSubSequence(&xSubRef, 1L);
388 :
389 : // create mask primitive
390 543 : MaskPrimitive2D* pNewMask = new MaskPrimitive2D(getB2DPolyPolygon(), aSubSequence);
391 1086 : const Primitive2DReference xRef(pNewMask);
392 :
393 1086 : return Primitive2DSequence(&xRef, 1);
394 : }
395 : else
396 : {
397 0 : return Primitive2DSequence();
398 : }
399 : }
400 :
401 0 : PolyPolygonHatchPrimitive2D::PolyPolygonHatchPrimitive2D(
402 : const basegfx::B2DPolyPolygon& rPolyPolygon,
403 : const basegfx::BColor& rBackgroundColor,
404 : const attribute::FillHatchAttribute& rFillHatch)
405 : : BufferedDecompositionPrimitive2D(),
406 : maPolyPolygon(rPolyPolygon),
407 : maDefinitionRange(rPolyPolygon.getB2DRange()),
408 : maBackgroundColor(rBackgroundColor),
409 0 : maFillHatch(rFillHatch)
410 : {
411 0 : }
412 :
413 543 : PolyPolygonHatchPrimitive2D::PolyPolygonHatchPrimitive2D(
414 : const basegfx::B2DPolyPolygon& rPolyPolygon,
415 : const basegfx::B2DRange& rDefinitionRange,
416 : const basegfx::BColor& rBackgroundColor,
417 : const attribute::FillHatchAttribute& rFillHatch)
418 : : BufferedDecompositionPrimitive2D(),
419 : maPolyPolygon(rPolyPolygon),
420 : maDefinitionRange(rDefinitionRange),
421 : maBackgroundColor(rBackgroundColor),
422 543 : maFillHatch(rFillHatch)
423 : {
424 543 : }
425 :
426 0 : bool PolyPolygonHatchPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
427 : {
428 0 : if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
429 : {
430 0 : const PolyPolygonHatchPrimitive2D& rCompare = static_cast<const PolyPolygonHatchPrimitive2D&>(rPrimitive);
431 :
432 0 : return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
433 0 : && getDefinitionRange() == rCompare.getDefinitionRange()
434 0 : && getBackgroundColor() == rCompare.getBackgroundColor()
435 0 : && getFillHatch() == rCompare.getFillHatch());
436 : }
437 :
438 0 : return false;
439 : }
440 :
441 : // provide unique ID
442 235 : ImplPrimitive2DIDBlock(PolyPolygonHatchPrimitive2D, PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D)
443 :
444 : } // end of namespace primitive2d
445 : } // end of namespace drawinglayer
446 :
447 :
448 :
449 : namespace drawinglayer
450 : {
451 : namespace primitive2d
452 : {
453 290 : Primitive2DSequence PolyPolygonGraphicPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
454 : {
455 290 : if(!getFillGraphic().isDefault())
456 : {
457 290 : const Graphic& rGraphic = getFillGraphic().getGraphic();
458 290 : const GraphicType aType(rGraphic.GetType());
459 :
460 : // is there a bitmap or a metafile (do we have content)?
461 290 : if(GRAPHIC_BITMAP == aType || GRAPHIC_GDIMETAFILE == aType)
462 : {
463 290 : const Size aPrefSize(rGraphic.GetPrefSize());
464 :
465 : // does content have a size?
466 290 : if(aPrefSize.Width() && aPrefSize.Height())
467 : {
468 : // create SubSequence with FillGraphicPrimitive2D based on polygon range
469 290 : const basegfx::B2DRange aOutRange(getB2DPolyPolygon().getB2DRange());
470 : const basegfx::B2DHomMatrix aNewObjectTransform(
471 : basegfx::tools::createScaleTranslateB2DHomMatrix(
472 : aOutRange.getRange(),
473 290 : aOutRange.getMinimum()));
474 580 : Primitive2DReference xSubRef;
475 :
476 290 : if(aOutRange != getDefinitionRange())
477 : {
478 : // we want to paint (tiled) content which is defined relative to DefinitionRange
479 : // with the same tiling and offset(s) in the traget range of the geometry (the
480 : // polygon). The range given in the local FillGraphicAttribute defines the position
481 : // of the graphic in unit coordinates relative to the DefinitionRange. Transform
482 : // this using DefinitionRange to get to the global definition and then with the
483 : // inverse transformation from the target range to go to unit coordinates relative
484 : // to that traget coordinate system.
485 0 : basegfx::B2DRange aAdaptedRange(getFillGraphic().getGraphicRange());
486 :
487 : const basegfx::B2DHomMatrix aFromDefinitionRangeToGlobal(
488 : basegfx::tools::createScaleTranslateB2DHomMatrix(
489 0 : getDefinitionRange().getRange(),
490 0 : getDefinitionRange().getMinimum()));
491 :
492 0 : aAdaptedRange.transform(aFromDefinitionRangeToGlobal);
493 :
494 : basegfx::B2DHomMatrix aFromGlobalToOutRange(
495 : basegfx::tools::createScaleTranslateB2DHomMatrix(
496 : aOutRange.getRange(),
497 0 : aOutRange.getMinimum()));
498 0 : aFromGlobalToOutRange.invert();
499 :
500 0 : aAdaptedRange.transform(aFromGlobalToOutRange);
501 :
502 : const drawinglayer::attribute::FillGraphicAttribute aAdaptedFillGraphicAttribute(
503 0 : getFillGraphic().getGraphic(),
504 : aAdaptedRange,
505 0 : getFillGraphic().getTiling(),
506 0 : getFillGraphic().getOffsetX(),
507 0 : getFillGraphic().getOffsetY());
508 :
509 0 : xSubRef = new FillGraphicPrimitive2D(
510 : aNewObjectTransform,
511 0 : aAdaptedFillGraphicAttribute);
512 : }
513 : else
514 : {
515 580 : xSubRef = new FillGraphicPrimitive2D(
516 : aNewObjectTransform,
517 580 : getFillGraphic());
518 : }
519 :
520 : // embed to mask primitive
521 : const Primitive2DReference xRef(
522 : new MaskPrimitive2D(
523 : getB2DPolyPolygon(),
524 580 : Primitive2DSequence(&xSubRef, 1)));
525 :
526 580 : return Primitive2DSequence(&xRef, 1);
527 : }
528 : }
529 : }
530 :
531 0 : return Primitive2DSequence();
532 : }
533 :
534 0 : PolyPolygonGraphicPrimitive2D::PolyPolygonGraphicPrimitive2D(
535 : const basegfx::B2DPolyPolygon& rPolyPolygon,
536 : const attribute::FillGraphicAttribute& rFillGraphic)
537 : : BufferedDecompositionPrimitive2D(),
538 : maPolyPolygon(rPolyPolygon),
539 : maDefinitionRange(rPolyPolygon.getB2DRange()),
540 0 : maFillGraphic(rFillGraphic)
541 : {
542 0 : }
543 :
544 290 : PolyPolygonGraphicPrimitive2D::PolyPolygonGraphicPrimitive2D(
545 : const basegfx::B2DPolyPolygon& rPolyPolygon,
546 : const basegfx::B2DRange& rDefinitionRange,
547 : const attribute::FillGraphicAttribute& rFillGraphic)
548 : : BufferedDecompositionPrimitive2D(),
549 : maPolyPolygon(rPolyPolygon),
550 : maDefinitionRange(rDefinitionRange),
551 290 : maFillGraphic(rFillGraphic)
552 : {
553 290 : }
554 :
555 0 : bool PolyPolygonGraphicPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
556 : {
557 0 : if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
558 : {
559 0 : const PolyPolygonGraphicPrimitive2D& rCompare = static_cast<const PolyPolygonGraphicPrimitive2D&>(rPrimitive);
560 :
561 0 : return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
562 0 : && getDefinitionRange() == rCompare.getDefinitionRange()
563 0 : && getFillGraphic() == rCompare.getFillGraphic());
564 : }
565 :
566 0 : return false;
567 : }
568 :
569 : // provide unique ID
570 246 : ImplPrimitive2DIDBlock(PolyPolygonGraphicPrimitive2D, PRIMITIVE2D_ID_POLYPOLYGONGRAPHICPRIMITIVE2D)
571 :
572 : } // end of namespace primitive2d
573 : } // end of namespace drawinglayer
574 :
575 :
576 :
577 : namespace drawinglayer
578 : {
579 : namespace primitive2d
580 : {
581 0 : Primitive2DSequence PolyPolygonSelectionPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
582 : {
583 0 : Primitive2DSequence aRetval;
584 :
585 0 : if(getTransparence() < 1.0 && getB2DPolyPolygon().count())
586 : {
587 0 : if(getFill() && getB2DPolyPolygon().isClosed())
588 : {
589 : // create fill primitive
590 : const Primitive2DReference aFill(
591 : new PolyPolygonColorPrimitive2D(
592 : getB2DPolyPolygon(),
593 0 : getColor()));
594 :
595 0 : aRetval = Primitive2DSequence(&aFill, 1);
596 : }
597 :
598 0 : if(getDiscreteGrow() > 0.0)
599 : {
600 : const attribute::LineAttribute aLineAttribute(
601 0 : getColor(),
602 0 : getDiscreteGrow() * getDiscreteUnit() * 2.0);
603 : const Primitive2DReference aFatLine(
604 : new PolyPolygonStrokePrimitive2D(
605 : getB2DPolyPolygon(),
606 0 : aLineAttribute));
607 :
608 0 : appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, aFatLine);
609 : }
610 :
611 : // embed filled to transparency (if used)
612 0 : if(aRetval.getLength() && getTransparence() > 0.0)
613 : {
614 : const Primitive2DReference aTrans(
615 : new UnifiedTransparencePrimitive2D(
616 : aRetval,
617 0 : getTransparence()));
618 :
619 0 : aRetval = Primitive2DSequence(&aTrans, 1);
620 : }
621 : }
622 :
623 0 : return aRetval;
624 : }
625 :
626 0 : PolyPolygonSelectionPrimitive2D::PolyPolygonSelectionPrimitive2D(
627 : const basegfx::B2DPolyPolygon& rPolyPolygon,
628 : const basegfx::BColor& rColor,
629 : double fTransparence,
630 : double fDiscreteGrow,
631 : bool bFill)
632 : : DiscreteMetricDependentPrimitive2D(),
633 : maPolyPolygon(rPolyPolygon),
634 : maColor(rColor),
635 : mfTransparence(fTransparence),
636 0 : mfDiscreteGrow(fabs(fDiscreteGrow)),
637 0 : mbFill(bFill)
638 : {
639 0 : }
640 :
641 0 : bool PolyPolygonSelectionPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
642 : {
643 0 : if(DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
644 : {
645 0 : const PolyPolygonSelectionPrimitive2D& rCompare = static_cast<const PolyPolygonSelectionPrimitive2D&>(rPrimitive);
646 :
647 0 : return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
648 0 : && getColor() == rCompare.getColor()
649 0 : && getTransparence() == rCompare.getTransparence()
650 0 : && getDiscreteGrow() == rCompare.getDiscreteGrow()
651 0 : && getFill() == rCompare.getFill());
652 : }
653 :
654 0 : return false;
655 : }
656 :
657 0 : basegfx::B2DRange PolyPolygonSelectionPrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
658 : {
659 0 : basegfx::B2DRange aRetval(basegfx::tools::getRange(getB2DPolyPolygon()));
660 :
661 0 : if(getDiscreteGrow() > 0.0)
662 : {
663 : // get the current DiscreteUnit (not sure if getDiscreteUnit() is updated here, better go safe way)
664 0 : const double fDiscreteUnit((rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 0.0)).getLength());
665 :
666 0 : aRetval.grow(fDiscreteUnit * getDiscreteGrow());
667 : }
668 :
669 0 : return aRetval;
670 : }
671 :
672 : // provide unique ID
673 0 : ImplPrimitive2DIDBlock(PolyPolygonSelectionPrimitive2D, PRIMITIVE2D_ID_POLYPOLYGONSELECTIONPRIMITIVE2D)
674 :
675 : } // end of namespace primitive2d
676 1143 : } // end of namespace drawinglayer
677 :
678 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
