drawinglayer/source/primitive2d/gridprimitive2d.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 #include <drawinglayer/primitive2d/gridprimitive2d.hxx>
  21 #include <basegfx/utils/canvastools.hxx>
  22 #include <drawinglayer/primitive2d/pointarrayprimitive2d.hxx>
  23 #include <drawinglayer/primitive2d/markerarrayprimitive2d.hxx>
  24 #include <drawinglayer/geometry/viewinformation2d.hxx>
  25 #include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
  26 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  27
  28
  29 using namespace com::sun::star;
  30
  31
  32 namespace drawinglayer
  33 {
  34     namespace primitive2d
  35     {
  36         void GridPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& rViewInformation) const
  37         {
  38             if(!rViewInformation.getViewport().isEmpty() && getWidth() > 0.0 && getHeight() > 0.0)
  39             {
  40                 // decompose grid matrix to get logic size
  41                 basegfx::B2DVector aScale, aTranslate;
  42                 double fRotate, fShearX;
  43                 getTransform().decompose(aScale, aTranslate, fRotate, fShearX);
  44
  45                 // create grid matrix which transforms from scaled logic to view
  46                 basegfx::B2DHomMatrix aRST(basegfx::utils::createShearXRotateTranslateB2DHomMatrix(
  47                     fShearX, fRotate, aTranslate.getX(), aTranslate.getY()));
  48                 aRST *= rViewInformation.getObjectToViewTransformation();
  49
  50                 // get step widths
  51                 double fStepX(getWidth());
  52                 double fStepY(getHeight());
  53                 const double fMinimalStep(10.0);
  54
  55                 // guarantee a step width of 10.0
  56                 if(basegfx::fTools::less(fStepX, fMinimalStep))
  57                 {
  58                     fStepX = fMinimalStep;
  59                 }
  60
  61                 if(basegfx::fTools::less(fStepY, fMinimalStep))
  62                 {
  63                     fStepY = fMinimalStep;
  64                 }
  65
  66                 // get relative distances in view coordinates
  67                 double fViewStepX((rViewInformation.getObjectToViewTransformation() * basegfx::B2DVector(fStepX, 0.0)).getLength());
  68                 double fViewStepY((rViewInformation.getObjectToViewTransformation() * basegfx::B2DVector(0.0, fStepY)).getLength());
  69                 double fSmallStepX(1.0), fViewSmallStepX(1.0), fSmallStepY(1.0), fViewSmallStepY(1.0);
  70                 sal_uInt32 nSmallStepsX(0), nSmallStepsY(0);
  71
  72                 // setup subdivisions
  73                 if(getSubdivisionsX())
  74                 {
  75                     fSmallStepX = fStepX / getSubdivisionsX();
  76                     fViewSmallStepX = fViewStepX / getSubdivisionsX();
  77                 }
  78
  79                 if(getSubdivisionsY())
  80                 {
  81                     fSmallStepY = fStepY / getSubdivisionsY();
  82                     fViewSmallStepY = fViewStepY / getSubdivisionsY();
  83                 }
  84
  85                 // correct step width
  86                 while(fViewStepX < getSmallestViewDistance())
  87                 {
  88                     fViewStepX *= 2.0;
  89                     fStepX *= 2.0;
  90                 }
  91
  92                 while(fViewStepY < getSmallestViewDistance())
  93                 {
  94                     fViewStepY *= 2.0;
  95                     fStepY *= 2.0;
  96                 }
  97
  98                 // correct small step width
  99                 if(getSubdivisionsX())
 100                 {
 101                     while(fViewSmallStepX < getSmallestSubdivisionViewDistance())
 102                     {
 103                         fViewSmallStepX *= 2.0;
 104                         fSmallStepX *= 2.0;
 105                     }
 106
 107                     nSmallStepsX = static_cast<sal_uInt32>(fStepX / fSmallStepX);
 108                 }
 109
 110                 if(getSubdivisionsY())
 111                 {
 112                     while(fViewSmallStepY < getSmallestSubdivisionViewDistance())
 113                     {
 114                         fViewSmallStepY *= 2.0;
 115                         fSmallStepY *= 2.0;
 116                     }
 117
 118                     nSmallStepsY = static_cast<sal_uInt32>(fStepY / fSmallStepY);
 119                 }
 120
 121                 // calculate extended viewport in which grid points may lie at all
 122                 basegfx::B2DRange aExtendedViewport;
 123
 124                 if(rViewInformation.getDiscreteViewport().isEmpty())
 125                 {
 126                     // not set, use logic size to travel over all potential grid points
 127                     aExtendedViewport = basegfx::B2DRange(0.0, 0.0, aScale.getX(), aScale.getY());
 128                 }
 129                 else
 130                 {
 131                     // transform unit range to discrete view
 132                     aExtendedViewport = basegfx::B2DRange(0.0, 0.0, 1.0, 1.0);
 133                     basegfx::B2DHomMatrix aTrans(rViewInformation.getObjectToViewTransformation() * getTransform());
 134                     aExtendedViewport.transform(aTrans);
 135
 136                     // intersect with visible part
 137                     aExtendedViewport.intersect(rViewInformation.getDiscreteViewport());
 138
 139                     if(!aExtendedViewport.isEmpty())
 140                     {
 141                         // convert back and apply scale
 142                         aTrans.invert();
 143                         aTrans.scale(aScale.getX(), aScale.getY());
 144                         aExtendedViewport.transform(aTrans);
 145
 146                         // crop start/end in X/Y to multiples of logical step width
 147                         const double fHalfCrossSize((rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(3.0, 0.0)).getLength());
 148                         const double fMinX(floor((aExtendedViewport.getMinX() - fHalfCrossSize) / fStepX) * fStepX);
 149                         const double fMaxX(ceil((aExtendedViewport.getMaxX() + fHalfCrossSize) / fStepX) * fStepX);
 150                         const double fMinY(floor((aExtendedViewport.getMinY() - fHalfCrossSize) / fStepY) * fStepY);
 151                         const double fMaxY(ceil((aExtendedViewport.getMaxY() + fHalfCrossSize) / fStepY) * fStepY);
 152
 153                         // put to aExtendedViewport and crop on object logic size
 154                         aExtendedViewport = basegfx::B2DRange(
 155                             std::max(fMinX, 0.0),
 156                             std::max(fMinY, 0.0),
 157                             std::min(fMaxX, aScale.getX()),
 158                             std::min(fMaxY, aScale.getY()));
 159                     }
 160                 }
 161
 162                 if(!aExtendedViewport.isEmpty())
 163                 {
 164                     // prepare point vectors for point and cross markers
 165                     std::vector< basegfx::B2DPoint > aPositionsPoint;
 166                     std::vector< basegfx::B2DPoint > aPositionsCross;
 167
 168                     for(double fX(aExtendedViewport.getMinX()); fX < aExtendedViewport.getMaxX(); fX += fStepX)
 169                     {
 170                         const bool bXZero(basegfx::fTools::equalZero(fX));
 171
 172                         for(double fY(aExtendedViewport.getMinY()); fY < aExtendedViewport.getMaxY(); fY += fStepY)
 173                         {
 174                             const bool bYZero(basegfx::fTools::equalZero(fY));
 175
 176                             if(!bXZero && !bYZero)
 177                             {
 178                                 // get discrete position and test against 3x3 area surrounding it
 179                                 // since it's a cross
 180                                 const double fHalfCrossSize(3.0 * 0.5);
 181                                 const basegfx::B2DPoint aViewPos(aRST * basegfx::B2DPoint(fX, fY));
 182                                 const basegfx::B2DRange aDiscreteRangeCross(
 183                                     aViewPos.getX() - fHalfCrossSize, aViewPos.getY() - fHalfCrossSize,
 184                                     aViewPos.getX() + fHalfCrossSize, aViewPos.getY() + fHalfCrossSize);
 185
 186                                 if(rViewInformation.getDiscreteViewport().overlaps(aDiscreteRangeCross))
 187                                 {
 188                                     const basegfx::B2DPoint aLogicPos(rViewInformation.getInverseObjectToViewTransformation() * aViewPos);
 189                                     aPositionsCross.push_back(aLogicPos);
 190                                 }
 191                             }
 192
 193                             if(getSubdivisionsX() && !bYZero)
 194                             {
 195                                 double fF(fX + fSmallStepX);
 196
 197                                 for(sal_uInt32 a(1); a < nSmallStepsX && fF < aExtendedViewport.getMaxX(); a++, fF += fSmallStepX)
 198                                 {
 199                                     const basegfx::B2DPoint aViewPos(aRST * basegfx::B2DPoint(fF, fY));
 200
 201                                     if(rViewInformation.getDiscreteViewport().isInside(aViewPos))
 202                                     {
 203                                         const basegfx::B2DPoint aLogicPos(rViewInformation.getInverseObjectToViewTransformation() * aViewPos);
 204                                         aPositionsPoint.push_back(aLogicPos);
 205                                     }
 206                                 }
 207                             }
 208
 209                             if(getSubdivisionsY() && !bXZero)
 210                             {
 211                                 double fF(fY + fSmallStepY);
 212
 213                                 for(sal_uInt32 a(1); a < nSmallStepsY && fF < aExtendedViewport.getMaxY(); a++, fF += fSmallStepY)
 214                                 {
 215                                     const basegfx::B2DPoint aViewPos(aRST * basegfx::B2DPoint(fX, fF));
 216
 217                                     if(rViewInformation.getDiscreteViewport().isInside(aViewPos))
 218                                     {
 219                                         const basegfx::B2DPoint aLogicPos(rViewInformation.getInverseObjectToViewTransformation() * aViewPos);
 220                                         aPositionsPoint.push_back(aLogicPos);
 221                                     }
 222                                 }
 223                             }
 224                         }
 225                     }
 226
 227                     // prepare return value
 228                     const sal_uInt32 nCountPoint(aPositionsPoint.size());
 229                     const sal_uInt32 nCountCross(aPositionsCross.size());
 230
 231                     // add PointArrayPrimitive2D if point markers were added
 232                     if(nCountPoint)
 233                     {
 234                         rContainer.push_back(new PointArrayPrimitive2D(aPositionsPoint, getBColor()));
 235                     }
 236
 237                     // add MarkerArrayPrimitive2D if cross markers were added
 238                     if(nCountCross)
 239                     {
 240                         if(!getSubdivisionsX() && !getSubdivisionsY())
 241                         {
 242                             // no subdivisions, so fall back to points at grid positions, no need to
 243                             // visualize a difference between divisions and sub-divisions
 244                             rContainer.push_back(new PointArrayPrimitive2D(aPositionsCross, getBColor()));
 245                         }
 246                         else
 247                         {
 248                             rContainer.push_back(new MarkerArrayPrimitive2D(aPositionsCross, getCrossMarker()));
 249                         }
 250                     }
 251                 }
 252             }
 253         }
 254
 255         GridPrimitive2D::GridPrimitive2D(
 256             const basegfx::B2DHomMatrix& rTransform,
 257             double fWidth,
 258             double fHeight,
 259             double fSmallestViewDistance,
 260             double fSmallestSubdivisionViewDistance,
 261             sal_uInt32 nSubdivisionsX,
 262             sal_uInt32 nSubdivisionsY,
 263             const basegfx::BColor& rBColor,
 264             const BitmapEx& rCrossMarker)
 265         :   BufferedDecompositionPrimitive2D(),
 266             maTransform(rTransform),
 267             mfWidth(fWidth),
 268             mfHeight(fHeight),
 269             mfSmallestViewDistance(fSmallestViewDistance),
 270             mfSmallestSubdivisionViewDistance(fSmallestSubdivisionViewDistance),
 271             mnSubdivisionsX(nSubdivisionsX),
 272             mnSubdivisionsY(nSubdivisionsY),
 273             maBColor(rBColor),
 274             maCrossMarker(rCrossMarker),
 275             maLastObjectToViewTransformation(),
 276             maLastViewport()
 277         {
 278         }
 279
 280         bool GridPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 281         {
 282             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
 283             {
 284                 const GridPrimitive2D& rCompare = static_cast<const GridPrimitive2D&>(rPrimitive);
 285
 286                 return (getTransform() == rCompare.getTransform()
 287                     && getWidth() == rCompare.getWidth()
 288                     && getHeight() == rCompare.getHeight()
 289                     && getSmallestViewDistance() == rCompare.getSmallestViewDistance()
 290                     && getSmallestSubdivisionViewDistance() == rCompare.getSmallestSubdivisionViewDistance()
 291                     && getSubdivisionsX() == rCompare.getSubdivisionsX()
 292                     && getSubdivisionsY() == rCompare.getSubdivisionsY()
 293                     && getBColor() == rCompare.getBColor()
 294                     && getCrossMarker() == rCompare.getCrossMarker());
 295             }
 296
 297             return false;
 298         }
 299
 300         basegfx::B2DRange GridPrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
 301         {
 302             // get object's range
 303             basegfx::B2DRange aUnitRange(0.0, 0.0, 1.0, 1.0);
 304             aUnitRange.transform(getTransform());
 305
 306             // intersect with visible part
 307             aUnitRange.intersect(rViewInformation.getViewport());
 308
 309             return aUnitRange;
 310         }
 311
 312         void GridPrimitive2D::get2DDecomposition(Primitive2DDecompositionVisitor& rVisitor, const geometry::ViewInformation2D& rViewInformation) const
 313         {
 314             ::osl::MutexGuard aGuard( m_aMutex );
 315
 316             if(!getBuffered2DDecomposition().empty())
 317             {
 318                 if(maLastViewport != rViewInformation.getViewport() || maLastObjectToViewTransformation != rViewInformation.getObjectToViewTransformation())
 319                 {
 320                     // conditions of last local decomposition have changed, delete
 321                     const_cast< GridPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DContainer());
 322                 }
 323             }
 324
 325             if(getBuffered2DDecomposition().empty())
 326             {
 327                 // remember ViewRange and ViewTransformation
 328                 const_cast< GridPrimitive2D* >(this)->maLastObjectToViewTransformation = rViewInformation.getObjectToViewTransformation();
 329                 const_cast< GridPrimitive2D* >(this)->maLastViewport = rViewInformation.getViewport();
 330             }
 331
 332             // use parent implementation
 333             BufferedDecompositionPrimitive2D::get2DDecomposition(rVisitor, rViewInformation);
 334         }
 335
 336         // provide unique ID
 337         ImplPrimitive2DIDBlock(GridPrimitive2D, PRIMITIVE2D_ID_GRIDPRIMITIVE2D)
 338
 339     } // end of namespace primitive2d
 340 } // end of namespace drawinglayer
 341
 342 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */