svx/source/sdr/primitive2d/sdrmeasureprimitive2d.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 <svx/sdr/primitive2d/sdrmeasureprimitive2d.hxx>
  21 #include <svx/sdr/primitive2d/sdrdecompositiontools.hxx>
  22 #include <basegfx/matrix/b2dhommatrix.hxx>
  23 #include <svx/sdr/primitive2d/sdrtextprimitive2d.hxx>
  24 #include <svx/sdr/attribute/sdrtextattribute.hxx>
  25 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  26 #include <basegfx/tools/canvastools.hxx>
  27 #include <drawinglayer/primitive2d/groupprimitive2d.hxx>
  28 #include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx>
  29 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  30 #include <drawinglayer/primitive2d/hiddengeometryprimitive2d.hxx>
  31
  32 //////////////////////////////////////////////////////////////////////////////
  33
  34 using namespace com::sun::star;
  35
  36 //////////////////////////////////////////////////////////////////////////////
  37
  38 namespace drawinglayer
  39 {
  40     namespace primitive2d
  41     {
  42         Primitive2DReference SdrMeasurePrimitive2D::impCreatePart(
  43             const attribute::SdrLineAttribute& rLineAttribute,
  44             const basegfx::B2DHomMatrix& rObjectMatrix,
  45             const basegfx::B2DPoint& rStart,
  46             const basegfx::B2DPoint& rEnd,
  47             bool bLeftActive,
  48             bool bRightActive) const
  49         {
  50             const attribute::SdrLineStartEndAttribute& rLineStartEnd = getSdrLSTAttribute().getLineStartEnd();
  51             basegfx::B2DPolygon aPolygon;
  52
  53             aPolygon.append(rStart);
  54             aPolygon.append(rEnd);
  55
  56             if(rLineStartEnd.isDefault() || (!bLeftActive && !bRightActive))
  57             {
  58                 return createPolygonLinePrimitive(
  59                     aPolygon,
  60                     rObjectMatrix,
  61                     rLineAttribute,
  62                     attribute::SdrLineStartEndAttribute());
  63             }
  64
  65             if(bLeftActive && bRightActive)
  66             {
  67                 return createPolygonLinePrimitive(
  68                     aPolygon,
  69                     rObjectMatrix,
  70                     rLineAttribute,
  71                     rLineStartEnd);
  72             }
  73
  74             const basegfx::B2DPolyPolygon aEmpty;
  75             const attribute::SdrLineStartEndAttribute aLineStartEnd(
  76                 bLeftActive ? rLineStartEnd.getStartPolyPolygon() : aEmpty, bRightActive ? rLineStartEnd.getEndPolyPolygon() : aEmpty,
  77                 bLeftActive ? rLineStartEnd.getStartWidth() : 0.0, bRightActive ? rLineStartEnd.getEndWidth() : 0.0,
  78                 bLeftActive ? rLineStartEnd.isStartActive() : false, bRightActive ? rLineStartEnd.isEndActive() : false,
  79                 bLeftActive ? rLineStartEnd.isStartCentered() : false, bRightActive? rLineStartEnd.isEndCentered() : false);
  80
  81             return createPolygonLinePrimitive(aPolygon, rObjectMatrix, rLineAttribute, aLineStartEnd);
  82         }
  83
  84         Primitive2DSequence SdrMeasurePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& aViewInformation) const
  85         {
  86             Primitive2DSequence aRetval;
  87             SdrBlockTextPrimitive2D* pBlockText = 0;
  88             basegfx::B2DRange aTextRange;
  89             double fTextX((getStart().getX() + getEnd().getX()) * 0.5);
  90             double fTextY((getStart().getX() + getEnd().getX()) * 0.5);
  91             const basegfx::B2DVector aLine(getEnd() - getStart());
  92             const double fDistance(aLine.getLength());
  93             const double fAngle(atan2(aLine.getY(), aLine.getX()));
  94             bool bAutoUpsideDown(false);
  95             const attribute::SdrTextAttribute rTextAttribute = getSdrLSTAttribute().getText();
  96             const basegfx::B2DHomMatrix aObjectMatrix(
  97                 basegfx::tools::createShearXRotateTranslateB2DHomMatrix(0.0, fAngle, getStart()));
  98
  99             // preapare text, but do not add yet; it needs to be aligned to
 100             // the line geometry
 101             if(!rTextAttribute.isDefault())
 102             {
 103                 basegfx::B2DHomMatrix aTextMatrix;
 104                 double fTestAngle(fAngle);
 105
 106                 if(getTextRotation())
 107                 {
 108                     aTextMatrix.rotate(-90.0 * F_PI180);
 109                     fTestAngle -= (90.0 * F_PI180);
 110
 111                     if(getTextAutoAngle() && fTestAngle < -F_PI)
 112                     {
 113                         fTestAngle += F_2PI;
 114                     }
 115                 }
 116
 117                 if(getTextAutoAngle())
 118                 {
 119                     if(fTestAngle > (F_PI / 4.0) || fTestAngle < (-F_PI * (3.0 / 4.0)))
 120                     {
 121                         bAutoUpsideDown = true;
 122                     }
 123                 }
 124
 125                 // create primitive and get text range
 126                 pBlockText = new SdrBlockTextPrimitive2D(
 127                     &rTextAttribute.getSdrText(),
 128                     rTextAttribute.getOutlinerParaObject(),
 129                     aTextMatrix,
 130                     SDRTEXTHORZADJUST_CENTER,
 131                     SDRTEXTVERTADJUST_CENTER,
 132                     rTextAttribute.isScroll(),
 133                     false,
 134                     false,
 135                     false,
 136                     false);
 137
 138                 aTextRange = pBlockText->getB2DRange(aViewInformation);
 139             }
 140
 141             // prepare line attribute and result
 142             {
 143                 const attribute::SdrLineAttribute rLineAttribute(getSdrLSTAttribute().getLine());
 144                 bool bArrowsOutside(false);
 145                 bool bMainLineSplitted(false);
 146                 const attribute::SdrLineStartEndAttribute& rLineStartEnd = getSdrLSTAttribute().getLineStartEnd();
 147                 double fStartArrowW(0.0);
 148                 double fStartArrowH(0.0);
 149                 double fEndArrowW(0.0);
 150                 double fEndArrowH(0.0);
 151
 152                 if(!rLineStartEnd.isDefault())
 153                 {
 154                     if(rLineStartEnd.isStartActive())
 155                     {
 156                         const basegfx::B2DRange aArrowRange(basegfx::tools::getRange(rLineStartEnd.getStartPolyPolygon()));
 157                         fStartArrowW = rLineStartEnd.getStartWidth();
 158                         fStartArrowH = aArrowRange.getHeight() * fStartArrowW / aArrowRange.getWidth();
 159
 160                         if(rLineStartEnd.isStartCentered())
 161                         {
 162                             fStartArrowH *= 0.5;
 163                         }
 164                     }
 165
 166                     if(rLineStartEnd.isEndActive())
 167                     {
 168                         const basegfx::B2DRange aArrowRange(basegfx::tools::getRange(rLineStartEnd.getEndPolyPolygon()));
 169                         fEndArrowW = rLineStartEnd.getEndWidth();
 170                         fEndArrowH = aArrowRange.getHeight() * fEndArrowW / aArrowRange.getWidth();
 171
 172                         if(rLineStartEnd.isEndCentered())
 173                         {
 174                             fEndArrowH *= 0.5;
 175                         }
 176                     }
 177                 }
 178
 179                 const double fSpaceNeededByArrows(fStartArrowH + fEndArrowH + ((fStartArrowW + fEndArrowW) * 0.5));
 180                 const double fArrowsOutsideLen((fStartArrowH + fEndArrowH + fStartArrowW + fEndArrowW) * 0.5);
 181                 const double fHalfLineWidth(rLineAttribute.getWidth() * 0.5);
 182
 183                 if(fSpaceNeededByArrows > fDistance)
 184                 {
 185                     bArrowsOutside = true;
 186                 }
 187
 188                 MeasureTextPosition eHorizontal(getHorizontal());
 189                 MeasureTextPosition eVertical(getVertical());
 190
 191                 if(MEASURETEXTPOSITION_AUTOMATIC == eVertical)
 192                 {
 193                     eVertical = MEASURETEXTPOSITION_NEGATIVE;
 194                 }
 195
 196                 if(MEASURETEXTPOSITION_CENTERED == eVertical)
 197                 {
 198                     bMainLineSplitted = true;
 199                 }
 200
 201                 if(MEASURETEXTPOSITION_AUTOMATIC == eHorizontal)
 202                 {
 203                     if(aTextRange.getWidth() > fDistance)
 204                     {
 205                         eHorizontal = MEASURETEXTPOSITION_NEGATIVE;
 206                     }
 207                     else
 208                     {
 209                         eHorizontal = MEASURETEXTPOSITION_CENTERED;
 210                     }
 211
 212                     if(bMainLineSplitted)
 213                     {
 214                         if(aTextRange.getWidth() + fSpaceNeededByArrows > fDistance)
 215                         {
 216                             bArrowsOutside = true;
 217                         }
 218                     }
 219                     else
 220                     {
 221                         const double fSmallArrowNeed(fStartArrowH + fEndArrowH + ((fStartArrowW + fEndArrowW) * 0.125));
 222
 223                         if(aTextRange.getWidth() + fSmallArrowNeed > fDistance)
 224                         {
 225                             bArrowsOutside = true;
 226                         }
 227                     }
 228                 }
 229
 230                 if(MEASURETEXTPOSITION_CENTERED != eHorizontal)
 231                 {
 232                     bArrowsOutside = true;
 233                 }
 234
 235                 // switch text above/below?
 236                 if(getBelow() || (bAutoUpsideDown && !getTextRotation()))
 237                 {
 238                     if(MEASURETEXTPOSITION_NEGATIVE == eVertical)
 239                     {
 240                         eVertical = MEASURETEXTPOSITION_POSITIVE;
 241                     }
 242                     else if(MEASURETEXTPOSITION_POSITIVE == eVertical)
 243                     {
 244                         eVertical = MEASURETEXTPOSITION_NEGATIVE;
 245                     }
 246                 }
 247
 248                 const double fMainLineOffset(getBelow() ? getDistance() : -getDistance());
 249                 const basegfx::B2DPoint aMainLeft(0.0, fMainLineOffset);
 250                 const basegfx::B2DPoint aMainRight(fDistance, fMainLineOffset);
 251
 252                 // main line
 253                 if(bArrowsOutside)
 254                 {
 255                     double fLenLeft(fArrowsOutsideLen);
 256                     double fLenRight(fArrowsOutsideLen);
 257
 258                     if(!bMainLineSplitted)
 259                     {
 260                         if(MEASURETEXTPOSITION_NEGATIVE == eHorizontal)
 261                         {
 262                             fLenLeft = fStartArrowH + aTextRange.getWidth();
 263                         }
 264                         else if(MEASURETEXTPOSITION_POSITIVE == eHorizontal)
 265                         {
 266                             fLenRight = fEndArrowH + aTextRange.getWidth();
 267                         }
 268                     }
 269
 270                     const basegfx::B2DPoint aMainLeftLeft(aMainLeft.getX() - fLenLeft, aMainLeft.getY());
 271                     const basegfx::B2DPoint aMainRightRight(aMainRight.getX() + fLenRight, aMainRight.getY());
 272
 273                     appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, impCreatePart(rLineAttribute, aObjectMatrix, aMainLeftLeft, aMainLeft, false, true));
 274                     appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, impCreatePart(rLineAttribute, aObjectMatrix, aMainRight, aMainRightRight, true, false));
 275
 276                     if(!bMainLineSplitted || MEASURETEXTPOSITION_CENTERED != eHorizontal)
 277                     {
 278                         appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, impCreatePart(rLineAttribute, aObjectMatrix, aMainLeft, aMainRight, false, false));
 279                     }
 280                 }
 281                 else
 282                 {
 283                     if(bMainLineSplitted)
 284                     {
 285                         const double fHalfLength((fDistance - (aTextRange.getWidth() + (fStartArrowH + fEndArrowH) * 0.25)) * 0.5);
 286                         const basegfx::B2DPoint aMainInnerLeft(aMainLeft.getX() + fHalfLength, aMainLeft.getY());
 287                         const basegfx::B2DPoint aMainInnerRight(aMainRight.getX() - fHalfLength, aMainRight.getY());
 288
 289                         appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, impCreatePart(rLineAttribute, aObjectMatrix, aMainLeft, aMainInnerLeft, true, false));
 290                         appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, impCreatePart(rLineAttribute, aObjectMatrix, aMainInnerRight, aMainRight, false, true));
 291                     }
 292                     else
 293                     {
 294                         appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, impCreatePart(rLineAttribute, aObjectMatrix, aMainLeft, aMainRight, true, true));
 295                     }
 296                 }
 297
 298                 // left/right help line value preparation
 299                 const double fTopEdge(getBelow() ? getUpper() + getDistance() : -getUpper() - getDistance());
 300                 const double fBottomLeft(getBelow() ? getLower() - getLeftDelta() : getLeftDelta() - getLower());
 301                 const double fBottomRight(getBelow() ? getLower() - getRightDelta() : getRightDelta() - getLower());
 302
 303                 // left help line
 304                 const basegfx::B2DPoint aLeftUp(0.0, fTopEdge);
 305                 const basegfx::B2DPoint aLeftDown(0.0, fBottomLeft);
 306
 307                 appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, impCreatePart(rLineAttribute, aObjectMatrix, aLeftDown, aLeftUp, false, false));
 308
 309                 // right help line
 310                 const basegfx::B2DPoint aRightUp(fDistance, fTopEdge);
 311                 const basegfx::B2DPoint aRightDown(fDistance, fBottomRight);
 312
 313                 appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, impCreatePart(rLineAttribute, aObjectMatrix, aRightDown, aRightUp, false, false));
 314
 315                 // text horizontal position
 316                 if(MEASURETEXTPOSITION_NEGATIVE == eHorizontal)
 317                 {
 318                     // left
 319                     const double fSmall(fArrowsOutsideLen * 0.18);
 320                     fTextX = aMainLeft.getX() - (fStartArrowH + aTextRange.getWidth() + fSmall + fHalfLineWidth);
 321
 322                     if(bMainLineSplitted)
 323                     {
 324                         fTextX -= (fArrowsOutsideLen - fStartArrowH);
 325                     }
 326
 327                     if(!rTextAttribute.isDefault())
 328                     {
 329                         fTextX -= rTextAttribute.getTextRightDistance();
 330                     }
 331                 }
 332                 else if(MEASURETEXTPOSITION_POSITIVE == eHorizontal)
 333                 {
 334                     // right
 335                     const double fSmall(fArrowsOutsideLen * 0.18);
 336                     fTextX = aMainRight.getX() + (fEndArrowH + fSmall + fHalfLineWidth);
 337
 338                     if(bMainLineSplitted)
 339                     {
 340                         fTextX += (fArrowsOutsideLen - fEndArrowH);
 341                     }
 342
 343                     if(!rTextAttribute.isDefault())
 344                     {
 345                         fTextX += rTextAttribute.getTextLeftDistance();
 346                     }
 347                 }
 348                 else // MEASURETEXTPOSITION_CENTERED
 349                 {
 350                     // centered
 351                     fTextX = aMainLeft.getX() + ((fDistance - aTextRange.getWidth()) * 0.5);
 352
 353                     if(!rTextAttribute.isDefault())
 354                     {
 355                         fTextX += (rTextAttribute.getTextLeftDistance() - rTextAttribute.getTextRightDistance()) / 2L;
 356                     }
 357                 }
 358
 359                 // text vertical position
 360                 if(MEASURETEXTPOSITION_NEGATIVE == eVertical)
 361                 {
 362                     // top
 363                     const double fSmall(fArrowsOutsideLen * 0.10);
 364                     fTextY = aMainLeft.getY() - (aTextRange.getHeight() + fSmall + fHalfLineWidth);
 365
 366                     if(!rTextAttribute.isDefault())
 367                     {
 368                         fTextY -= rTextAttribute.getTextLowerDistance();
 369                     }
 370                 }
 371                 else if(MEASURETEXTPOSITION_POSITIVE == eVertical)
 372                 {
 373                     // bottom
 374                     const double fSmall(fArrowsOutsideLen * 0.10);
 375                     fTextY = aMainLeft.getY() + (fSmall + fHalfLineWidth);
 376
 377                     if(!rTextAttribute.isDefault())
 378                     {
 379                         fTextY += rTextAttribute.getTextUpperDistance();
 380                     }
 381                 }
 382                 else // MEASURETEXTPOSITION_CENTERED
 383                 {
 384                     // centered
 385                     fTextY = aMainLeft.getY() - (aTextRange.getHeight() * 0.5);
 386
 387                     if(!rTextAttribute.isDefault())
 388                     {
 389                         fTextY += (rTextAttribute.getTextUpperDistance() - rTextAttribute.getTextLowerDistance()) / 2L;
 390                     }
 391                 }
 392             }
 393
 394             if(getSdrLSTAttribute().getLine().isDefault())
 395             {
 396                 // embed line geometry to invisible (100% transparent) line group for HitTest
 397                 const Primitive2DReference xHiddenLines(new HiddenGeometryPrimitive2D(aRetval));
 398
 399                 aRetval = Primitive2DSequence(&xHiddenLines, 1);
 400             }
 401
 402             if(pBlockText)
 403             {
 404                 // create transformation to text primitive end position
 405                 basegfx::B2DHomMatrix aChange;
 406
 407                 // handle auto text rotation
 408                 if(bAutoUpsideDown)
 409                 {
 410                     aChange.rotate(F_PI);
 411                 }
 412
 413                 // move from aTextRange.TopLeft to fTextX, fTextY
 414                 aChange.translate(fTextX - aTextRange.getMinX(), fTextY - aTextRange.getMinY());
 415
 416                 // apply object matrix
 417                 aChange *= aObjectMatrix;
 418
 419                 // apply to existing text primitive
 420                 SdrTextPrimitive2D* pNewBlockText = pBlockText->createTransformedClone(aChange);
 421                 OSL_ENSURE(pNewBlockText, "SdrMeasurePrimitive2D::create2DDecomposition: Could not create transformed clone of text primitive (!)");
 422                 delete pBlockText;
 423
 424                 // add to local primitives
 425                 appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, Primitive2DReference(pNewBlockText));
 426             }
 427
 428             // add shadow
 429             if(!getSdrLSTAttribute().getShadow().isDefault())
 430             {
 431                 aRetval = createEmbeddedShadowPrimitive(
 432                     aRetval,
 433                     getSdrLSTAttribute().getShadow());
 434             }
 435
 436             return aRetval;
 437         }
 438
 439         SdrMeasurePrimitive2D::SdrMeasurePrimitive2D(
 440             const attribute::SdrLineShadowTextAttribute& rSdrLSTAttribute,
 441             const basegfx::B2DPoint& rStart,
 442             const basegfx::B2DPoint& rEnd,
 443             MeasureTextPosition eHorizontal,
 444             MeasureTextPosition eVertical,
 445             double fDistance,
 446             double fUpper,
 447             double fLower,
 448             double fLeftDelta,
 449             double fRightDelta,
 450             bool bBelow,
 451             bool bTextRotation,
 452             bool bTextAutoAngle)
 453         :   BufferedDecompositionPrimitive2D(),
 454             maSdrLSTAttribute(rSdrLSTAttribute),
 455             maStart(rStart),
 456             maEnd(rEnd),
 457             meHorizontal(eHorizontal),
 458             meVertical(eVertical),
 459             mfDistance(fDistance),
 460             mfUpper(fUpper),
 461             mfLower(fLower),
 462             mfLeftDelta(fLeftDelta),
 463             mfRightDelta(fRightDelta),
 464             mbBelow(bBelow),
 465             mbTextRotation(bTextRotation),
 466             mbTextAutoAngle(bTextAutoAngle)
 467         {
 468         }
 469
 470         bool SdrMeasurePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 471         {
 472             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
 473             {
 474                 const SdrMeasurePrimitive2D& rCompare = (SdrMeasurePrimitive2D&)rPrimitive;
 475
 476                 return (getStart() == rCompare.getStart()
 477                     && getEnd() == rCompare.getEnd()
 478                     && getHorizontal() == rCompare.getHorizontal()
 479                     && getVertical() == rCompare.getVertical()
 480                     && getDistance() == rCompare.getDistance()
 481                     && getUpper() == rCompare.getUpper()
 482                     && getLower() == rCompare.getLower()
 483                     && getLeftDelta() == rCompare.getLeftDelta()
 484                     && getRightDelta() == rCompare.getRightDelta()
 485                     && getBelow() == rCompare.getBelow()
 486                     && getTextRotation() == rCompare.getTextRotation()
 487                     && getTextAutoAngle() == rCompare.getTextAutoAngle()
 488                     && getSdrLSTAttribute() == rCompare.getSdrLSTAttribute());
 489             }
 490
 491             return false;
 492         }
 493
 494         // provide unique ID
 495         ImplPrimitive2DIDBlock(SdrMeasurePrimitive2D, PRIMITIVE2D_ID_SDRMEASUREPRIMITIVE2D)
 496
 497     } // end of namespace primitive2d
 498 } // end of namespace drawinglayer
 499
 500 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */