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
35#include <vcl/svapp.hxx>
36#include <vcl/settings.hxx>
38
39
41{
42
44 const basegfx::B2DPoint& rPosition,
45 const basegfx::B2DSize& rSize,
46 const basegfx::BColor& rStrokeColor,
47 const basegfx::BColor& rFillColor,
48 double fTransparence,
49 double fRotation)
50 : maPosition(rPosition)
51 , maSize(rSize)
52 , maStrokeColor(rStrokeColor)
53 , maFillColor(rFillColor)
54 , mfTransparence(fTransparence)
55 , mfRotation(fRotation)
56{}
57
59{
60 Primitive2DContainer aPrimitive2DSequence;
61 const double fHalfWidth = maSize.getWidth() * getDiscreteUnit() / 2.0;
62 const double fHalfHeight = maSize.getHeight() * getDiscreteUnit() / 2.0;
63
64 basegfx::B2DRange aRange(
65 maPosition.getX() - fHalfWidth, maPosition.getY() - fHalfHeight,
66 maPosition.getX() + fHalfWidth, maPosition.getY() + fHalfHeight);
67
69 {
70 basegfx::B2DPolygon aPolygon(
72
73 // create filled primitive
74 basegfx::B2DPolyPolygon aPolyPolygon;
75 aPolyPolygon.append(aPolygon);
76
77 const attribute::LineAttribute aLineAttribute(maStrokeColor, 1.0);
78
79 // create data
80 const Primitive2DReference aStroke(
81 new PolyPolygonStrokePrimitive2D(aPolyPolygon, aLineAttribute));
82
83 // create fill primitive
84 const Primitive2DReference aFill(
85 new PolyPolygonColorPrimitive2D(std::move(aPolyPolygon), maFillColor));
86
87 aPrimitive2DSequence = Primitive2DContainer(2);
88 aPrimitive2DSequence[0] = aFill;
89 aPrimitive2DSequence[1] = aStroke;
90
91 // embed filled to transparency (if used)
92 if (mfTransparence > 0.0)
93 {
94 const Primitive2DReference aFillTransparent(
96 std::move(aPrimitive2DSequence),
98
99 aPrimitive2DSequence = Primitive2DContainer { aFillTransparent };
100 }
101 }
102
103 rContainer.append(std::move(aPrimitive2DSequence));
104}
105
107{
108 if (DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
109 {
110 const OverlayStaticRectanglePrimitive& rCompare = static_cast<const OverlayStaticRectanglePrimitive&>(rPrimitive);
111
112 return (maPosition == rCompare.maPosition
113 && maSize == rCompare.maSize
114 && maStrokeColor == rCompare.maStrokeColor
115 && maFillColor == rCompare.maFillColor
116 && mfTransparence == rCompare.mfTransparence
117 && mfRotation == rCompare.mfRotation);
118 }
119
120 return false;
121}
122
124{
126}
127
128
129
131 const BitmapEx& rBitmapEx,
132 const basegfx::B2DPoint& rBasePosition,
133 sal_uInt16 nCenterX,
134 sal_uInt16 nCenterY,
135 double fShearX,
136 double fRotation)
137 : maBitmapEx(rBitmapEx),
138 maBasePosition(rBasePosition),
139 mnCenterX(nCenterX),
140 mnCenterY(nCenterY),
141 mfShearX(fShearX),
142 mfRotation(fRotation)
143 {}
144
146 {
147 const Size aBitmapSize(getBitmapEx().GetSizePixel());
148
149 if(!aBitmapSize.Width() || !aBitmapSize.Height() || !basegfx::fTools::more(getDiscreteUnit(), 0.0))
150 return;
151
152 // calculate back from internal bitmap's extreme coordinates (the edges)
153 // to logical coordinates. Only use a unified scaling value (getDiscreteUnit(),
154 // the prepared one which expresses how many logic units form a discrete unit)
155 // for this step. This primitive is to be displayed always unscaled (in its pixel size)
156 // and unrotated, more like a marker
157 const double fLeft((0.0 - getCenterX()) * getDiscreteUnit());
158 const double fTop((0.0 - getCenterY()) * getDiscreteUnit());
159 const double fRight((aBitmapSize.getWidth() - getCenterX()) * getDiscreteUnit());
160 const double fBottom((aBitmapSize.getHeight() - getCenterY()) * getDiscreteUnit());
161
162 // create a BitmapPrimitive2D using those positions
163 basegfx::B2DHomMatrix aTransform;
164
165 aTransform.set(0, 0, fRight - fLeft);
166 aTransform.set(1, 1, fBottom - fTop);
167 aTransform.set(0, 2, fLeft);
168 aTransform.set(1, 2, fTop);
169
170 // if shearX is used, apply it, too
172 {
173 aTransform.shearX(getShearX());
174 }
175
176 // if rotation is used, apply it, too
178 {
179 aTransform.rotate(getRotation());
180 }
181
182 // add BasePosition
183 aTransform.translate(getBasePosition().getX(), getBasePosition().getY());
184
185 rContainer.push_back(
187 getBitmapEx(),
188 aTransform));
189 }
190
192 {
193 if(DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
194 {
195 const OverlayBitmapExPrimitive& rCompare = static_cast< const OverlayBitmapExPrimitive& >(rPrimitive);
196
197 return (getBitmapEx() == rCompare.getBitmapEx()
198 && getBasePosition() == rCompare.getBasePosition()
199 && getCenterX() == rCompare.getCenterX()
200 && getCenterY() == rCompare.getCenterY()
201 && getShearX() == rCompare.getShearX()
202 && getRotation() == rCompare.getRotation());
203 }
204
205 return false;
206 }
207
209 {
211 }
212
213
214
216 const basegfx::B2DPoint& rBasePosition,
217 const basegfx::BColor& rRGBColorA,
218 const basegfx::BColor& rRGBColorB,
219 double fDiscreteDashLength)
220 : maBasePosition(rBasePosition),
221 maRGBColorA(rRGBColorA),
222 maRGBColorB(rRGBColorB),
223 mfDiscreteDashLength(fDiscreteDashLength)
224 {}
225
227 {
228 // use the prepared Viewport information accessible using getViewport()
229
230 if(getViewport().isEmpty())
231 return;
232
233 basegfx::B2DPolygon aPolygon;
234
235 aPolygon.append(basegfx::B2DPoint(getViewport().getMinX(), getBasePosition().getY()));
236 aPolygon.append(basegfx::B2DPoint(getViewport().getMaxX(), getBasePosition().getY()));
237
238 rContainer.push_back(
240 aPolygon,
241 getRGBColorA(),
242 getRGBColorB(),
244
245 aPolygon.clear();
246 aPolygon.append(basegfx::B2DPoint(getBasePosition().getX(), getViewport().getMinY()));
247 aPolygon.append(basegfx::B2DPoint(getBasePosition().getX(), getViewport().getMaxY()));
248
249 rContainer.push_back(
251 std::move(aPolygon),
252 getRGBColorA(),
253 getRGBColorB(),
255 }
256
258 {
259 if(ViewportDependentPrimitive2D::operator==(rPrimitive))
260 {
261 const OverlayCrosshairPrimitive& rCompare = static_cast< const OverlayCrosshairPrimitive& >(rPrimitive);
262
263 return (getBasePosition() == rCompare.getBasePosition()
264 && getRGBColorA() == rCompare.getRGBColorA()
265 && getRGBColorB() == rCompare.getRGBColorB()
267 }
268
269 return false;
270 }
271
273 {
275 }
276
277
278
280 const basegfx::B2DRange& rObjectRange,
281 const basegfx::BColor& rColor,
282 double fTransparence,
283 double fDiscreteGrow,
284 double fDiscreteShrink,
285 double fRotation)
286 : maObjectRange(rObjectRange),
287 maColor(rColor),
288 mfTransparence(fTransparence),
289 mfDiscreteGrow(fDiscreteGrow),
290 mfDiscreteShrink(fDiscreteShrink),
291 mfRotation(fRotation)
292 {}
293
295 {
296 Primitive2DContainer aRetval;
297 basegfx::B2DRange aInnerRange(getObjectRange());
298
299 if(!aInnerRange.isEmpty() && basegfx::fTools::more(getDiscreteUnit(), 0.0) && getTransparence() <= 1.0)
300 {
301 if (!Application::GetSettings().GetStyleSettings().GetHighContrastMode())
302 {
303 basegfx::B2DRange aOuterRange(aInnerRange);
304 // grow/shrink inner/outer polygons
305 aOuterRange.grow(getDiscreteUnit() * getDiscreteGrow());
306 aInnerRange.grow(getDiscreteUnit() * -getDiscreteShrink());
307
308 // convert to polygons
309 const double fFullGrow(getDiscreteGrow() + getDiscreteShrink());
310 const double fRelativeRadiusX(fFullGrow / aOuterRange.getWidth());
311 const double fRelativeRadiusY(fFullGrow / aOuterRange.getHeight());
312 basegfx::B2DPolygon aOuterPolygon(
314 aOuterRange,
315 fRelativeRadiusX,
316 fRelativeRadiusY));
317 basegfx::B2DPolygon aInnerPolygon(
319 aInnerRange));
320
321 // apply evtl. existing rotation
323 {
325 getObjectRange().getMinX(), getObjectRange().getMinY(), getRotation()));
326
327 aOuterPolygon.transform(aTransform);
328 aInnerPolygon.transform(aTransform);
329 }
330
331 // create filled primitive
332 basegfx::B2DPolyPolygon aPolyPolygon;
333
334 aPolyPolygon.append(aOuterPolygon);
335 aPolyPolygon.append(aInnerPolygon);
336
337 // create fill primitive
338 const Primitive2DReference aFill(
340 std::move(aPolyPolygon),
341 getColor()));
342
343 aRetval = Primitive2DContainer { aFill };
344
345 // embed filled to transparency (if used)
346 if(getTransparence() > 0.0)
347 {
348 Primitive2DReference aFillTransparent(
350 std::move(aRetval),
351 getTransparence()));
352
353 aRetval = Primitive2DContainer { aFillTransparent };
354 }
355 }
356 else
357 {
358 basegfx::B2DPolygon aInnerPolygon(
360 aInnerRange));
361
362 // apply evtl. existing rotation
364 {
366 getObjectRange().getMinX(), getObjectRange().getMinY(), getRotation()));
367
368 aInnerPolygon.transform(aTransform);
369 }
370
371 // for high contrast, use a thick stroke
372 const basegfx::BColor aHighContrastLineColor(Application::GetSettings().GetStyleSettings().GetHighlightColor().getBColor());
373 const attribute::LineAttribute aLineAttribute(aHighContrastLineColor, getDiscreteUnit() * getDiscreteGrow());
374
375 const Primitive2DReference aStroke(new PolygonStrokePrimitive2D(aInnerPolygon, aLineAttribute));
376
377 aRetval = Primitive2DContainer { aStroke };
378 }
379 }
380
381 rContainer.append(std::move(aRetval));
382 }
383
385 {
386 if(DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
387 {
388 const OverlayRectanglePrimitive& rCompare = static_cast< const OverlayRectanglePrimitive& >(rPrimitive);
389
390 return (getObjectRange() == rCompare.getObjectRange()
391 && getColor() == rCompare.getColor()
392 && getTransparence() == rCompare.getTransparence()
393 && getDiscreteGrow() == rCompare.getDiscreteGrow()
394 && getDiscreteShrink() == rCompare.getDiscreteShrink()
395 && getRotation() == rCompare.getRotation());
396 }
397
398 return false;
399 }
400
402 {
404 }
405
406
407
409 const basegfx::B2DPoint& rBasePosition,
410 HelplineStyle eStyle,
411 const basegfx::BColor& rRGBColorA,
412 const basegfx::BColor& rRGBColorB,
413 double fDiscreteDashLength)
414 : maBasePosition(rBasePosition),
415 meStyle(eStyle),
416 maRGBColorA(rRGBColorA),
417 maRGBColorB(rRGBColorB),
418 mfDiscreteDashLength(fDiscreteDashLength)
419 {}
420
422 {
423 // use the prepared Viewport information accessible using getViewport()
424
425 if(getViewport().isEmpty())
426 return;
427
428 switch(getStyle())
429 {
431 {
433
434 aLine.append(basegfx::B2DPoint(getBasePosition().getX(), getViewport().getMinY()));
435 aLine.append(basegfx::B2DPoint(getBasePosition().getX(), getViewport().getMaxY()));
436
437 rContainer.push_back(
439 std::move(aLine),
440 getRGBColorA(),
441 getRGBColorB(),
443 break;
444 }
445
447 {
449
450 aLine.append(basegfx::B2DPoint(getViewport().getMinX(), getBasePosition().getY()));
451 aLine.append(basegfx::B2DPoint(getViewport().getMaxX(), getBasePosition().getY()));
452
453 rContainer.push_back(
455 std::move(aLine),
456 getRGBColorA(),
457 getRGBColorB(),
459 break;
460 }
461
462 default: // case HELPLINESTYLE_POINT :
463 {
464 const double fDiscreteUnit((rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 0.0)).getLength());
465 basegfx::B2DPolygon aLineA, aLineB;
466
467 aLineA.append(basegfx::B2DPoint(getBasePosition().getX(), getBasePosition().getY() - fDiscreteUnit));
468 aLineA.append(basegfx::B2DPoint(getBasePosition().getX(), getBasePosition().getY() + fDiscreteUnit));
469
470 rContainer.push_back(
472 std::move(aLineA),
473 getRGBColorA(),
474 getRGBColorB(),
476
477 aLineB.append(basegfx::B2DPoint(getBasePosition().getX() - fDiscreteUnit, getBasePosition().getY()));
478 aLineB.append(basegfx::B2DPoint(getBasePosition().getX() + fDiscreteUnit, getBasePosition().getY()));
479
480 rContainer.push_back(
482 std::move(aLineB),
483 getRGBColorA(),
484 getRGBColorB(),
486
487 break;
488 }
489 }
490 }
491
493 {
494 if(ViewportDependentPrimitive2D::operator==(rPrimitive))
495 {
496 const OverlayHelplineStripedPrimitive& rCompare = static_cast< const OverlayHelplineStripedPrimitive& >(rPrimitive);
497
498 return (getBasePosition() == rCompare.getBasePosition()
499 && getStyle() == rCompare.getStyle()
500 && getRGBColorA() == rCompare.getRGBColorA()
501 && getRGBColorB() == rCompare.getRGBColorB()
503 }
504
505 return false;
506 }
507
509 {
511 }
512
513
514
516 const basegfx::B2DRange& aRollingRectangle,
517 const basegfx::BColor& rRGBColorA,
518 const basegfx::BColor& rRGBColorB,
519 double fDiscreteDashLength)
520 : maRollingRectangle(aRollingRectangle),
521 maRGBColorA(rRGBColorA),
522 maRGBColorB(rRGBColorB),
523 mfDiscreteDashLength(fDiscreteDashLength)
524 {}
525
527 {
528 // use the prepared Viewport information accessible using getViewport()
529
530 if(getViewport().isEmpty())
531 return;
532
533
534 // Left lines
535 basegfx::B2DPolygon aLine1;
536 aLine1.append(basegfx::B2DPoint(getViewport().getMinX(), getRollingRectangle().getMinY()));
537 aLine1.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getRollingRectangle().getMinY()));
538 rContainer.push_back(new PolygonMarkerPrimitive2D(std::move(aLine1), getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
539
540 basegfx::B2DPolygon aLine2;
541 aLine2.append(basegfx::B2DPoint(getViewport().getMinX(), getRollingRectangle().getMaxY()));
542 aLine2.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getRollingRectangle().getMaxY()));
543 rContainer.push_back(new PolygonMarkerPrimitive2D(std::move(aLine2), getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
544
545 // Right lines
546 basegfx::B2DPolygon aLine3;
547 aLine3.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getRollingRectangle().getMinY()));
548 aLine3.append(basegfx::B2DPoint(getViewport().getMaxX(), getRollingRectangle().getMinY()));
549 rContainer.push_back(new PolygonMarkerPrimitive2D(std::move(aLine3), getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
550
551 basegfx::B2DPolygon aLine4;
552 aLine4.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getRollingRectangle().getMaxY()));
553 aLine4.append(basegfx::B2DPoint(getViewport().getMaxX(), getRollingRectangle().getMaxY()));
554 rContainer.push_back(new PolygonMarkerPrimitive2D(std::move(aLine4), getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
555
556 // Top lines
557 basegfx::B2DPolygon aLine5;
558 aLine5.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getViewport().getMinY()));
559 aLine5.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getRollingRectangle().getMinY()));
560 rContainer.push_back(new PolygonMarkerPrimitive2D(std::move(aLine5), getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
561
562 basegfx::B2DPolygon aLine6;
563 aLine6.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getViewport().getMinY()));
564 aLine6.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getRollingRectangle().getMinY()));
565 rContainer.push_back(new PolygonMarkerPrimitive2D(std::move(aLine6), getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
566
567 // Bottom lines
568 basegfx::B2DPolygon aLine7;
569 aLine7.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getRollingRectangle().getMaxY()));
570 aLine7.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getViewport().getMaxY()));
571 rContainer.push_back(new PolygonMarkerPrimitive2D(std::move(aLine7), getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
572
573 basegfx::B2DPolygon aLine8;
574 aLine8.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getRollingRectangle().getMaxY()));
575 aLine8.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getViewport().getMaxY()));
576 rContainer.push_back(new PolygonMarkerPrimitive2D(std::move(aLine8), getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
577
578 }
579
581 {
582 if(ViewportDependentPrimitive2D::operator==(rPrimitive))
583 {
584 const OverlayRollingRectanglePrimitive& rCompare = static_cast< const OverlayRollingRectanglePrimitive& >(rPrimitive);
585
586 return (getRollingRectangle() == rCompare.getRollingRectangle()
587 && getRGBColorA() == rCompare.getRGBColorA()
588 && getRGBColorB() == rCompare.getRGBColorB()
590 }
591
592 return false;
593 }
594
596 {
598 }
599
600} // end of namespace
601
602/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
basegfx::BColor maColor
geometry::RealPoint2D maPosition
geometry::RealSize2D maSize
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
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 getWidth() 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 &)
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)
uno::Sequence< double > maFillColor
#define PRIMITIVE2D_ID_OVERLAYROLLINGRECTANGLEPRIMITIVE
#define PRIMITIVE2D_ID_OVERLAYRECTANGLEPRIMITIVE
#define PRIMITIVE2D_ID_OVERLAYCROSSHAIRPRIMITIVE
#define PRIMITIVE2D_ID_OVERLAYBITMAPEXPRIMITIVE
#define PRIMITIVE2D_ID_OVERLAYHELPLINESTRIPEDPRIMITIVE