svx/source/sdr/overlay/overlaytools.cxx

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