svx/source/sdr/overlay/overlaytools.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: overlayobject.cxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svx.hxx"
  33
  34 #include <svx/sdr/overlay/overlaytools.hxx>
  35 #include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx>
  36 #include <basegfx/matrix/b2dhommatrix.hxx>
  37 #include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>
  38 #include <basegfx/polygon/b2dpolygon.hxx>
  39 #include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
  40 #include <basegfx/polygon/b2dpolygontools.hxx>
  41 #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
  42 #include <drawinglayer/geometry/viewinformation2d.hxx>
  43
  44 //////////////////////////////////////////////////////////////////////////////
  45
  46 namespace drawinglayer
  47 {
  48     namespace primitive2d
  49     {
  50         OverlayBitmapExPrimitive::OverlayBitmapExPrimitive(
  51             const BitmapEx& rBitmapEx,
  52             const basegfx::B2DPoint& rBasePosition,
  53             sal_uInt16 nCenterX,
  54             sal_uInt16 nCenterY)
  55         :   DiscreteMetricDependentPrimitive2D(),
  56             maBitmapEx(rBitmapEx),
  57             maBasePosition(rBasePosition),
  58             mnCenterX(nCenterX),
  59             mnCenterY(nCenterY)
  60         {}
  61
  62         Primitive2DSequence OverlayBitmapExPrimitive::createLocalDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
  63         {
  64             Primitive2DSequence aRetval;
  65             const Size aBitmapSize(getBitmapEx().GetSizePixel());
  66
  67             if(aBitmapSize.Width() && aBitmapSize.Height() && basegfx::fTools::more(getDiscreteUnit(), 0.0))
  68             {
  69                 // calculate back from internal bitmap's extreme coordinates (the edges)
  70                 // to logical coordinates. Only use a unified scaling value (getDiscreteUnit(),
  71                 // the prepared one which expresses how many logic units form a discrete unit)
  72                 // for this step. This primitive is to be displayed always unscaled (in it's pixel size)
  73                 // and unrotated, more like a marker
  74                 const double fLeft(((0.0 - getCenterX()) * getDiscreteUnit()) + getBasePosition().getX());
  75                 const double fTop(((0.0 - getCenterY()) * getDiscreteUnit()) + getBasePosition().getY());
  76                 const double fRight((((aBitmapSize.getWidth() - 1.0) - getCenterX()) * getDiscreteUnit()) + getBasePosition().getX());
  77                 const double fBottom((((aBitmapSize.getHeight() - 1.0) - getCenterY()) * getDiscreteUnit()) + getBasePosition().getY());
  78
  79                 // create a BitmapPrimitive2D using those positions
  80                 basegfx::B2DHomMatrix aTransform;
  81
  82                 aTransform.set(0, 0, fRight - fLeft);
  83                 aTransform.set(1, 1, fBottom - fTop);
  84                 aTransform.set(0, 2, fLeft);
  85                 aTransform.set(1, 2, fTop);
  86
  87                 const Primitive2DReference aPrimitive(new BitmapPrimitive2D(getBitmapEx(), aTransform));
  88                 aRetval = Primitive2DSequence(&aPrimitive, 1);
  89             }
  90
  91             return aRetval;
  92         }
  93
  94         bool OverlayBitmapExPrimitive::operator==( const BasePrimitive2D& rPrimitive ) const
  95         {
  96             if(DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
  97             {
  98                 const OverlayBitmapExPrimitive& rCompare = static_cast< const OverlayBitmapExPrimitive& >(rPrimitive);
  99
 100                 return (getBitmapEx() == rCompare.getBitmapEx()
 101                     && getBasePosition() == rCompare.getBasePosition()
 102                     && getCenterX() == rCompare.getCenterX()
 103                     && getCenterY() == rCompare.getCenterY());
 104             }
 105
 106             return false;
 107         }
 108
 109         ImplPrimitrive2DIDBlock(OverlayBitmapExPrimitive, PRIMITIVE2D_ID_OVERLAYBITMAPEXPRIMITIVE)
 110
 111     } // end of namespace primitive2d
 112 } // end of namespace drawinglayer
 113
 114 //////////////////////////////////////////////////////////////////////////////
 115
 116 namespace drawinglayer
 117 {
 118     namespace primitive2d
 119     {
 120         OverlayCrosshairPrimitive::OverlayCrosshairPrimitive(
 121             const basegfx::B2DPoint& rBasePosition,
 122             const basegfx::BColor& rRGBColorA,
 123             const basegfx::BColor& rRGBColorB,
 124             double fDiscreteDashLength)
 125         :   ViewportDependentPrimitive2D(),
 126             maBasePosition(rBasePosition),
 127             maRGBColorA(rRGBColorA),
 128             maRGBColorB(rRGBColorB),
 129             mfDiscreteDashLength(fDiscreteDashLength)
 130         {}
 131
 132         Primitive2DSequence OverlayCrosshairPrimitive::createLocalDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
 133         {
 134             // use the prepared Viewport information accessible using getViewport()
 135             Primitive2DSequence aRetval;
 136
 137             if(!getViewport().isEmpty())
 138             {
 139                 aRetval.realloc(2);
 140                 basegfx::B2DPolygon aPolygon;
 141
 142                 aPolygon.append(basegfx::B2DPoint(getViewport().getMinX(), getBasePosition().getY()));
 143                 aPolygon.append(basegfx::B2DPoint(getViewport().getMaxX(), getBasePosition().getY()));
 144
 145                 aRetval[0] = Primitive2DReference(
 146                     new PolygonMarkerPrimitive2D(
 147                         aPolygon,
 148                         getRGBColorA(),
 149                         getRGBColorB(),
 150                         getDiscreteDashLength()));
 151
 152                 aPolygon.clear();
 153                 aPolygon.append(basegfx::B2DPoint(getBasePosition().getX(), getViewport().getMinY()));
 154                 aPolygon.append(basegfx::B2DPoint(getBasePosition().getX(), getViewport().getMaxY()));
 155
 156                 aRetval[1] = Primitive2DReference(
 157                     new PolygonMarkerPrimitive2D(
 158                         aPolygon,
 159                         getRGBColorA(),
 160                         getRGBColorB(),
 161                         getDiscreteDashLength()));
 162             }
 163
 164             return aRetval;
 165         }
 166
 167         bool OverlayCrosshairPrimitive::operator==( const BasePrimitive2D& rPrimitive ) const
 168         {
 169             if(ViewportDependentPrimitive2D::operator==(rPrimitive))
 170             {
 171                 const OverlayCrosshairPrimitive& rCompare = static_cast< const OverlayCrosshairPrimitive& >(rPrimitive);
 172
 173                 return (getBasePosition() == rCompare.getBasePosition()
 174                     && getRGBColorA() == rCompare.getRGBColorA()
 175                     && getRGBColorB() == rCompare.getRGBColorB()
 176                     && getDiscreteDashLength() == rCompare.getDiscreteDashLength());
 177             }
 178
 179             return false;
 180         }
 181
 182         ImplPrimitrive2DIDBlock(OverlayCrosshairPrimitive, PRIMITIVE2D_ID_OVERLAYCROSSHAIRPRIMITIVE)
 183
 184     } // end of namespace primitive2d
 185 } // end of namespace drawinglayer
 186
 187 //////////////////////////////////////////////////////////////////////////////
 188
 189 namespace drawinglayer
 190 {
 191     namespace primitive2d
 192     {
 193         OverlayHatchRectanglePrimitive::OverlayHatchRectanglePrimitive(
 194             const basegfx::B2DRange& rObjectRange,
 195             double fDiscreteHatchDistance,
 196             double fHatchRotation,
 197             const basegfx::BColor& rHatchColor,
 198             double fDiscreteGrow,
 199             double fDiscreteShrink,
 200             double fRotation)
 201         :   DiscreteMetricDependentPrimitive2D(),
 202             maObjectRange(rObjectRange),
 203             mfDiscreteHatchDistance(fDiscreteHatchDistance),
 204             mfHatchRotation(fHatchRotation),
 205             maHatchColor(rHatchColor),
 206             mfDiscreteGrow(fDiscreteGrow),
 207             mfDiscreteShrink(fDiscreteShrink),
 208             mfRotation(fRotation)
 209         {}
 210
 211         Primitive2DSequence OverlayHatchRectanglePrimitive::createLocalDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
 212         {
 213             Primitive2DSequence aRetval;
 214
 215             if(basegfx::fTools::more(getDiscreteUnit(), 0.0))
 216             {
 217                 basegfx::B2DRange aInnerRange(getObjectRange());
 218                 basegfx::B2DRange aOuterRange(getObjectRange());
 219                 basegfx::B2DPolyPolygon aHatchPolyPolygon;
 220
 221                 aOuterRange.grow(getDiscreteUnit() * getDiscreteGrow());
 222                 aInnerRange.grow(getDiscreteUnit() * -getDiscreteShrink());
 223
 224                 aHatchPolyPolygon.append(basegfx::tools::createPolygonFromRect(aOuterRange));
 225
 226                 if(!aInnerRange.isEmpty())
 227                 {
 228                     aHatchPolyPolygon.append(basegfx::tools::createPolygonFromRect(aInnerRange));
 229                 }
 230
 231                 if(!basegfx::fTools::equalZero(getRotation()))
 232                 {
 233                     basegfx::B2DHomMatrix aTransform;
 234
 235                     aTransform.translate(-getObjectRange().getMinX(), -getObjectRange().getMinY());
 236                     aTransform.rotate(getRotation());
 237                     aTransform.translate(getObjectRange().getMinX(), getObjectRange().getMinY());
 238
 239                     aHatchPolyPolygon.transform(aTransform);
 240                 }
 241
 242                 const basegfx::BColor aEmptyColor(0.0, 0.0, 0.0);
 243                 const drawinglayer::attribute::FillHatchAttribute aFillHatchAttribute(
 244                     drawinglayer::attribute::HATCHSTYLE_SINGLE,
 245                     getDiscreteHatchDistance() * getDiscreteUnit(),
 246                     getHatchRotation() - getRotation(),
 247                     getHatchColor(),
 248                     false);
 249                 const Primitive2DReference aPrimitive(
 250                     new PolyPolygonHatchPrimitive2D(
 251                         aHatchPolyPolygon,
 252                         aEmptyColor,
 253                         aFillHatchAttribute));
 254
 255                 aRetval = Primitive2DSequence(&aPrimitive, 1);
 256             }
 257
 258             return aRetval;
 259         }
 260
 261         bool OverlayHatchRectanglePrimitive::operator==( const BasePrimitive2D& rPrimitive ) const
 262         {
 263             if(DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
 264             {
 265                 const OverlayHatchRectanglePrimitive& rCompare = static_cast< const OverlayHatchRectanglePrimitive& >(rPrimitive);
 266
 267                 return (getObjectRange() == rCompare.getObjectRange()
 268                     && getDiscreteHatchDistance() == rCompare.getDiscreteHatchDistance()
 269                     && getHatchRotation() == rCompare.getHatchRotation()
 270                     && getHatchColor() == rCompare.getHatchColor()
 271                     && getDiscreteGrow() == rCompare.getDiscreteGrow()
 272                     && getDiscreteShrink() == rCompare.getDiscreteShrink()
 273                     && getRotation() == rCompare.getRotation());
 274             }
 275
 276             return false;
 277         }
 278
 279         ImplPrimitrive2DIDBlock(OverlayHatchRectanglePrimitive, PRIMITIVE2D_ID_OVERLAYHATCHRECTANGLEPRIMITIVE)
 280
 281     } // end of namespace primitive2d
 282 } // end of namespace drawinglayer
 283
 284 //////////////////////////////////////////////////////////////////////////////
 285
 286 namespace drawinglayer
 287 {
 288     namespace primitive2d
 289     {
 290         OverlayHelplineStripedPrimitive::OverlayHelplineStripedPrimitive(
 291             const basegfx::B2DPoint& rBasePosition,
 292             HelplineStyle eStyle,
 293             const basegfx::BColor& rRGBColorA,
 294             const basegfx::BColor& rRGBColorB,
 295             double fDiscreteDashLength)
 296         :   ViewportDependentPrimitive2D(),
 297             maBasePosition(rBasePosition),
 298             meStyle(eStyle),
 299             maRGBColorA(rRGBColorA),
 300             maRGBColorB(rRGBColorB),
 301             mfDiscreteDashLength(fDiscreteDashLength)
 302         {}
 303
 304         Primitive2DSequence OverlayHelplineStripedPrimitive::createLocalDecomposition(const geometry::ViewInformation2D& rViewInformation) const
 305         {
 306             // use the prepared Viewport information accessible using getViewport()
 307             Primitive2DSequence aRetval;
 308
 309             if(!getViewport().isEmpty())
 310             {
 311                 switch(getStyle())
 312                 {
 313                     case HELPLINESTYLE_VERTICAL :
 314                     {
 315                         aRetval.realloc(1);
 316                         basegfx::B2DPolygon aLine;
 317
 318                         aLine.append(basegfx::B2DPoint(getBasePosition().getX(), getViewport().getMinY()));
 319                         aLine.append(basegfx::B2DPoint(getBasePosition().getX(), getViewport().getMaxY()));
 320
 321                         aRetval[0] = Primitive2DReference(
 322                             new PolygonMarkerPrimitive2D(
 323                                 aLine,
 324                                 getRGBColorA(),
 325                                 getRGBColorB(),
 326                                 getDiscreteDashLength()));
 327                         break;
 328                     }
 329
 330                     case HELPLINESTYLE_HORIZONTAL :
 331                     {
 332                         aRetval.realloc(1);
 333                         basegfx::B2DPolygon aLine;
 334
 335                         aLine.append(basegfx::B2DPoint(getViewport().getMinX(), getBasePosition().getY()));
 336                         aLine.append(basegfx::B2DPoint(getViewport().getMaxX(), getBasePosition().getY()));
 337
 338                         aRetval[0] = Primitive2DReference(
 339                             new PolygonMarkerPrimitive2D(
 340                                 aLine,
 341                                 getRGBColorA(),
 342                                 getRGBColorB(),
 343                                 getDiscreteDashLength()));
 344                         break;
 345                     }
 346
 347                     default: // case HELPLINESTYLE_POINT :
 348                     {
 349                         const double fDiscreteUnit((rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 0.0)).getLength());
 350                         aRetval.realloc(2);
 351                         basegfx::B2DPolygon aLineA, aLineB;
 352
 353                         aLineA.append(basegfx::B2DPoint(getBasePosition().getX(), getBasePosition().getY() - fDiscreteUnit));
 354                         aLineA.append(basegfx::B2DPoint(getBasePosition().getX(), getBasePosition().getY() + fDiscreteUnit));
 355
 356                         aRetval[0] = Primitive2DReference(
 357                             new PolygonMarkerPrimitive2D(
 358                                 aLineA,
 359                                 getRGBColorA(),
 360                                 getRGBColorB(),
 361                                 getDiscreteDashLength()));
 362
 363                         aLineB.append(basegfx::B2DPoint(getBasePosition().getX() - fDiscreteUnit, getBasePosition().getY()));
 364                         aLineB.append(basegfx::B2DPoint(getBasePosition().getX() + fDiscreteUnit, getBasePosition().getY()));
 365
 366                         aRetval[1] = Primitive2DReference(
 367                             new PolygonMarkerPrimitive2D(
 368                                 aLineB,
 369                                 getRGBColorA(),
 370                                 getRGBColorB(),
 371                                 getDiscreteDashLength()));
 372
 373                         break;
 374                     }
 375                 }
 376             }
 377
 378             return aRetval;
 379         }
 380
 381         bool OverlayHelplineStripedPrimitive::operator==( const BasePrimitive2D& rPrimitive ) const
 382         {
 383             if(ViewportDependentPrimitive2D::operator==(rPrimitive))
 384             {
 385                 const OverlayHelplineStripedPrimitive& rCompare = static_cast< const OverlayHelplineStripedPrimitive& >(rPrimitive);
 386
 387                 return (getBasePosition() == rCompare.getBasePosition()
 388                     && getStyle() == rCompare.getStyle()
 389                     && getRGBColorA() == rCompare.getRGBColorA()
 390                     && getRGBColorB() == rCompare.getRGBColorB()
 391                     && getDiscreteDashLength() == rCompare.getDiscreteDashLength());
 392             }
 393
 394             return false;
 395         }
 396
 397         ImplPrimitrive2DIDBlock(OverlayHelplineStripedPrimitive, PRIMITIVE2D_ID_OVERLAYHELPLINESTRIPEDPRIMITIVE)
 398
 399     } // end of namespace primitive2d
 400 } // end of namespace drawinglayer
 401
 402 //////////////////////////////////////////////////////////////////////////////
 403
 404 namespace drawinglayer
 405 {
 406     namespace primitive2d
 407     {
 408         OverlayRollingRectanglePrimitive::OverlayRollingRectanglePrimitive(
 409             const basegfx::B2DRange& aRollingRectangle,
 410             const basegfx::BColor& rRGBColorA,
 411             const basegfx::BColor& rRGBColorB,
 412             double fDiscreteDashLength)
 413         :   ViewportDependentPrimitive2D(),
 414             maRollingRectangle(aRollingRectangle),
 415             maRGBColorA(rRGBColorA),
 416             maRGBColorB(rRGBColorB),
 417             mfDiscreteDashLength(fDiscreteDashLength)
 418         {}
 419
 420         Primitive2DSequence OverlayRollingRectanglePrimitive::createLocalDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
 421         {
 422             // use the prepared Viewport information accessible using getViewport()
 423             Primitive2DSequence aRetval;
 424
 425             if(!getViewport().isEmpty())
 426             {
 427                 basegfx::B2DPolygon aLine;
 428                 aRetval.realloc(8);
 429
 430                 // Left lines
 431                 aLine.append(basegfx::B2DPoint(getViewport().getMinX(), getRollingRectangle().getMinY()));
 432                 aLine.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getRollingRectangle().getMinY()));
 433                 aRetval[0] = Primitive2DReference(new PolygonMarkerPrimitive2D(aLine, getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
 434
 435                 aLine.clear();
 436                 aLine.append(basegfx::B2DPoint(getViewport().getMinX(), getRollingRectangle().getMaxY()));
 437                 aLine.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getRollingRectangle().getMaxY()));
 438                 aRetval[1] = Primitive2DReference(new PolygonMarkerPrimitive2D(aLine, getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
 439
 440                 // Right lines
 441                 aLine.clear();
 442                 aLine.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getRollingRectangle().getMinY()));
 443                 aLine.append(basegfx::B2DPoint(getViewport().getMaxX(), getRollingRectangle().getMinY()));
 444                 aRetval[2] = Primitive2DReference(new PolygonMarkerPrimitive2D(aLine, getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
 445
 446                 aLine.clear();
 447                 aLine.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getRollingRectangle().getMaxY()));
 448                 aLine.append(basegfx::B2DPoint(getViewport().getMaxX(), getRollingRectangle().getMaxY()));
 449                 aRetval[3] = Primitive2DReference(new PolygonMarkerPrimitive2D(aLine, getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
 450
 451                 // Top lines
 452                 aLine.clear();
 453                 aLine.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getViewport().getMinY()));
 454                 aLine.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getRollingRectangle().getMinY()));
 455                 aRetval[4] = Primitive2DReference(new PolygonMarkerPrimitive2D(aLine, getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
 456
 457                 aLine.clear();
 458                 aLine.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getViewport().getMinY()));
 459                 aLine.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getRollingRectangle().getMinY()));
 460                 aRetval[5] = Primitive2DReference(new PolygonMarkerPrimitive2D(aLine, getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
 461
 462                 // Bottom lines
 463                 aLine.clear();
 464                 aLine.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getRollingRectangle().getMaxY()));
 465                 aLine.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getViewport().getMaxY()));
 466                 aRetval[6] = Primitive2DReference(new PolygonMarkerPrimitive2D(aLine, getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
 467
 468                 aLine.clear();
 469                 aLine.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getRollingRectangle().getMaxY()));
 470                 aLine.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getViewport().getMaxY()));
 471                 aRetval[7] = Primitive2DReference(new PolygonMarkerPrimitive2D(aLine, getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
 472             }
 473
 474             return aRetval;
 475         }
 476
 477         bool OverlayRollingRectanglePrimitive::operator==( const BasePrimitive2D& rPrimitive ) const
 478         {
 479             if(ViewportDependentPrimitive2D::operator==(rPrimitive))
 480             {
 481                 const OverlayRollingRectanglePrimitive& rCompare = static_cast< const OverlayRollingRectanglePrimitive& >(rPrimitive);
 482
 483                 return (getRollingRectangle() == rCompare.getRollingRectangle()
 484                     && getRGBColorA() == rCompare.getRGBColorA()
 485                     && getRGBColorB() == rCompare.getRGBColorB()
 486                     && getDiscreteDashLength() == rCompare.getDiscreteDashLength());
 487             }
 488
 489             return false;
 490         }
 491
 492         ImplPrimitrive2DIDBlock(OverlayRollingRectanglePrimitive, PRIMITIVE2D_ID_OVERLAYROLLINGRECTANGLEPRIMITIVE)
 493
 494     } // end of namespace primitive2d
 495 } // end of namespace drawinglayer
 496
 497 //////////////////////////////////////////////////////////////////////////////
 498 // eof