1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_drawinglayer.hxx" 26 27 #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx> 28 #include <basegfx/polygon/b2dpolypolygontools.hxx> 29 #include <basegfx/tools/canvastools.hxx> 30 #include <drawinglayer/primitive2d/fillgradientprimitive2d.hxx> 31 #include <drawinglayer/primitive2d/maskprimitive2d.hxx> 32 #include <drawinglayer/primitive2d/fillhatchprimitive2d.hxx> 33 #include <basegfx/matrix/b2dhommatrix.hxx> 34 #include <drawinglayer/primitive2d/fillbitmapprimitive2d.hxx> 35 #include <drawinglayer/primitive2d/polygonprimitive2d.hxx> 36 #include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx> 37 38 ////////////////////////////////////////////////////////////////////////////// 39 40 using namespace com::sun::star; 41 42 ////////////////////////////////////////////////////////////////////////////// 43 44 namespace drawinglayer 45 { 46 namespace primitive2d 47 { 48 Primitive2DSequence PolyPolygonHairlinePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const 49 { 50 const basegfx::B2DPolyPolygon aPolyPolygon(getB2DPolyPolygon()); 51 const sal_uInt32 nCount(aPolyPolygon.count()); 52 53 if(nCount) 54 { 55 Primitive2DSequence aRetval(nCount); 56 57 for(sal_uInt32 a(0L); a < nCount; a++) 58 { 59 aRetval[a] = Primitive2DReference(new PolygonHairlinePrimitive2D(aPolyPolygon.getB2DPolygon(a), getBColor())); 60 } 61 62 return aRetval; 63 } 64 else 65 { 66 return Primitive2DSequence(); 67 } 68 } 69 70 PolyPolygonHairlinePrimitive2D::PolyPolygonHairlinePrimitive2D(const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::BColor& rBColor) 71 : BufferedDecompositionPrimitive2D(), 72 maPolyPolygon(rPolyPolygon), 73 maBColor(rBColor) 74 { 75 } 76 77 bool PolyPolygonHairlinePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const 78 { 79 if(BufferedDecompositionPrimitive2D::operator==(rPrimitive)) 80 { 81 const PolyPolygonHairlinePrimitive2D& rCompare = (PolyPolygonHairlinePrimitive2D&)rPrimitive; 82 83 return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon() 84 && getBColor() == rCompare.getBColor()); 85 } 86 87 return false; 88 } 89 90 basegfx::B2DRange PolyPolygonHairlinePrimitive2D::getB2DRange(const geometry::ViewInformation2D& /*rViewInformation*/) const 91 { 92 // return range 93 return basegfx::tools::getRange(getB2DPolyPolygon()); 94 } 95 96 // provide unique ID 97 ImplPrimitrive2DIDBlock(PolyPolygonHairlinePrimitive2D, PRIMITIVE2D_ID_POLYPOLYGONHAIRLINEPRIMITIVE2D) 98 99 } // end of namespace primitive2d 100 } // end of namespace drawinglayer 101 102 ////////////////////////////////////////////////////////////////////////////// 103 104 namespace drawinglayer 105 { 106 namespace primitive2d 107 { 108 Primitive2DSequence PolyPolygonMarkerPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const 109 { 110 const basegfx::B2DPolyPolygon aPolyPolygon(getB2DPolyPolygon()); 111 const sal_uInt32 nCount(aPolyPolygon.count()); 112 113 if(nCount) 114 { 115 Primitive2DSequence aRetval(nCount); 116 117 for(sal_uInt32 a(0L); a < nCount; a++) 118 { 119 aRetval[a] = Primitive2DReference(new PolygonMarkerPrimitive2D(aPolyPolygon.getB2DPolygon(a), getRGBColorA(), getRGBColorB(), getDiscreteDashLength())); 120 } 121 122 return aRetval; 123 } 124 else 125 { 126 return Primitive2DSequence(); 127 } 128 } 129 130 PolyPolygonMarkerPrimitive2D::PolyPolygonMarkerPrimitive2D( 131 const basegfx::B2DPolyPolygon& rPolyPolygon, 132 const basegfx::BColor& rRGBColorA, 133 const basegfx::BColor& rRGBColorB, 134 double fDiscreteDashLength) 135 : BufferedDecompositionPrimitive2D(), 136 maPolyPolygon(rPolyPolygon), 137 maRGBColorA(rRGBColorA), 138 maRGBColorB(rRGBColorB), 139 mfDiscreteDashLength(fDiscreteDashLength) 140 { 141 } 142 143 bool PolyPolygonMarkerPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const 144 { 145 if(BufferedDecompositionPrimitive2D::operator==(rPrimitive)) 146 { 147 const PolyPolygonMarkerPrimitive2D& rCompare = (PolyPolygonMarkerPrimitive2D&)rPrimitive; 148 149 return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon() 150 && getRGBColorA() == rCompare.getRGBColorA() 151 && getRGBColorB() == rCompare.getRGBColorB() 152 && getDiscreteDashLength() == rCompare.getDiscreteDashLength()); 153 } 154 155 return false; 156 } 157 158 basegfx::B2DRange PolyPolygonMarkerPrimitive2D::getB2DRange(const geometry::ViewInformation2D& /*rViewInformation*/) const 159 { 160 // return range 161 return basegfx::tools::getRange(getB2DPolyPolygon()); 162 } 163 164 // provide unique ID 165 ImplPrimitrive2DIDBlock(PolyPolygonMarkerPrimitive2D, PRIMITIVE2D_ID_POLYPOLYGONMARKERPRIMITIVE2D) 166 167 } // end of namespace primitive2d 168 } // end of namespace drawinglayer 169 170 ////////////////////////////////////////////////////////////////////////////// 171 172 namespace drawinglayer 173 { 174 namespace primitive2d 175 { 176 Primitive2DSequence PolyPolygonStrokePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const 177 { 178 const basegfx::B2DPolyPolygon aPolyPolygon(getB2DPolyPolygon()); 179 const sal_uInt32 nCount(aPolyPolygon.count()); 180 181 if(nCount) 182 { 183 Primitive2DSequence aRetval(nCount); 184 185 for(sal_uInt32 a(0L); a < nCount; a++) 186 { 187 aRetval[a] = Primitive2DReference( 188 new PolygonStrokePrimitive2D( 189 aPolyPolygon.getB2DPolygon(a), getLineAttribute(), getStrokeAttribute())); 190 } 191 192 return aRetval; 193 } 194 else 195 { 196 return Primitive2DSequence(); 197 } 198 } 199 200 PolyPolygonStrokePrimitive2D::PolyPolygonStrokePrimitive2D( 201 const basegfx::B2DPolyPolygon& rPolyPolygon, 202 const attribute::LineAttribute& rLineAttribute, 203 const attribute::StrokeAttribute& rStrokeAttribute) 204 : BufferedDecompositionPrimitive2D(), 205 maPolyPolygon(rPolyPolygon), 206 maLineAttribute(rLineAttribute), 207 maStrokeAttribute(rStrokeAttribute) 208 { 209 } 210 211 PolyPolygonStrokePrimitive2D::PolyPolygonStrokePrimitive2D( 212 const basegfx::B2DPolyPolygon& rPolyPolygon, 213 const attribute::LineAttribute& rLineAttribute) 214 : BufferedDecompositionPrimitive2D(), 215 maPolyPolygon(rPolyPolygon), 216 maLineAttribute(rLineAttribute), 217 maStrokeAttribute() 218 { 219 } 220 221 bool PolyPolygonStrokePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const 222 { 223 if(BufferedDecompositionPrimitive2D::operator==(rPrimitive)) 224 { 225 const PolyPolygonStrokePrimitive2D& rCompare = (PolyPolygonStrokePrimitive2D&)rPrimitive; 226 227 return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon() 228 && getLineAttribute() == rCompare.getLineAttribute() 229 && getStrokeAttribute() == rCompare.getStrokeAttribute()); 230 } 231 232 return false; 233 } 234 235 basegfx::B2DRange PolyPolygonStrokePrimitive2D::getB2DRange(const geometry::ViewInformation2D& /*rViewInformation*/) const 236 { 237 // get range of it (subdivided) 238 basegfx::B2DRange aRetval(basegfx::tools::getRange(getB2DPolyPolygon())); 239 240 // if width, grow by line width 241 if(getLineAttribute().getWidth()) 242 { 243 aRetval.grow(getLineAttribute().getWidth() / 2.0); 244 } 245 246 return aRetval; 247 } 248 249 // provide unique ID 250 ImplPrimitrive2DIDBlock(PolyPolygonStrokePrimitive2D, PRIMITIVE2D_ID_POLYPOLYGONSTROKEPRIMITIVE2D) 251 252 } // end of namespace primitive2d 253 } // end of namespace drawinglayer 254 255 ////////////////////////////////////////////////////////////////////////////// 256 257 namespace drawinglayer 258 { 259 namespace primitive2d 260 { 261 Primitive2DSequence PolyPolygonStrokeArrowPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const 262 { 263 const basegfx::B2DPolyPolygon aPolyPolygon(getB2DPolyPolygon()); 264 const sal_uInt32 nCount(aPolyPolygon.count()); 265 266 if(nCount) 267 { 268 Primitive2DSequence aRetval(nCount); 269 270 for(sal_uInt32 a(0L); a < nCount; a++) 271 { 272 const basegfx::B2DPolygon aPolygon(aPolyPolygon.getB2DPolygon(a)); 273 274 if(aPolygon.isClosed()) 275 { 276 // no need for PolygonStrokeArrowPrimitive2D when polygon is closed 277 aRetval[a] = Primitive2DReference( 278 new PolygonStrokePrimitive2D(aPolygon, getLineAttribute(), getStrokeAttribute())); 279 } 280 else 281 { 282 aRetval[a] = Primitive2DReference( 283 new PolygonStrokeArrowPrimitive2D(aPolygon, getLineAttribute(), 284 getStrokeAttribute(), getStart(), getEnd())); 285 } 286 } 287 288 return aRetval; 289 } 290 else 291 { 292 return Primitive2DSequence(); 293 } 294 } 295 296 PolyPolygonStrokeArrowPrimitive2D::PolyPolygonStrokeArrowPrimitive2D( 297 const basegfx::B2DPolyPolygon& rPolyPolygon, 298 const attribute::LineAttribute& rLineAttribute, 299 const attribute::StrokeAttribute& rStrokeAttribute, 300 const attribute::LineStartEndAttribute& rStart, 301 const attribute::LineStartEndAttribute& rEnd) 302 : PolyPolygonStrokePrimitive2D(rPolyPolygon, rLineAttribute, rStrokeAttribute), 303 maStart(rStart), 304 maEnd(rEnd) 305 { 306 } 307 308 PolyPolygonStrokeArrowPrimitive2D::PolyPolygonStrokeArrowPrimitive2D( 309 const basegfx::B2DPolyPolygon& rPolyPolygon, 310 const attribute::LineAttribute& rLineAttribute, 311 const attribute::LineStartEndAttribute& rStart, 312 const attribute::LineStartEndAttribute& rEnd) 313 : PolyPolygonStrokePrimitive2D(rPolyPolygon, rLineAttribute), 314 maStart(rStart), 315 maEnd(rEnd) 316 { 317 } 318 319 bool PolyPolygonStrokeArrowPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const 320 { 321 if(PolyPolygonStrokePrimitive2D::operator==(rPrimitive)) 322 { 323 const PolyPolygonStrokeArrowPrimitive2D& rCompare = (PolyPolygonStrokeArrowPrimitive2D&)rPrimitive; 324 325 return (getStart() == rCompare.getStart() 326 && getEnd() == rCompare.getEnd()); 327 } 328 329 return false; 330 } 331 332 basegfx::B2DRange PolyPolygonStrokeArrowPrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const 333 { 334 basegfx::B2DRange aRetval; 335 336 if(getStart().isActive() || getEnd().isActive()) 337 { 338 // use decomposition when line start/end is used 339 return BufferedDecompositionPrimitive2D::getB2DRange(rViewInformation); 340 } 341 else 342 { 343 // get range from parent 344 return PolyPolygonStrokePrimitive2D::getB2DRange(rViewInformation); 345 } 346 } 347 348 // provide unique ID 349 ImplPrimitrive2DIDBlock(PolyPolygonStrokeArrowPrimitive2D, PRIMITIVE2D_ID_POLYPOLYGONSTROKEARROWPRIMITIVE2D) 350 351 } // end of namespace primitive2d 352 } // end of namespace drawinglayer 353 354 ////////////////////////////////////////////////////////////////////////////// 355 356 namespace drawinglayer 357 { 358 namespace primitive2d 359 { 360 PolyPolygonColorPrimitive2D::PolyPolygonColorPrimitive2D( 361 const basegfx::B2DPolyPolygon& rPolyPolygon, 362 const basegfx::BColor& rBColor) 363 : BasePrimitive2D(), 364 maPolyPolygon(rPolyPolygon), 365 maBColor(rBColor) 366 { 367 } 368 369 bool PolyPolygonColorPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const 370 { 371 if(BasePrimitive2D::operator==(rPrimitive)) 372 { 373 const PolyPolygonColorPrimitive2D& rCompare = (PolyPolygonColorPrimitive2D&)rPrimitive; 374 375 return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon() 376 && getBColor() == rCompare.getBColor()); 377 } 378 379 return false; 380 } 381 382 basegfx::B2DRange PolyPolygonColorPrimitive2D::getB2DRange(const geometry::ViewInformation2D& /*rViewInformation*/) const 383 { 384 // return range 385 return basegfx::tools::getRange(getB2DPolyPolygon()); 386 } 387 388 // provide unique ID 389 ImplPrimitrive2DIDBlock(PolyPolygonColorPrimitive2D, PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D) 390 391 } // end of namespace primitive2d 392 } // end of namespace drawinglayer 393 394 ////////////////////////////////////////////////////////////////////////////// 395 396 namespace drawinglayer 397 { 398 namespace primitive2d 399 { 400 Primitive2DSequence PolyPolygonGradientPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const 401 { 402 if(!getFillGradient().isDefault()) 403 { 404 // create SubSequence with FillGradientPrimitive2D 405 const basegfx::B2DRange aPolyPolygonRange(getB2DPolyPolygon().getB2DRange()); 406 FillGradientPrimitive2D* pNewGradient = new FillGradientPrimitive2D(aPolyPolygonRange, getFillGradient()); 407 const Primitive2DReference xSubRef(pNewGradient); 408 const Primitive2DSequence aSubSequence(&xSubRef, 1L); 409 410 // create mask primitive 411 MaskPrimitive2D* pNewMask = new MaskPrimitive2D(getB2DPolyPolygon(), aSubSequence); 412 const Primitive2DReference xRef(pNewMask); 413 414 return Primitive2DSequence(&xRef, 1); 415 } 416 else 417 { 418 return Primitive2DSequence(); 419 } 420 } 421 422 PolyPolygonGradientPrimitive2D::PolyPolygonGradientPrimitive2D( 423 const basegfx::B2DPolyPolygon& rPolyPolygon, 424 const attribute::FillGradientAttribute& rFillGradient) 425 : BufferedDecompositionPrimitive2D(), 426 maPolyPolygon(rPolyPolygon), 427 maFillGradient(rFillGradient) 428 { 429 } 430 431 bool PolyPolygonGradientPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const 432 { 433 if(BufferedDecompositionPrimitive2D::operator==(rPrimitive)) 434 { 435 const PolyPolygonGradientPrimitive2D& rCompare = (PolyPolygonGradientPrimitive2D&)rPrimitive; 436 437 return (getFillGradient() == rCompare.getFillGradient()); 438 } 439 440 return false; 441 } 442 443 // provide unique ID 444 ImplPrimitrive2DIDBlock(PolyPolygonGradientPrimitive2D, PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D) 445 446 } // end of namespace primitive2d 447 } // end of namespace drawinglayer 448 449 ////////////////////////////////////////////////////////////////////////////// 450 451 namespace drawinglayer 452 { 453 namespace primitive2d 454 { 455 Primitive2DSequence PolyPolygonHatchPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const 456 { 457 if(!getFillHatch().isDefault()) 458 { 459 // create SubSequence with FillHatchPrimitive2D 460 const basegfx::B2DRange aPolyPolygonRange(getB2DPolyPolygon().getB2DRange()); 461 FillHatchPrimitive2D* pNewHatch = new FillHatchPrimitive2D(aPolyPolygonRange, getBackgroundColor(), getFillHatch()); 462 const Primitive2DReference xSubRef(pNewHatch); 463 const Primitive2DSequence aSubSequence(&xSubRef, 1L); 464 465 // create mask primitive 466 MaskPrimitive2D* pNewMask = new MaskPrimitive2D(getB2DPolyPolygon(), aSubSequence); 467 const Primitive2DReference xRef(pNewMask); 468 469 return Primitive2DSequence(&xRef, 1); 470 } 471 else 472 { 473 return Primitive2DSequence(); 474 } 475 } 476 477 PolyPolygonHatchPrimitive2D::PolyPolygonHatchPrimitive2D( 478 const basegfx::B2DPolyPolygon& rPolyPolygon, 479 const basegfx::BColor& rBackgroundColor, 480 const attribute::FillHatchAttribute& rFillHatch) 481 : BufferedDecompositionPrimitive2D(), 482 maPolyPolygon(rPolyPolygon), 483 maBackgroundColor(rBackgroundColor), 484 maFillHatch(rFillHatch) 485 { 486 } 487 488 bool PolyPolygonHatchPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const 489 { 490 if(BufferedDecompositionPrimitive2D::operator==(rPrimitive)) 491 { 492 const PolyPolygonHatchPrimitive2D& rCompare = (PolyPolygonHatchPrimitive2D&)rPrimitive; 493 494 return (getBackgroundColor() == rCompare.getBackgroundColor() 495 && getFillHatch() == rCompare.getFillHatch()); 496 } 497 498 return false; 499 } 500 501 // provide unique ID 502 ImplPrimitrive2DIDBlock(PolyPolygonHatchPrimitive2D, PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D) 503 504 } // end of namespace primitive2d 505 } // end of namespace drawinglayer 506 507 ////////////////////////////////////////////////////////////////////////////// 508 509 namespace drawinglayer 510 { 511 namespace primitive2d 512 { 513 Primitive2DSequence PolyPolygonBitmapPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const 514 { 515 if(!getFillBitmap().isDefault()) 516 { 517 // create SubSequence with FillBitmapPrimitive2D 518 const basegfx::B2DRange aPolyPolygonRange(getB2DPolyPolygon().getB2DRange()); 519 basegfx::B2DHomMatrix aNewObjectTransform; 520 aNewObjectTransform.set(0, 0, aPolyPolygonRange.getWidth()); 521 aNewObjectTransform.set(1, 1, aPolyPolygonRange.getHeight()); 522 aNewObjectTransform.set(0, 2, aPolyPolygonRange.getMinX()); 523 aNewObjectTransform.set(1, 2, aPolyPolygonRange.getMinY()); 524 FillBitmapPrimitive2D* pNewBitmap = new FillBitmapPrimitive2D(aNewObjectTransform, getFillBitmap()); 525 const Primitive2DReference xSubRef(pNewBitmap); 526 const Primitive2DSequence aSubSequence(&xSubRef, 1L); 527 528 // create mask primitive 529 MaskPrimitive2D* pNewMask = new MaskPrimitive2D(getB2DPolyPolygon(), aSubSequence); 530 const Primitive2DReference xRef(pNewMask); 531 532 return Primitive2DSequence(&xRef, 1); 533 } 534 else 535 { 536 return Primitive2DSequence(); 537 } 538 } 539 540 PolyPolygonBitmapPrimitive2D::PolyPolygonBitmapPrimitive2D( 541 const basegfx::B2DPolyPolygon& rPolyPolygon, 542 const attribute::FillBitmapAttribute& rFillBitmap) 543 : BufferedDecompositionPrimitive2D(), 544 maPolyPolygon(rPolyPolygon), 545 maFillBitmap(rFillBitmap) 546 { 547 } 548 549 bool PolyPolygonBitmapPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const 550 { 551 if(BufferedDecompositionPrimitive2D::operator==(rPrimitive)) 552 { 553 const PolyPolygonBitmapPrimitive2D& rCompare = (PolyPolygonBitmapPrimitive2D&)rPrimitive; 554 555 return (getFillBitmap() == rCompare.getFillBitmap()); 556 } 557 558 return false; 559 } 560 561 // provide unique ID 562 ImplPrimitrive2DIDBlock(PolyPolygonBitmapPrimitive2D, PRIMITIVE2D_ID_POLYPOLYGONBITMAPPRIMITIVE2D) 563 564 } // end of namespace primitive2d 565 } // end of namespace drawinglayer 566 567 ////////////////////////////////////////////////////////////////////////////// 568 // eof 569