LibreOffice Module svx (master) 1
overlaytools.cxx
Go to the documentation of this file.
1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * 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
34#include <vcl/svapp.hxx>
35#include <vcl/settings.hxx>
37
38
40{
41
43 const basegfx::B2DPoint& rPosition,
44 const basegfx::B2DSize& rSize,
45 const basegfx::BColor& rStrokeColor,
46 const basegfx::BColor& rFillColor,
47 double fTransparence,
48 double fRotation)
49 : maPosition(rPosition)
50 , maSize(rSize)
51 , maStrokeColor(rStrokeColor)
52 , maFillColor(rFillColor)
53 , mfTransparence(fTransparence)
54 , mfRotation(fRotation)
55{}
56
58{
59 Primitive2DContainer aPrimitive2DSequence;
60 const double fHalfWidth = maSize.getX() * getDiscreteUnit() / 2.0;
61 const double fHalfHeight = maSize.getY() * getDiscreteUnit() / 2.0;
62
63 basegfx::B2DRange aRange(
64 maPosition.getX() - fHalfWidth, maPosition.getY() - fHalfHeight,
65 maPosition.getX() + fHalfWidth, maPosition.getY() + fHalfHeight);
66
68 {
69 basegfx::B2DPolygon aPolygon(
71
72 // create filled primitive
73 basegfx::B2DPolyPolygon aPolyPolygon;
74 aPolyPolygon.append(aPolygon);
75
76 const attribute::LineAttribute aLineAttribute(maStrokeColor, 1.0);
77
78 // create data
79 const Primitive2DReference aStroke(
80 new PolyPolygonStrokePrimitive2D(aPolyPolygon, aLineAttribute));
81
82 // create fill primitive
83 const Primitive2DReference aFill(
84 new PolyPolygonColorPrimitive2D(aPolyPolygon, maFillColor));
85
86 aPrimitive2DSequence = Primitive2DContainer(2);
87 aPrimitive2DSequence[0] = aFill;
88 aPrimitive2DSequence[1] = aStroke;
89
90 // embed filled to transparency (if used)
91 if (mfTransparence > 0.0)
92 {
93 const Primitive2DReference aFillTransparent(
95 std::move(aPrimitive2DSequence),
97
98 aPrimitive2DSequence = Primitive2DContainer { aFillTransparent };
99 }
100 }
101
102 rContainer.append(std::move(aPrimitive2DSequence));
103}
104
106{
107 if (DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
108 {
109 const OverlayStaticRectanglePrimitive& rCompare = static_cast<const OverlayStaticRectanglePrimitive&>(rPrimitive);
110
111 return (maPosition == rCompare.maPosition
112 && maSize == rCompare.maSize
113 && maStrokeColor == rCompare.maStrokeColor
114 && maFillColor == rCompare.maFillColor
115 && mfTransparence == rCompare.mfTransparence
116 && mfRotation == rCompare.mfRotation);
117 }
118
119 return false;
120}
121
123{
125}
126
127
128
130 const BitmapEx& rBitmapEx,
131 const basegfx::B2DPoint& rBasePosition,
132 sal_uInt16 nCenterX,
133 sal_uInt16 nCenterY,
134 double fShearX,
135 double fRotation)
136 : maBitmapEx(rBitmapEx),
137 maBasePosition(rBasePosition),
138 mnCenterX(nCenterX),
139 mnCenterY(nCenterY),
140 mfShearX(fShearX),
141 mfRotation(fRotation)
142 {}
143
145 {
146 const Size aBitmapSize(getBitmapEx().GetSizePixel());
147
148 if(!aBitmapSize.Width() || !aBitmapSize.Height() || !basegfx::fTools::more(getDiscreteUnit(), 0.0))
149 return;
150
151 // calculate back from internal bitmap's extreme coordinates (the edges)
152 // to logical coordinates. Only use a unified scaling value (getDiscreteUnit(),
153 // the prepared one which expresses how many logic units form a discrete unit)
154 // for this step. This primitive is to be displayed always unscaled (in its pixel size)
155 // and unrotated, more like a marker
156 const double fLeft((0.0 - getCenterX()) * getDiscreteUnit());
157 const double fTop((0.0 - getCenterY()) * getDiscreteUnit());
158 const double fRight((aBitmapSize.getWidth() - getCenterX()) * getDiscreteUnit());
159 const double fBottom((aBitmapSize.getHeight() - getCenterY()) * getDiscreteUnit());
160
161 // create a BitmapPrimitive2D using those positions
162 basegfx::B2DHomMatrix aTransform;
163
164 aTransform.set(0, 0, fRight - fLeft);
165 aTransform.set(1, 1, fBottom - fTop);
166 aTransform.set(0, 2, fLeft);
167 aTransform.set(1, 2, fTop);
168
169 // if shearX is used, apply it, too
171 {
172 aTransform.shearX(getShearX());
173 }
174
175 // if rotation is used, apply it, too
177 {
178 aTransform.rotate(getRotation());
179 }
180
181 // add BasePosition
182 aTransform.translate(getBasePosition().getX(), getBasePosition().getY());
183
184 rContainer.push_back(
187 aTransform));
188 }
189
191 {
192 if(DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
193 {
194 const OverlayBitmapExPrimitive& rCompare = static_cast< const OverlayBitmapExPrimitive& >(rPrimitive);
195
196 return (getBitmapEx() == rCompare.getBitmapEx()
197 && getBasePosition() == rCompare.getBasePosition()
198 && getCenterX() == rCompare.getCenterX()
199 && getCenterY() == rCompare.getCenterY()
200 && getShearX() == rCompare.getShearX()
201 && getRotation() == rCompare.getRotation());
202 }
203
204 return false;
205 }
206
208 {
210 }
211
212
213
215 const basegfx::B2DPoint& rBasePosition,
216 const basegfx::BColor& rRGBColorA,
217 const basegfx::BColor& rRGBColorB,
218 double fDiscreteDashLength)
219 : maBasePosition(rBasePosition),
220 maRGBColorA(rRGBColorA),
221 maRGBColorB(rRGBColorB),
222 mfDiscreteDashLength(fDiscreteDashLength)
223 {}
224
226 {
227 // use the prepared Viewport information accessible using getViewport()
228
229 if(getViewport().isEmpty())
230 return;
231
232 basegfx::B2DPolygon aPolygon;
233
234 aPolygon.append(basegfx::B2DPoint(getViewport().getMinX(), getBasePosition().getY()));
235 aPolygon.append(basegfx::B2DPoint(getViewport().getMaxX(), getBasePosition().getY()));
236
237 rContainer.push_back(
239 std::move(aPolygon),
240 getRGBColorA(),
241 getRGBColorB(),
243
244 aPolygon.clear();
245 aPolygon.append(basegfx::B2DPoint(getBasePosition().getX(), getViewport().getMinY()));
246 aPolygon.append(basegfx::B2DPoint(getBasePosition().getX(), getViewport().getMaxY()));
247
248 rContainer.push_back(
250 std::move(aPolygon),
251 getRGBColorA(),
252 getRGBColorB(),
254 }
255
257 {
258 if(ViewportDependentPrimitive2D::operator==(rPrimitive))
259 {
260 const OverlayCrosshairPrimitive& rCompare = static_cast< const OverlayCrosshairPrimitive& >(rPrimitive);
261
262 return (getBasePosition() == rCompare.getBasePosition()
263 && getRGBColorA() == rCompare.getRGBColorA()
264 && getRGBColorB() == rCompare.getRGBColorB()
266 }
267
268 return false;
269 }
270
272 {
274 }
275
276
277
279 const basegfx::B2DRange& rObjectRange,
280 const basegfx::BColor& rColor,
281 double fTransparence,
282 double fDiscreteGrow,
283 double fDiscreteShrink,
284 double fRotation)
285 : maObjectRange(rObjectRange),
286 maColor(rColor),
287 mfTransparence(fTransparence),
288 mfDiscreteGrow(fDiscreteGrow),
289 mfDiscreteShrink(fDiscreteShrink),
290 mfRotation(fRotation)
291 {}
292
294 {
295 Primitive2DContainer aRetval;
296 basegfx::B2DRange aInnerRange(getObjectRange());
297
298 if(!aInnerRange.isEmpty() && basegfx::fTools::more(getDiscreteUnit(), 0.0) && getTransparence() <= 1.0)
299 {
300 basegfx::B2DRange aOuterRange(getObjectRange());
301
302 // grow/shrink inner/outer polygons
303 aOuterRange.grow(getDiscreteUnit() * getDiscreteGrow());
304 aInnerRange.grow(getDiscreteUnit() * -getDiscreteShrink());
305
306 // convert to polygons
307 const double fFullGrow(getDiscreteGrow() + getDiscreteShrink());
308 const double fRelativeRadiusX(fFullGrow / aOuterRange.getWidth());
309 const double fRelativeRadiusY(fFullGrow / aOuterRange.getHeight());
310 basegfx::B2DPolygon aOuterPolygon(
312 aOuterRange,
313 fRelativeRadiusX,
314 fRelativeRadiusY));
315 basegfx::B2DPolygon aInnerPolygon(
317 aInnerRange));
318
319 // apply evtl. existing rotation
321 {
323 getObjectRange().getMinX(), getObjectRange().getMinY(), getRotation()));
324
325 aOuterPolygon.transform(aTransform);
326 aInnerPolygon.transform(aTransform);
327 }
328
329 // create filled primitive
330 basegfx::B2DPolyPolygon aPolyPolygon;
331
332 aPolyPolygon.append(aOuterPolygon);
333 aPolyPolygon.append(aInnerPolygon);
334
335 if(Application::GetSettings().GetStyleSettings().GetHighContrastMode())
336 {
337 // for high contrast, use hatch
338 const basegfx::BColor aHighContrastLineColor(Application::GetSettings().GetStyleSettings().GetFontColor().getBColor());
339 const basegfx::BColor aEmptyColor(0.0, 0.0, 0.0);
340 const double fHatchRotation(basegfx::deg2rad(45));
341 const double fDiscreteHatchDistance(3.0);
344 fDiscreteHatchDistance * getDiscreteUnit(),
345 fHatchRotation - getRotation(),
346 aHighContrastLineColor,
347 3, // same default as VCL, a minimum of three discrete units (pixels) offset
348 false);
349 const Primitive2DReference aHatch(
351 aPolyPolygon,
352 aEmptyColor,
353 std::move(aFillHatchAttribute)));
354
355 aRetval = Primitive2DContainer { aHatch };
356 }
357 else
358 {
359 // create fill primitive
360 const Primitive2DReference aFill(
362 std::move(aPolyPolygon),
363 getColor()));
364
365 aRetval = Primitive2DContainer { aFill };
366
367 // embed filled to transparency (if used)
368 if(getTransparence() > 0.0)
369 {
370 Primitive2DReference aFillTransparent(
372 std::move(aRetval),
373 getTransparence()));
374
375 aRetval = Primitive2DContainer { aFillTransparent };
376 }
377 }
378 }
379
380 rContainer.append(std::move(aRetval));
381 }
382
384 {
385 if(DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
386 {
387 const OverlayRectanglePrimitive& rCompare = static_cast< const OverlayRectanglePrimitive& >(rPrimitive);
388
389 return (getObjectRange() == rCompare.getObjectRange()
390 && getColor() == rCompare.getColor()
391 && getTransparence() == rCompare.getTransparence()
392 && getDiscreteGrow() == rCompare.getDiscreteGrow()
393 && getDiscreteShrink() == rCompare.getDiscreteShrink()
394 && getRotation() == rCompare.getRotation());
395 }
396
397 return false;
398 }
399
401 {
403 }
404
405
406
408 const basegfx::B2DPoint& rBasePosition,
409 HelplineStyle eStyle,
410 const basegfx::BColor& rRGBColorA,
411 const basegfx::BColor& rRGBColorB,
412 double fDiscreteDashLength)
413 : maBasePosition(rBasePosition),
414 meStyle(eStyle),
415 maRGBColorA(rRGBColorA),
416 maRGBColorB(rRGBColorB),
417 mfDiscreteDashLength(fDiscreteDashLength)
418 {}
419
421 {
422 // use the prepared Viewport information accessible using getViewport()
423
424 if(getViewport().isEmpty())
425 return;
426
427 switch(getStyle())
428 {
430 {
432
433 aLine.append(basegfx::B2DPoint(getBasePosition().getX(), getViewport().getMinY()));
434 aLine.append(basegfx::B2DPoint(getBasePosition().getX(), getViewport().getMaxY()));
435
436 rContainer.push_back(
438 std::move(aLine),
439 getRGBColorA(),
440 getRGBColorB(),
442 break;
443 }
444
446 {
448
449 aLine.append(basegfx::B2DPoint(getViewport().getMinX(), getBasePosition().getY()));
450 aLine.append(basegfx::B2DPoint(getViewport().getMaxX(), getBasePosition().getY()));
451
452 rContainer.push_back(
454 std::move(aLine),
455 getRGBColorA(),
456 getRGBColorB(),
458 break;
459 }
460
461 default: // case HELPLINESTYLE_POINT :
462 {
463 const double fDiscreteUnit((rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 0.0)).getLength());
464 basegfx::B2DPolygon aLineA, aLineB;
465
466 aLineA.append(basegfx::B2DPoint(getBasePosition().getX(), getBasePosition().getY() - fDiscreteUnit));
467 aLineA.append(basegfx::B2DPoint(getBasePosition().getX(), getBasePosition().getY() + fDiscreteUnit));
468
469 rContainer.push_back(
471 std::move(aLineA),
472 getRGBColorA(),
473 getRGBColorB(),
475
476 aLineB.append(basegfx::B2DPoint(getBasePosition().getX() - fDiscreteUnit, getBasePosition().getY()));
477 aLineB.append(basegfx::B2DPoint(getBasePosition().getX() + fDiscreteUnit, getBasePosition().getY()));
478
479 rContainer.push_back(
481 std::move(aLineB),
482 getRGBColorA(),
483 getRGBColorB(),
485
486 break;
487 }
488 }
489 }
490
492 {
493 if(ViewportDependentPrimitive2D::operator==(rPrimitive))
494 {
495 const OverlayHelplineStripedPrimitive& rCompare = static_cast< const OverlayHelplineStripedPrimitive& >(rPrimitive);
496
497 return (getBasePosition() == rCompare.getBasePosition()
498 && getStyle() == rCompare.getStyle()
499 && getRGBColorA() == rCompare.getRGBColorA()
500 && getRGBColorB() == rCompare.getRGBColorB()
502 }
503
504 return false;
505 }
506
508 {
510 }
511
512
513
515 const basegfx::B2DRange& aRollingRectangle,
516 const basegfx::BColor& rRGBColorA,
517 const basegfx::BColor& rRGBColorB,
518 double fDiscreteDashLength)
519 : maRollingRectangle(aRollingRectangle),
520 maRGBColorA(rRGBColorA),
521 maRGBColorB(rRGBColorB),
522 mfDiscreteDashLength(fDiscreteDashLength)
523 {}
524
526 {
527 // use the prepared Viewport information accessible using getViewport()
528
529 if(getViewport().isEmpty())
530 return;
531
532
533 // Left lines
534 basegfx::B2DPolygon aLine1;
535 aLine1.append(basegfx::B2DPoint(getViewport().getMinX(), getRollingRectangle().getMinY()));
536 aLine1.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getRollingRectangle().getMinY()));
537 rContainer.push_back(new PolygonMarkerPrimitive2D(std::move(aLine1), getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
538
539 basegfx::B2DPolygon aLine2;
540 aLine2.append(basegfx::B2DPoint(getViewport().getMinX(), getRollingRectangle().getMaxY()));
541 aLine2.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getRollingRectangle().getMaxY()));
542 rContainer.push_back(new PolygonMarkerPrimitive2D(std::move(aLine2), getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
543
544 // Right lines
545 basegfx::B2DPolygon aLine3;
546 aLine3.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getRollingRectangle().getMinY()));
547 aLine3.append(basegfx::B2DPoint(getViewport().getMaxX(), getRollingRectangle().getMinY()));
548 rContainer.push_back(new PolygonMarkerPrimitive2D(std::move(aLine3), getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
549
550 basegfx::B2DPolygon aLine4;
551 aLine4.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getRollingRectangle().getMaxY()));
552 aLine4.append(basegfx::B2DPoint(getViewport().getMaxX(), getRollingRectangle().getMaxY()));
553 rContainer.push_back(new PolygonMarkerPrimitive2D(std::move(aLine4), getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
554
555 // Top lines
556 basegfx::B2DPolygon aLine5;
557 aLine5.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getViewport().getMinY()));
558 aLine5.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getRollingRectangle().getMinY()));
559 rContainer.push_back(new PolygonMarkerPrimitive2D(std::move(aLine5), getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
560
561 basegfx::B2DPolygon aLine6;
562 aLine6.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getViewport().getMinY()));
563 aLine6.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getRollingRectangle().getMinY()));
564 rContainer.push_back(new PolygonMarkerPrimitive2D(std::move(aLine6), getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
565
566 // Bottom lines
567 basegfx::B2DPolygon aLine7;
568 aLine7.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getRollingRectangle().getMaxY()));
569 aLine7.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getViewport().getMaxY()));
570 rContainer.push_back(new PolygonMarkerPrimitive2D(std::move(aLine7), getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
571
572 basegfx::B2DPolygon aLine8;
573 aLine8.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getRollingRectangle().getMaxY()));
574 aLine8.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getViewport().getMaxY()));
575 rContainer.push_back(new PolygonMarkerPrimitive2D(std::move(aLine8), getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
576
577 }
578
580 {
581 if(ViewportDependentPrimitive2D::operator==(rPrimitive))
582 {
583 const OverlayRollingRectanglePrimitive& rCompare = static_cast< const OverlayRollingRectanglePrimitive& >(rPrimitive);
584
585 return (getRollingRectangle() == rCompare.getRollingRectangle()
586 && getRGBColorA() == rCompare.getRGBColorA()
587 && getRGBColorB() == rCompare.getRGBColorB()
589 }
590
591 return false;
592 }
593
595 {
597 }
598
599} // end of namespace
600
601/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
basegfx::BColor maColor
geometry::RealPoint2D maPosition
basegfx::B2DPoint maBasePosition
static const AllSettings & GetSettings()
constexpr tools::Long getHeight() const
constexpr tools::Long Height() const
constexpr tools::Long getWidth() const
constexpr tools::Long Width() const
static css::uno::Reference< css::awt::XBitmap > CreateVCLXBitmap(const BitmapEx &rBitmap)
void shearX(double fSx)
void set(sal_uInt16 nRow, sal_uInt16 nColumn, double fValue)
void rotate(double fRadiant)
void translate(double fX, double fY)
void append(const B2DPolygon &rPolygon, sal_uInt32 nCount=1)
void transform(const basegfx::B2DHomMatrix &rMatrix)
void append(const basegfx::B2DPoint &rPoint, sal_uInt32 nCount)
void grow(TYPE fValue)
TYPE getWidth() const
bool isEmpty() const
TYPE getHeight() const
TYPE getX() const
TYPE getY() const
const basegfx::B2DHomMatrix & getInverseObjectToViewTransformation() const
virtual void create2DDecomposition(Primitive2DContainer &rContainer, const geometry::ViewInformation2D &rViewInformation) const override
virtual sal_uInt32 getPrimitive2DID() const override
virtual bool operator==(const BasePrimitive2D &rPrimitive) const override
const basegfx::B2DPoint & getBasePosition() const
OverlayBitmapExPrimitive(const BitmapEx &rBitmapEx, const basegfx::B2DPoint &rBasePosition, sal_uInt16 nCenterX, sal_uInt16 nCenterY, double fShearX, double fRotation)
virtual bool operator==(const BasePrimitive2D &rPrimitive) const override
virtual sal_uInt32 getPrimitive2DID() const override
const basegfx::B2DPoint & getBasePosition() const
OverlayCrosshairPrimitive(const basegfx::B2DPoint &rBasePosition, const basegfx::BColor &rRGBColorA, const basegfx::BColor &rRGBColorB, double fDiscreteDashLength)
virtual void create2DDecomposition(Primitive2DContainer &rContainer, const geometry::ViewInformation2D &rViewInformation) const override
virtual void create2DDecomposition(Primitive2DContainer &rContainer, const geometry::ViewInformation2D &rViewInformation) const override
virtual sal_uInt32 getPrimitive2DID() const override
OverlayHelplineStripedPrimitive(const basegfx::B2DPoint &rBasePosition, HelplineStyle eStyle, const basegfx::BColor &rRGBColorA, const basegfx::BColor &rRGBColorB, double fDiscreteDashLength)
virtual bool operator==(const BasePrimitive2D &rPrimitive) const override
virtual sal_uInt32 getPrimitive2DID() const override
virtual void create2DDecomposition(Primitive2DContainer &rContainer, const geometry::ViewInformation2D &rViewInformation) const override
OverlayRectanglePrimitive(const basegfx::B2DRange &rObjectRange, const basegfx::BColor &rColor, double fTransparence, double fDiscreteGrow, double fDiscreteShrink, double fRotation)
virtual bool operator==(const BasePrimitive2D &rPrimitive) const override
const basegfx::B2DRange & getObjectRange() const
virtual bool operator==(const BasePrimitive2D &rPrimitive) const override
virtual void create2DDecomposition(Primitive2DContainer &rContainer, const geometry::ViewInformation2D &rViewInformation) const override
OverlayRollingRectanglePrimitive(const basegfx::B2DRange &aRollingRectangle, const basegfx::BColor &rRGBColorA, const basegfx::BColor &rRGBColorB, double fDiscreteDashLength)
virtual sal_uInt32 getPrimitive2DID() const override
virtual bool operator==(const BasePrimitive2D &rPrimitive) const override
OverlayStaticRectanglePrimitive(const basegfx::B2DPoint &rPosition, const basegfx::B2DSize &rSize, const basegfx::BColor &rStrokeColor, const basegfx::BColor &rFillColor, double fTransparence, double fRotation)
virtual void create2DDecomposition(Primitive2DContainer &rContainer, const geometry::ViewInformation2D &rViewInformation) const override
void append(const Primitive2DReference &)
::basegfx::B2IVector maSize
Color GetFontColor()
Definition: svdetc.hxx:68
bool more(const T &rfValA, const T &rfValB)
bool equalZero(const T &rfVal)
B2DPolygon createPolygonFromRect(const B2DRectangle &rRect, double fRadiusX, double fRadiusY)
B2DHomMatrix createRotateAroundPoint(double fPointX, double fPointY, double fRadiant)
constexpr double deg2rad(double v)
uno::Sequence< double > maFillColor
#define PRIMITIVE2D_ID_OVERLAYROLLINGRECTANGLEPRIMITIVE
#define PRIMITIVE2D_ID_OVERLAYRECTANGLEPRIMITIVE
#define PRIMITIVE2D_ID_OVERLAYCROSSHAIRPRIMITIVE
#define PRIMITIVE2D_ID_OVERLAYBITMAPEXPRIMITIVE
#define PRIMITIVE2D_ID_OVERLAYHELPLINESTRIPEDPRIMITIVE