svx/source/sdr/primitive2d/sdrtextprimitive2d.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 <sdr/primitive2d/sdrtextprimitive2d.hxx>
  21 #include <svx/svdotext.hxx>
  22 #include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx>
  23 #include <drawinglayer/primitive2d/texthierarchyprimitive2d.hxx>
  24 #include <editeng/outlobj.hxx>
  25 #include <editeng/editobj.hxx>
  26 #include <editeng/flditem.hxx>
  27 #include <drawinglayer/geometry/viewinformation2d.hxx>
  28 #include <svx/unoapi.hxx>
  29 #include <svx/svdpage.hxx>
  30 #include <svx/svdmodel.hxx>
  31 #include <svx/svdoutl.hxx>
  32 #include <com/sun/star/beans/XPropertySet.hpp>
  33 #include <utility>
  34 #include <osl/diagnose.h>
  35
  36
  37 using namespace com::sun::star;
  38
  39
  40 namespace
  41 {
  42     sal_Int16 getPageNumber(const uno::Reference< drawing::XDrawPage >& rxDrawPage)
  43     {
  44         sal_Int16 nRetval(0);
  45         uno::Reference< beans::XPropertySet > xSet(rxDrawPage, uno::UNO_QUERY);
  46
  47         if (xSet.is())
  48         {
  49             try
  50             {
  51                 const uno::Any aNumber(xSet->getPropertyValue("Number"));
  52                 aNumber >>= nRetval;
  53             }
  54             catch(const uno::Exception&)
  55             {
  56                 OSL_ASSERT(false);
  57             }
  58         }
  59
  60         return nRetval;
  61     }
  62
  63     sal_Int16 getPageCount(const uno::Reference< drawing::XDrawPage >& rxDrawPage)
  64     {
  65         sal_Int16 nRetval(0);
  66         SdrPage* pPage = GetSdrPageFromXDrawPage(rxDrawPage);
  67
  68         if(pPage)
  69         {
  70             if( (pPage->GetPageNum() == 0) && !pPage->IsMasterPage() )
  71             {
  72                 // handout page!
  73                 return pPage->getSdrModelFromSdrPage().getHandoutPageCount();
  74             }
  75             else
  76             {
  77                 const sal_uInt16 nPageCount(pPage->getSdrModelFromSdrPage().GetPageCount());
  78                 nRetval = (static_cast<sal_Int16>(nPageCount) - 1) / 2;
  79             }
  80         }
  81
  82         return nRetval;
  83     }
  84 } // end of anonymous namespace
  85
  86
  87 namespace drawinglayer::primitive2d
  88 {
  89         // support for XTEXT_PAINTSHAPE_BEGIN/XTEXT_PAINTSHAPE_END Metafile comments
  90         // for slideshow. This uses TextHierarchyBlockPrimitive2D to mark a text block.
  91         // ATM there is only one text block per SdrObject, this may get more in the future
  92         void SdrTextPrimitive2D::encapsulateWithTextHierarchyBlockPrimitive2D(Primitive2DContainer& rContainer, Primitive2DContainer&& aCandidate)
  93         {
  94             rContainer.push_back(new TextHierarchyBlockPrimitive2D(drawinglayer::primitive2d::Primitive2DContainer(aCandidate)));
  95         }
  96
  97         SdrTextPrimitive2D::SdrTextPrimitive2D(
  98             const SdrText* pSdrText,
  99             OutlinerParaObject aOutlinerParaObject)
 100         :   mxSdrText(const_cast< SdrText* >(pSdrText)),
 101             maOutlinerParaObject(std::move(aOutlinerParaObject)),
 102             mnLastPageNumber(0),
 103             mnLastPageCount(0),
 104             mbContainsPageField(false),
 105             mbContainsPageCountField(false),
 106             mbContainsOtherFields(false)
 107         {
 108             const EditTextObject& rETO = maOutlinerParaObject.GetTextObject();
 109
 110             mbContainsPageField = rETO.HasField(SvxPageField::CLASS_ID);
 111             mbContainsPageCountField = rETO.HasField(SvxPagesField::CLASS_ID);
 112             mbContainsOtherFields = rETO.HasField(SvxHeaderField::CLASS_ID)
 113                 || rETO.HasField(SvxFooterField::CLASS_ID)
 114                 || rETO.HasField(SvxDateTimeField::CLASS_ID)
 115                 || rETO.HasField(SvxAuthorField::CLASS_ID);
 116         }
 117
 118         const SdrText* SdrTextPrimitive2D::getSdrText() const { return mxSdrText.get().get(); }
 119
 120         bool SdrTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 121         {
 122             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
 123             {
 124                 const SdrTextPrimitive2D& rCompare = static_cast<const SdrTextPrimitive2D&>(rPrimitive);
 125
 126                 return (
 127
 128                     // compare OPO and content, but not WrongList
 129                     getOutlinerParaObject() == rCompare.getOutlinerParaObject()
 130
 131                     // also compare WrongList (not-persistent data, but visualized)
 132                     && getOutlinerParaObject().isWrongListEqual(rCompare.getOutlinerParaObject()));
 133             }
 134
 135             return false;
 136         }
 137
 138         void SdrTextPrimitive2D::get2DDecomposition(Primitive2DDecompositionVisitor& rVisitor, const geometry::ViewInformation2D& rViewInformation) const
 139         {
 140             uno::Reference< drawing::XDrawPage > xCurrentlyVisualizingPage;
 141             bool bCurrentlyVisualizingPageIsSet(false);
 142             Color aNewTextBackgroundColor;
 143             bool bNewTextBackgroundColorIsSet(false);
 144             sal_Int16 nCurrentlyValidPageNumber(0);
 145             sal_Int16 nCurrentlyValidPageCount(0);
 146
 147             if(!getBuffered2DDecomposition().empty())
 148             {
 149                 bool bDoDelete(false);
 150
 151                 // check visualized page
 152                 if(mbContainsPageField || mbContainsPageCountField || mbContainsOtherFields)
 153                 {
 154                     // get visualized page and remember
 155                     xCurrentlyVisualizingPage = rViewInformation.getVisualizedPage();
 156                     bCurrentlyVisualizingPageIsSet = true;
 157
 158                     if(xCurrentlyVisualizingPage != mxLastVisualizingPage)
 159                     {
 160                         bDoDelete = true;
 161                     }
 162
 163                     // #i98870# check visualized PageNumber
 164                     if(!bDoDelete && mbContainsPageField)
 165                     {
 166                         nCurrentlyValidPageNumber = getPageNumber(xCurrentlyVisualizingPage);
 167
 168                         if(nCurrentlyValidPageNumber != mnLastPageNumber)
 169                         {
 170                             bDoDelete = true;
 171                         }
 172                     }
 173
 174                     // #i98870# check visualized PageCount, too
 175                     if(!bDoDelete && mbContainsPageCountField)
 176                     {
 177                         nCurrentlyValidPageCount = getPageCount(xCurrentlyVisualizingPage);
 178
 179                         if(nCurrentlyValidPageCount != mnLastPageCount)
 180                         {
 181                             bDoDelete = true;
 182                         }
 183                     }
 184                 }
 185
 186                 // #i101443#  check change of TextBackgroundolor
 187                 if(!bDoDelete && getSdrText())
 188                 {
 189                     SdrOutliner& rDrawOutliner = getSdrText()->GetObject().getSdrModelFromSdrObject().GetDrawOutliner();
 190                     aNewTextBackgroundColor = rDrawOutliner.GetBackgroundColor();
 191                     bNewTextBackgroundColorIsSet = true;
 192
 193                     if(aNewTextBackgroundColor != maLastTextBackgroundColor)
 194                     {
 195                         bDoDelete = true;
 196                     }
 197                 }
 198
 199                 if(bDoDelete)
 200                 {
 201                     const_cast< SdrTextPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DContainer());
 202                 }
 203             }
 204
 205             if(getBuffered2DDecomposition().empty())
 206             {
 207                 if(!bCurrentlyVisualizingPageIsSet && mbContainsPageField)
 208                 {
 209                     xCurrentlyVisualizingPage = rViewInformation.getVisualizedPage();
 210                 }
 211
 212                 if(!nCurrentlyValidPageNumber && mbContainsPageField)
 213                 {
 214                     nCurrentlyValidPageNumber = getPageNumber(xCurrentlyVisualizingPage);
 215                 }
 216
 217                 if(!nCurrentlyValidPageCount && mbContainsPageCountField)
 218                 {
 219                     nCurrentlyValidPageCount = getPageCount(xCurrentlyVisualizingPage);
 220                 }
 221
 222                 if(!bNewTextBackgroundColorIsSet && getSdrText())
 223                 {
 224                     SdrOutliner& rDrawOutliner = getSdrText()->GetObject().getSdrModelFromSdrObject().GetDrawOutliner();
 225                     aNewTextBackgroundColor = rDrawOutliner.GetBackgroundColor();
 226                 }
 227
 228                 const_cast< SdrTextPrimitive2D* >(this)->mxLastVisualizingPage = xCurrentlyVisualizingPage;
 229                 const_cast< SdrTextPrimitive2D* >(this)->mnLastPageNumber = nCurrentlyValidPageNumber;
 230                 const_cast< SdrTextPrimitive2D* >(this)->mnLastPageCount = nCurrentlyValidPageCount;
 231                 const_cast< SdrTextPrimitive2D* >(this)->maLastTextBackgroundColor = aNewTextBackgroundColor;
 232             }
 233
 234             // call parent
 235             BufferedDecompositionPrimitive2D::get2DDecomposition(rVisitor, rViewInformation);
 236         }
 237
 238
 239
 240
 241         void SdrContourTextPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& aViewInformation) const
 242         {
 243             Primitive2DContainer aRetval;
 244             getSdrText()->GetObject().impDecomposeContourTextPrimitive(aRetval, *this, aViewInformation);
 245
 246             encapsulateWithTextHierarchyBlockPrimitive2D(rContainer, std::move(aRetval));
 247         }
 248
 249         SdrContourTextPrimitive2D::SdrContourTextPrimitive2D(
 250             const SdrText* pSdrText,
 251             const OutlinerParaObject& rOutlinerParaObject,
 252             basegfx::B2DPolyPolygon aUnitPolyPolygon,
 253             basegfx::B2DHomMatrix aObjectTransform)
 254         :   SdrTextPrimitive2D(pSdrText, rOutlinerParaObject),
 255             maUnitPolyPolygon(std::move(aUnitPolyPolygon)),
 256             maObjectTransform(std::move(aObjectTransform))
 257         {
 258         }
 259
 260         bool SdrContourTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 261         {
 262             if(SdrTextPrimitive2D::operator==(rPrimitive))
 263             {
 264                 const SdrContourTextPrimitive2D& rCompare = static_cast<const SdrContourTextPrimitive2D&>(rPrimitive);
 265
 266                 return (getUnitPolyPolygon() == rCompare.getUnitPolyPolygon()
 267                     && getObjectTransform() == rCompare.getObjectTransform());
 268             }
 269
 270             return false;
 271         }
 272
 273         rtl::Reference<SdrTextPrimitive2D> SdrContourTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const
 274         {
 275             return new SdrContourTextPrimitive2D(
 276                 getSdrText(),
 277                 getOutlinerParaObject(),
 278                 getUnitPolyPolygon(),
 279                 rTransform * getObjectTransform());
 280         }
 281
 282         // provide unique ID
 283         sal_uInt32 SdrContourTextPrimitive2D::getPrimitive2DID() const
 284         {
 285             return PRIMITIVE2D_ID_SDRCONTOURTEXTPRIMITIVE2D;
 286         }
 287
 288
 289
 290         void SdrPathTextPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& aViewInformation) const
 291         {
 292             Primitive2DContainer aRetval;
 293             getSdrText()->GetObject().impDecomposePathTextPrimitive(aRetval, *this, aViewInformation);
 294
 295             encapsulateWithTextHierarchyBlockPrimitive2D(rContainer, std::move(aRetval));
 296         }
 297
 298         SdrPathTextPrimitive2D::SdrPathTextPrimitive2D(
 299             const SdrText* pSdrText,
 300             const OutlinerParaObject& rOutlinerParaObject,
 301             basegfx::B2DPolyPolygon aPathPolyPolygon,
 302             attribute::SdrFormTextAttribute aSdrFormTextAttribute)
 303         :   SdrTextPrimitive2D(pSdrText, rOutlinerParaObject),
 304             maPathPolyPolygon(std::move(aPathPolyPolygon)),
 305             maSdrFormTextAttribute(std::move(aSdrFormTextAttribute))
 306         {
 307         }
 308
 309         bool SdrPathTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 310         {
 311             if(SdrTextPrimitive2D::operator==(rPrimitive))
 312             {
 313                 const SdrPathTextPrimitive2D& rCompare = static_cast<const SdrPathTextPrimitive2D&>(rPrimitive);
 314
 315                 return (getPathPolyPolygon() == rCompare.getPathPolyPolygon()
 316                     && getSdrFormTextAttribute() == rCompare.getSdrFormTextAttribute());
 317             }
 318
 319             return false;
 320         }
 321
 322         rtl::Reference<SdrTextPrimitive2D> SdrPathTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const
 323         {
 324             basegfx::B2DPolyPolygon aNewPolyPolygon(getPathPolyPolygon());
 325             aNewPolyPolygon.transform(rTransform);
 326
 327             return new SdrPathTextPrimitive2D(
 328                 getSdrText(),
 329                 getOutlinerParaObject(),
 330                 std::move(aNewPolyPolygon),
 331                 getSdrFormTextAttribute());
 332         }
 333
 334         // provide unique ID
 335         sal_uInt32 SdrPathTextPrimitive2D::getPrimitive2DID() const
 336         {
 337             return PRIMITIVE2D_ID_SDRPATHTEXTPRIMITIVE2D;
 338         }
 339
 340
 341
 342         void SdrBlockTextPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& aViewInformation) const
 343         {
 344             Primitive2DContainer aRetval;
 345             getSdrText()->GetObject().impDecomposeBlockTextPrimitive(aRetval, *this, aViewInformation);
 346
 347             encapsulateWithTextHierarchyBlockPrimitive2D(rContainer, std::move(aRetval));
 348         }
 349
 350         SdrBlockTextPrimitive2D::SdrBlockTextPrimitive2D(
 351             const SdrText* pSdrText,
 352             const OutlinerParaObject& rOutlinerParaObject,
 353             basegfx::B2DHomMatrix aTextRangeTransform,
 354             SdrTextHorzAdjust aSdrTextHorzAdjust,
 355             SdrTextVertAdjust aSdrTextVertAdjust,
 356             bool bFixedCellHeight,
 357             bool bUnlimitedPage,
 358             bool bCellText,
 359             bool bWordWrap)
 360         :   SdrTextPrimitive2D(pSdrText, rOutlinerParaObject),
 361             maTextRangeTransform(std::move(aTextRangeTransform)),
 362             maSdrTextHorzAdjust(aSdrTextHorzAdjust),
 363             maSdrTextVertAdjust(aSdrTextVertAdjust),
 364             mbFixedCellHeight(bFixedCellHeight),
 365             mbUnlimitedPage(bUnlimitedPage),
 366             mbCellText(bCellText),
 367             mbWordWrap(bWordWrap)
 368         {
 369         }
 370
 371         bool SdrBlockTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 372         {
 373             if(SdrTextPrimitive2D::operator==(rPrimitive))
 374             {
 375                 const SdrBlockTextPrimitive2D& rCompare = static_cast<const SdrBlockTextPrimitive2D&>(rPrimitive);
 376
 377                 return (getTextRangeTransform() == rCompare.getTextRangeTransform()
 378                     && getSdrTextHorzAdjust() == rCompare.getSdrTextHorzAdjust()
 379                     && getSdrTextVertAdjust() == rCompare.getSdrTextVertAdjust()
 380                     && isFixedCellHeight() == rCompare.isFixedCellHeight()
 381                     && getUnlimitedPage() == rCompare.getUnlimitedPage()
 382                     && getCellText() == rCompare.getCellText()
 383                     && getWordWrap() == rCompare.getWordWrap());
 384             }
 385
 386             return false;
 387         }
 388
 389         rtl::Reference<SdrTextPrimitive2D> SdrBlockTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const
 390         {
 391             return new SdrBlockTextPrimitive2D(
 392                 getSdrText(),
 393                 getOutlinerParaObject(),
 394                 rTransform * getTextRangeTransform(),
 395                 getSdrTextHorzAdjust(),
 396                 getSdrTextVertAdjust(),
 397                 isFixedCellHeight(),
 398                 getUnlimitedPage(),
 399                 getCellText(),
 400                 getWordWrap());
 401         }
 402
 403         // provide unique ID
 404         sal_uInt32 SdrBlockTextPrimitive2D::getPrimitive2DID() const
 405         {
 406             return PRIMITIVE2D_ID_SDRBLOCKTEXTPRIMITIVE2D;
 407         }
 408
 409
 410
 411          void SdrAutoFitTextPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& aViewInformation) const
 412          {
 413              Primitive2DContainer aRetval;
 414              getSdrText()->GetObject().impDecomposeAutoFitTextPrimitive(aRetval, *this, aViewInformation);
 415
 416              encapsulateWithTextHierarchyBlockPrimitive2D(rContainer, std::move(aRetval));
 417          }
 418
 419          SdrAutoFitTextPrimitive2D::SdrAutoFitTextPrimitive2D(
 420              const SdrText* pSdrText,
 421              const OutlinerParaObject& rParaObj,
 422              ::basegfx::B2DHomMatrix aTextRangeTransform,
 423              bool bWordWrap)
 424          :  SdrTextPrimitive2D(pSdrText, rParaObj),
 425              maTextRangeTransform(std::move(aTextRangeTransform)),
 426              mbWordWrap(bWordWrap)
 427          {
 428          }
 429
 430          bool SdrAutoFitTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 431          {
 432              if(SdrTextPrimitive2D::operator==(rPrimitive))
 433              {
 434                  const SdrBlockTextPrimitive2D& rCompare = static_cast<const SdrBlockTextPrimitive2D&>(rPrimitive);
 435
 436                  return (getTextRangeTransform() == rCompare.getTextRangeTransform()
 437                      && getWordWrap() == rCompare.getWordWrap());
 438              }
 439
 440              return false;
 441          }
 442
 443          rtl::Reference<SdrTextPrimitive2D> SdrAutoFitTextPrimitive2D::createTransformedClone(const ::basegfx::B2DHomMatrix& rTransform) const
 444          {
 445              return new SdrAutoFitTextPrimitive2D(getSdrText(), getOutlinerParaObject(), rTransform * getTextRangeTransform(), getWordWrap());
 446          }
 447
 448         // provide unique ID
 449         sal_uInt32 SdrAutoFitTextPrimitive2D::getPrimitive2DID() const
 450         {
 451             return PRIMITIVE2D_ID_SDRAUTOFITTEXTPRIMITIVE2D;
 452         }
 453
 454
 455
 456
 457         SdrChainedTextPrimitive2D::SdrChainedTextPrimitive2D(
 458             const SdrText* pSdrText,
 459             const OutlinerParaObject& rOutlinerParaObject,
 460             basegfx::B2DHomMatrix aTextRangeTransform)
 461         : SdrTextPrimitive2D(pSdrText, rOutlinerParaObject),
 462           maTextRangeTransform(std::move(aTextRangeTransform))
 463         { }
 464
 465         void SdrChainedTextPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& aViewInformation) const
 466         {
 467             Primitive2DContainer aRetval;
 468             getSdrText()->GetObject().impDecomposeChainedTextPrimitive(aRetval, *this, aViewInformation);
 469
 470             encapsulateWithTextHierarchyBlockPrimitive2D(rContainer, std::move(aRetval));
 471         }
 472
 473         bool SdrChainedTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 474          {
 475              if(SdrTextPrimitive2D::operator==(rPrimitive))
 476              {
 477                  const SdrBlockTextPrimitive2D& rCompare = static_cast<const SdrBlockTextPrimitive2D&>(rPrimitive);
 478
 479                  return (getTextRangeTransform() == rCompare.getTextRangeTransform());
 480              }
 481
 482              return false;
 483          }
 484
 485         rtl::Reference<SdrTextPrimitive2D> SdrChainedTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const
 486         {
 487             return new SdrChainedTextPrimitive2D(getSdrText(), getOutlinerParaObject(), rTransform * getTextRangeTransform());
 488         }
 489
 490         // provide unique ID
 491         sal_uInt32 SdrChainedTextPrimitive2D::getPrimitive2DID() const
 492         {
 493             return PRIMITIVE2D_ID_SDRCHAINEDTEXTPRIMITIVE2D;
 494         }
 495
 496
 497         void SdrStretchTextPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& aViewInformation) const
 498         {
 499             Primitive2DContainer aRetval;
 500             getSdrText()->GetObject().impDecomposeStretchTextPrimitive(aRetval, *this, aViewInformation);
 501
 502             encapsulateWithTextHierarchyBlockPrimitive2D(rContainer, std::move(aRetval));
 503         }
 504
 505         SdrStretchTextPrimitive2D::SdrStretchTextPrimitive2D(
 506             const SdrText* pSdrText,
 507             const OutlinerParaObject& rOutlinerParaObject,
 508             basegfx::B2DHomMatrix aTextRangeTransform,
 509             bool bFixedCellHeight)
 510         :   SdrTextPrimitive2D(pSdrText, rOutlinerParaObject),
 511             maTextRangeTransform(std::move(aTextRangeTransform)),
 512             mbFixedCellHeight(bFixedCellHeight)
 513         {
 514         }
 515
 516         bool SdrStretchTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 517         {
 518             if(SdrTextPrimitive2D::operator==(rPrimitive))
 519             {
 520                 const SdrStretchTextPrimitive2D& rCompare = static_cast<const SdrStretchTextPrimitive2D&>(rPrimitive);
 521
 522                 return (getTextRangeTransform() == rCompare.getTextRangeTransform()
 523                     && isFixedCellHeight() == rCompare.isFixedCellHeight());
 524             }
 525
 526             return false;
 527         }
 528
 529         rtl::Reference<SdrTextPrimitive2D> SdrStretchTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const
 530         {
 531             return new SdrStretchTextPrimitive2D(
 532                 getSdrText(),
 533                 getOutlinerParaObject(),
 534                 rTransform * getTextRangeTransform(),
 535                 isFixedCellHeight());
 536         }
 537
 538         // provide unique ID
 539         sal_uInt32 SdrStretchTextPrimitive2D::getPrimitive2DID() const
 540         {
 541             return PRIMITIVE2D_ID_SDRSTRETCHTEXTPRIMITIVE2D;
 542         }
 543
 544 } // end of namespace
 545
 546 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */