drawinglayer/source/primitive2d/polygonprimitive2d.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile: polygonprimitive2d.cxx,v $
   6  *
   7  *  $Revision: 1.12 $
   8  *
   9  *  last change: $Author: aw $ $Date: 2008-05-27 14:11:20 $
  10  *
  11  *  The Contents of this file are made available subject to
  12  *  the terms of GNU Lesser General Public License Version 2.1.
  13  *
  14  *
  15  *    GNU Lesser General Public License Version 2.1
  16  *    =============================================
  17  *    Copyright 2005 by Sun Microsystems, Inc.
  18  *    901 San Antonio Road, Palo Alto, CA 94303, USA
  19  *
  20  *    This library is free software; you can redistribute it and/or
  21  *    modify it under the terms of the GNU Lesser General Public
  22  *    License version 2.1, as published by the Free Software Foundation.
  23  *
  24  *    This library is distributed in the hope that it will be useful,
  25  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  27  *    Lesser General Public License for more details.
  28  *
  29  *    You should have received a copy of the GNU Lesser General Public
  30  *    License along with this library; if not, write to the Free Software
  31  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  32  *    MA  02111-1307  USA
  33  *
  34  ************************************************************************/
  35
  36 // MARKER(update_precomp.py): autogen include statement, do not remove
  37 #include "precompiled_drawinglayer.hxx"
  38
  39 #include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
  40 #include <basegfx/tools/canvastools.hxx>
  41 #include <basegfx/polygon/b2dpolygontools.hxx>
  42 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  43 #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
  44 #include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
  45 #include <drawinglayer/geometry/viewinformation2d.hxx>
  46
  47 //////////////////////////////////////////////////////////////////////////////
  48
  49 using namespace com::sun::star;
  50
  51 //////////////////////////////////////////////////////////////////////////////
  52
  53 namespace drawinglayer
  54 {
  55     namespace primitive2d
  56     {
  57         PolygonHairlinePrimitive2D::PolygonHairlinePrimitive2D(
  58             const basegfx::B2DPolygon& rPolygon,
  59             const basegfx::BColor& rBColor)
  60         :       BasePrimitive2D(),
  61             maPolygon(rPolygon),
  62             maBColor(rBColor)
  63         {
  64         }
  65
  66         bool PolygonHairlinePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
  67         {
  68             if(BasePrimitive2D::operator==(rPrimitive))
  69             {
  70                 const PolygonHairlinePrimitive2D& rCompare = (PolygonHairlinePrimitive2D&)rPrimitive;
  71
  72                 return (getB2DPolygon() == rCompare.getB2DPolygon()
  73                     && getBColor() == rCompare.getBColor());
  74             }
  75
  76             return false;
  77         }
  78
  79         basegfx::B2DRange PolygonHairlinePrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
  80         {
  81             // this is a hairline, thus the line width is view-dependent. Get range of polygon
  82             // as base size
  83             basegfx::B2DRange aRetval(getB2DPolygon().getB2DRange());
  84
  85             if(!aRetval.isEmpty())
  86             {
  87                 // Calculate view-dependent hairline width
  88                 const basegfx::B2DVector aDiscreteSize(rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 0.0));
  89                 const double fDiscreteHalfLineWidth(aDiscreteSize.getLength() * 0.5);
  90
  91                 if(basegfx::fTools::more(fDiscreteHalfLineWidth, 0.0))
  92                 {
  93                     aRetval.grow(fDiscreteHalfLineWidth);
  94                 }
  95             }
  96
  97             // return range
  98             return aRetval;
  99         }
 100
 101         // provide unique ID
 102         ImplPrimitrive2DIDBlock(PolygonHairlinePrimitive2D, PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D)
 103
 104     } // end of namespace primitive2d
 105 } // end of namespace drawinglayer
 106
 107 //////////////////////////////////////////////////////////////////////////////
 108
 109 namespace drawinglayer
 110 {
 111     namespace primitive2d
 112     {
 113         Primitive2DSequence PolygonMarkerPrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& rViewInformation) const
 114         {
 115             // calculate logic DashLength
 116             const basegfx::B2DVector aDashVector(rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(getDiscreteDashLength(), 0.0));
 117             const double fLogicDashLength(aDashVector.getX());
 118
 119             if(fLogicDashLength > 0.0 && !getRGBColorA().equal(getRGBColorB()))
 120             {
 121                 // apply dashing; get line and gap snippets
 122                 ::std::vector< double > aDash;
 123                 basegfx::B2DPolyPolygon aDashedPolyPolyA;
 124                 basegfx::B2DPolyPolygon aDashedPolyPolyB;
 125
 126                 aDash.push_back(fLogicDashLength);
 127                 aDash.push_back(fLogicDashLength);
 128                 basegfx::tools::applyLineDashing(getB2DPolygon(), aDash, &aDashedPolyPolyA, &aDashedPolyPolyB, 2.0 * fLogicDashLength);
 129
 130                 // prepare return value
 131                 Primitive2DSequence aRetval(2);
 132
 133                 aRetval[0] = Primitive2DReference(new PolyPolygonHairlinePrimitive2D(aDashedPolyPolyA, getRGBColorA()));
 134                 aRetval[1] = Primitive2DReference(new PolyPolygonHairlinePrimitive2D(aDashedPolyPolyB, getRGBColorB()));
 135
 136                 return aRetval;
 137             }
 138             else
 139             {
 140                 const Primitive2DReference xRef(new PolygonHairlinePrimitive2D(getB2DPolygon(), getRGBColorA()));
 141                 return Primitive2DSequence(&xRef, 1L);
 142             }
 143         }
 144
 145         PolygonMarkerPrimitive2D::PolygonMarkerPrimitive2D(
 146             const basegfx::B2DPolygon& rPolygon,
 147             const basegfx::BColor& rRGBColorA,
 148             const basegfx::BColor& rRGBColorB,
 149             double fDiscreteDashLength)
 150         :       BasePrimitive2D(),
 151             maPolygon(rPolygon),
 152             maRGBColorA(rRGBColorA),
 153             maRGBColorB(rRGBColorB),
 154             mfDiscreteDashLength(fDiscreteDashLength),
 155             maLastInverseObjectToViewTransformation()
 156         {
 157         }
 158
 159         bool PolygonMarkerPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 160         {
 161             if(BasePrimitive2D::operator==(rPrimitive))
 162             {
 163                 const PolygonMarkerPrimitive2D& rCompare = (PolygonMarkerPrimitive2D&)rPrimitive;
 164
 165                 return (getB2DPolygon() == rCompare.getB2DPolygon()
 166                     && getRGBColorA() == rCompare.getRGBColorA()
 167                     && getRGBColorB() == rCompare.getRGBColorB()
 168                     && getDiscreteDashLength() == rCompare.getDiscreteDashLength());
 169             }
 170
 171             return false;
 172         }
 173
 174         basegfx::B2DRange PolygonMarkerPrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
 175         {
 176             // this is a hairline, thus the line width is view-dependent. Get range of polygon
 177             // as base size
 178             basegfx::B2DRange aRetval(getB2DPolygon().getB2DRange());
 179
 180             if(!aRetval.isEmpty())
 181             {
 182                 // Calculate view-dependent hairline width
 183                 const basegfx::B2DVector aDiscreteSize(rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 0.0));
 184                 const double fDiscreteHalfLineWidth(aDiscreteSize.getLength() * 0.5);
 185
 186                 if(basegfx::fTools::more(fDiscreteHalfLineWidth, 0.0))
 187                 {
 188                     aRetval.grow(fDiscreteHalfLineWidth);
 189                 }
 190             }
 191
 192             // return range
 193             return aRetval;
 194         }
 195
 196         Primitive2DSequence PolygonMarkerPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
 197         {
 198             ::osl::MutexGuard aGuard( m_aMutex );
 199             bool bNeedNewDecomposition(false);
 200
 201             if(getLocalDecomposition().hasElements())
 202             {
 203                 if(rViewInformation.getInverseObjectToViewTransformation() != maLastInverseObjectToViewTransformation)
 204                 {
 205                     bNeedNewDecomposition = true;
 206                 }
 207             }
 208
 209             if(bNeedNewDecomposition)
 210             {
 211                 // conditions of last local decomposition have changed, delete
 212                 const_cast< PolygonMarkerPrimitive2D* >(this)->setLocalDecomposition(Primitive2DSequence());
 213             }
 214
 215             if(!getLocalDecomposition().hasElements())
 216             {
 217                 // remember last used InverseObjectToViewTransformation
 218                 PolygonMarkerPrimitive2D* pThat = const_cast< PolygonMarkerPrimitive2D* >(this);
 219                 pThat->maLastInverseObjectToViewTransformation = rViewInformation.getInverseObjectToViewTransformation();
 220             }
 221
 222             // use parent implementation
 223             return BasePrimitive2D::get2DDecomposition(rViewInformation);
 224         }
 225
 226         // provide unique ID
 227         ImplPrimitrive2DIDBlock(PolygonMarkerPrimitive2D, PRIMITIVE2D_ID_POLYGONMARKERPRIMITIVE2D)
 228
 229     } // end of namespace primitive2d
 230 } // end of namespace drawinglayer
 231
 232 //////////////////////////////////////////////////////////////////////////////
 233
 234 namespace drawinglayer
 235 {
 236     namespace primitive2d
 237     {
 238         Primitive2DSequence PolygonStrokePrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
 239         {
 240             if(getB2DPolygon().count())
 241             {
 242                 // #i102241# try to simplify before usage
 243                 const basegfx::B2DPolygon aB2DPolygon(basegfx::tools::simplifyCurveSegments(getB2DPolygon()));
 244                 basegfx::B2DPolyPolygon aHairLinePolyPolygon;
 245
 246                 if(0.0 == getStrokeAttribute().getFullDotDashLen())
 247                 {
 248                     // no line dashing, just copy
 249                     aHairLinePolyPolygon.append(aB2DPolygon);
 250                 }
 251                 else
 252                 {
 253                     // apply LineStyle
 254                     basegfx::tools::applyLineDashing(aB2DPolygon, getStrokeAttribute().getDotDashArray(), &aHairLinePolyPolygon, 0, getStrokeAttribute().getFullDotDashLen());
 255                 }
 256
 257                 const sal_uInt32 nCount(aHairLinePolyPolygon.count());
 258
 259                 if(getLineAttribute().getWidth())
 260                 {
 261                     // create fat line data
 262                     const double fHalfLineWidth(getLineAttribute().getWidth() / 2.0);
 263                     const basegfx::B2DLineJoin aLineJoin(getLineAttribute().getLineJoin());
 264                     basegfx::B2DPolyPolygon aAreaPolyPolygon;
 265
 266                     for(sal_uInt32 a(0L); a < nCount; a++)
 267                     {
 268                         // New version of createAreaGeometry; now creates bezier polygons
 269                         aAreaPolyPolygon.append(basegfx::tools::createAreaGeometry(
 270                             aHairLinePolyPolygon.getB2DPolygon(a), fHalfLineWidth, aLineJoin));
 271                     }
 272
 273                     // prepare return value
 274                     Primitive2DSequence aRetval(aAreaPolyPolygon.count());
 275
 276                     // create primitive
 277                     for(sal_uInt32 b(0L); b < aAreaPolyPolygon.count(); b++)
 278                     {
 279                         // put into single polyPolygon primitives to make clear that this is NOT meant
 280                         // to be painted as a single PolyPolygon (XORed as fill rule). Alternatively, a
 281                         // melting process may be used here one day.
 282                         const basegfx::B2DPolyPolygon aNewPolyPolygon(aAreaPolyPolygon.getB2DPolygon(b));
 283                         static bool bTestByUsingRandomColor(false);
 284                         const basegfx::BColor aColor(bTestByUsingRandomColor
 285                             ? basegfx::BColor(rand() / 32767.0, rand() / 32767.0, rand() / 32767.0)
 286                             : getLineAttribute().getColor());
 287                         const Primitive2DReference xRef(new PolyPolygonColorPrimitive2D(aNewPolyPolygon, aColor));
 288                         aRetval[b] = xRef;
 289                     }
 290
 291                     return aRetval;
 292                 }
 293                 else
 294                 {
 295                     // prepare return value
 296                     const Primitive2DReference xRef(new PolyPolygonHairlinePrimitive2D(aHairLinePolyPolygon, getLineAttribute().getColor()));
 297                     return Primitive2DSequence(&xRef, 1);
 298                 }
 299             }
 300             else
 301             {
 302                 return Primitive2DSequence();
 303             }
 304         }
 305
 306         PolygonStrokePrimitive2D::PolygonStrokePrimitive2D(
 307             const basegfx::B2DPolygon& rPolygon,
 308             const attribute::LineAttribute& rLineAttribute,
 309             const attribute::StrokeAttribute& rStrokeAttribute)
 310         :       BasePrimitive2D(),
 311             maPolygon(rPolygon),
 312             maLineAttribute(rLineAttribute),
 313             maStrokeAttribute(rStrokeAttribute)
 314         {
 315         }
 316
 317         PolygonStrokePrimitive2D::PolygonStrokePrimitive2D(
 318             const basegfx::B2DPolygon& rPolygon,
 319             const attribute::LineAttribute& rLineAttribute)
 320         :       BasePrimitive2D(),
 321             maPolygon(rPolygon),
 322             maLineAttribute(rLineAttribute),
 323             maStrokeAttribute()
 324         {
 325         }
 326
 327         bool PolygonStrokePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 328         {
 329             if(BasePrimitive2D::operator==(rPrimitive))
 330             {
 331                 const PolygonStrokePrimitive2D& rCompare = (PolygonStrokePrimitive2D&)rPrimitive;
 332
 333                 return (getB2DPolygon() == rCompare.getB2DPolygon()
 334                     && getLineAttribute() == rCompare.getLineAttribute()
 335                     && getStrokeAttribute() == rCompare.getStrokeAttribute());
 336             }
 337
 338             return false;
 339         }
 340
 341         basegfx::B2DRange PolygonStrokePrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
 342         {
 343             basegfx::B2DRange aRetval;
 344
 345             if(getLineAttribute().getWidth())
 346             {
 347                 if(basegfx::B2DLINEJOIN_MITER == getLineAttribute().getLineJoin())
 348                 {
 349                     // if line is mitered, use parent call since mitered line
 350                     // geometry may use more space than the geometry grown by half line width
 351                     aRetval = BasePrimitive2D::getB2DRange(rViewInformation);
 352                 }
 353                 else
 354                 {
 355                     // for all other B2DLINEJOIN_* get the range from the base geometry
 356                     // and expand by half the line width
 357                     aRetval = getB2DPolygon().getB2DRange();
 358                     aRetval.grow(getLineAttribute().getWidth() * 0.5);
 359                 }
 360             }
 361             else
 362             {
 363                 // this is a hairline, thus the line width is view-dependent. Get range of polygon
 364                 // as base size
 365                 aRetval = getB2DPolygon().getB2DRange();
 366
 367                 if(!aRetval.isEmpty())
 368                 {
 369                     // Calculate view-dependent hairline width
 370                     const basegfx::B2DVector aDiscreteSize(rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 0.0));
 371                     const double fDiscreteHalfLineWidth(aDiscreteSize.getLength() * 0.5);
 372
 373                     if(basegfx::fTools::more(fDiscreteHalfLineWidth, 0.0))
 374                     {
 375                         aRetval.grow(fDiscreteHalfLineWidth);
 376                     }
 377                 }
 378             }
 379
 380             return aRetval;
 381         }
 382
 383         // provide unique ID
 384         ImplPrimitrive2DIDBlock(PolygonStrokePrimitive2D, PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D)
 385
 386     } // end of namespace primitive2d
 387 } // end of namespace drawinglayer
 388
 389 //////////////////////////////////////////////////////////////////////////////
 390
 391 namespace drawinglayer
 392 {
 393     namespace primitive2d
 394     {
 395         Primitive2DSequence PolygonWavePrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
 396         {
 397             Primitive2DSequence aRetval;
 398
 399             if(getB2DPolygon().count())
 400             {
 401                 const bool bHasWidth(!basegfx::fTools::equalZero(getWaveWidth()));
 402                 const bool bHasHeight(!basegfx::fTools::equalZero(getWaveHeight()));
 403
 404                 if(bHasWidth && bHasHeight)
 405                 {
 406                     // create waveline curve
 407                     const basegfx::B2DPolygon aWaveline(basegfx::tools::createWaveline(getB2DPolygon(), getWaveWidth(), getWaveHeight()));
 408                     const Primitive2DReference xRef(new PolygonStrokePrimitive2D(aWaveline, getLineAttribute(), getStrokeAttribute()));
 409                     aRetval = Primitive2DSequence(&xRef, 1);
 410                 }
 411                 else
 412                 {
 413                     // flat waveline, decompose to simple line primitive
 414                     const Primitive2DReference xRef(new PolygonStrokePrimitive2D(getB2DPolygon(), getLineAttribute(), getStrokeAttribute()));
 415                     aRetval = Primitive2DSequence(&xRef, 1);
 416                 }
 417             }
 418
 419             return aRetval;
 420         }
 421
 422         PolygonWavePrimitive2D::PolygonWavePrimitive2D(
 423             const basegfx::B2DPolygon& rPolygon,
 424             const attribute::LineAttribute& rLineAttribute,
 425             const attribute::StrokeAttribute& rStrokeAttribute,
 426             double fWaveWidth,
 427             double fWaveHeight)
 428         :       PolygonStrokePrimitive2D(rPolygon, rLineAttribute, rStrokeAttribute),
 429             mfWaveWidth(fWaveWidth),
 430             mfWaveHeight(fWaveHeight)
 431         {
 432             if(mfWaveWidth < 0.0)
 433             {
 434                 mfWaveWidth = 0.0;
 435             }
 436
 437             if(mfWaveHeight < 0.0)
 438             {
 439                 mfWaveHeight = 0.0;
 440             }
 441         }
 442
 443         PolygonWavePrimitive2D::PolygonWavePrimitive2D(
 444             const basegfx::B2DPolygon& rPolygon,
 445             const attribute::LineAttribute& rLineAttribute,
 446             double fWaveWidth,
 447             double fWaveHeight)
 448         :       PolygonStrokePrimitive2D(rPolygon, rLineAttribute),
 449             mfWaveWidth(fWaveWidth),
 450             mfWaveHeight(fWaveHeight)
 451         {
 452             if(mfWaveWidth < 0.0)
 453             {
 454                 mfWaveWidth = 0.0;
 455             }
 456
 457             if(mfWaveHeight < 0.0)
 458             {
 459                 mfWaveHeight = 0.0;
 460             }
 461         }
 462
 463         bool PolygonWavePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 464         {
 465             if(PolygonStrokePrimitive2D::operator==(rPrimitive))
 466             {
 467                 const PolygonWavePrimitive2D& rCompare = (PolygonWavePrimitive2D&)rPrimitive;
 468
 469                 return (getWaveWidth() == rCompare.getWaveWidth()
 470                     && getWaveHeight() == rCompare.getWaveHeight());
 471             }
 472
 473             return false;
 474         }
 475
 476         basegfx::B2DRange PolygonWavePrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
 477         {
 478             // get range of parent
 479             basegfx::B2DRange aRetval(PolygonStrokePrimitive2D::getB2DRange(rViewInformation));
 480
 481             // if WaveHeight, grow by it
 482             if(basegfx::fTools::more(getWaveHeight(), 0.0))
 483             {
 484                 aRetval.grow(getWaveHeight());
 485             }
 486
 487             // if line width, grow by it
 488             if(basegfx::fTools::more(getLineAttribute().getWidth(), 0.0))
 489             {
 490                 aRetval.grow(getLineAttribute().getWidth() * 0.5);
 491             }
 492
 493             return aRetval;
 494         }
 495
 496         // provide unique ID
 497         ImplPrimitrive2DIDBlock(PolygonWavePrimitive2D, PRIMITIVE2D_ID_POLYGONWAVEPRIMITIVE2D)
 498
 499     } // end of namespace primitive2d
 500 } // end of namespace drawinglayer
 501
 502 //////////////////////////////////////////////////////////////////////////////
 503
 504 namespace drawinglayer
 505 {
 506     namespace primitive2d
 507     {
 508         Primitive2DSequence PolygonStrokeArrowPrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
 509         {
 510             // copy local polygon, it may be changed
 511             basegfx::B2DPolygon aLocalPolygon(getB2DPolygon());
 512             basegfx::B2DPolyPolygon aArrowA;
 513             basegfx::B2DPolyPolygon aArrowB;
 514
 515             if(!aLocalPolygon.isClosed())
 516             {
 517                 // apply arrows
 518                 const double fPolyLength(basegfx::tools::getLength(aLocalPolygon));
 519                 double fStart(0.0);
 520                 double fEnd(0.0);
 521
 522                 if(getStart().isActive())
 523                 {
 524                     // create start arrow primitive and consume
 525                     aArrowA = basegfx::tools::createAreaGeometryForLineStartEnd(
 526                         aLocalPolygon, getStart().getB2DPolyPolygon(), true, getStart().getWidth(),
 527                         fPolyLength, getStart().isCentered() ? 0.5 : 0.0, &fStart);
 528
 529                     // create some overlapping
 530                     fStart *= 0.8;
 531                 }
 532
 533                 if(getEnd().isActive())
 534                 {
 535                     // create end arrow primitive and consume
 536                     aArrowB = basegfx::tools::createAreaGeometryForLineStartEnd(
 537                         aLocalPolygon, getEnd().getB2DPolyPolygon(), false, getEnd().getWidth(),
 538                         fPolyLength, getEnd().isCentered() ? 0.5 : 0.0, &fEnd);
 539
 540                     // create some overlapping
 541                     fEnd *= 0.8;
 542                 }
 543
 544                 if(0.0 != fStart || 0.0 != fEnd)
 545                 {
 546                     // build new poly, consume something from old poly
 547                     aLocalPolygon = basegfx::tools::getSnippetAbsolute(aLocalPolygon, fStart, fPolyLength - fEnd, fPolyLength);
 548                 }
 549             }
 550
 551             // prepare return value
 552             Primitive2DSequence aRetval(1L + (aArrowA.count() ? 1L : 0L) + (aArrowB.count() ? 1L : 0L));
 553             sal_uInt32 nInd(0L);
 554
 555             // add shaft
 556             const Primitive2DReference xRefShaft(new PolygonStrokePrimitive2D(aLocalPolygon, getLineAttribute(), getStrokeAttribute()));
 557             aRetval[nInd++] = xRefShaft;
 558
 559             if(aArrowA.count())
 560             {
 561                 const Primitive2DReference xRefA(new PolyPolygonColorPrimitive2D(aArrowA, getLineAttribute().getColor()));
 562                 aRetval[nInd++] = xRefA;
 563             }
 564
 565             if(aArrowB.count())
 566             {
 567                 const Primitive2DReference xRefB(new PolyPolygonColorPrimitive2D(aArrowB, getLineAttribute().getColor()));
 568                 aRetval[nInd++] = xRefB;
 569             }
 570
 571             return aRetval;
 572         }
 573
 574         PolygonStrokeArrowPrimitive2D::PolygonStrokeArrowPrimitive2D(
 575             const basegfx::B2DPolygon& rPolygon,
 576             const attribute::LineAttribute& rLineAttribute,
 577             const attribute::StrokeAttribute& rStrokeAttribute,
 578             const attribute::LineStartEndAttribute& rStart,
 579             const attribute::LineStartEndAttribute& rEnd)
 580         :       PolygonStrokePrimitive2D(rPolygon, rLineAttribute, rStrokeAttribute),
 581             maStart(rStart),
 582             maEnd(rEnd)
 583         {
 584         }
 585
 586         PolygonStrokeArrowPrimitive2D::PolygonStrokeArrowPrimitive2D(
 587             const basegfx::B2DPolygon& rPolygon,
 588             const attribute::LineAttribute& rLineAttribute,
 589             const attribute::LineStartEndAttribute& rStart,
 590             const attribute::LineStartEndAttribute& rEnd)
 591         :       PolygonStrokePrimitive2D(rPolygon, rLineAttribute),
 592             maStart(rStart),
 593             maEnd(rEnd)
 594         {
 595         }
 596
 597         bool PolygonStrokeArrowPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 598         {
 599             if(PolygonStrokePrimitive2D::operator==(rPrimitive))
 600             {
 601                 const PolygonStrokeArrowPrimitive2D& rCompare = (PolygonStrokeArrowPrimitive2D&)rPrimitive;
 602
 603                 return (getStart() == rCompare.getStart()
 604                     && getEnd() == rCompare.getEnd());
 605             }
 606
 607             return false;
 608         }
 609
 610         basegfx::B2DRange PolygonStrokeArrowPrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
 611         {
 612             basegfx::B2DRange aRetval;
 613
 614             if(getStart().isActive() || getEnd().isActive())
 615             {
 616                 // use decomposition when line start/end is used
 617                 return BasePrimitive2D::getB2DRange(rViewInformation);
 618             }
 619             else
 620             {
 621                 // get range from parent
 622                 return PolygonStrokePrimitive2D::getB2DRange(rViewInformation);
 623             }
 624         }
 625
 626         // provide unique ID
 627         ImplPrimitrive2DIDBlock(PolygonStrokeArrowPrimitive2D, PRIMITIVE2D_ID_POLYGONSTROKEARROWPRIMITIVE2D)
 628
 629     } // end of namespace primitive2d
 630 } // end of namespace drawinglayer
 631
 632 //////////////////////////////////////////////////////////////////////////////
 633 // eof