svx/source/sdr/primitive2d/sdrtextprimitive2d.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: sdrtextprimitive2d.cxx,v $
  10  *
  11  * $Revision: 1.2.18.1 $
  12  *
  13  * This file is part of OpenOffice.org.
  14  *
  15  * OpenOffice.org is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU Lesser General Public License version 3
  17  * only, as published by the Free Software Foundation.
  18  *
  19  * OpenOffice.org is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Lesser General Public License version 3 for more details
  23  * (a copy is included in the LICENSE file that accompanied this code).
  24  *
  25  * You should have received a copy of the GNU Lesser General Public License
  26  * version 3 along with OpenOffice.org.  If not, see
  27  * <http://www.openoffice.org/license.html>
  28  * for a copy of the LGPLv3 License.
  29  *
  30  ************************************************************************/
  31
  32 #include "precompiled_svx.hxx"
  33 #include <svx/sdr/primitive2d/sdrtextprimitive2d.hxx>
  34 #include <svx/svdotext.hxx>
  35 #include <basegfx/color/bcolor.hxx>
  36 #include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx>
  37 #include <drawinglayer/primitive2d/texthierarchyprimitive2d.hxx>
  38 #include <svx/outlobj.hxx>
  39 #include <svx/editobj.hxx>
  40 #include <svx/flditem.hxx>
  41 #include <drawinglayer/geometry/viewinformation2d.hxx>
  42 #include <unoapi.hxx>
  43 #include <svx/svdpage.hxx>
  44 #include <svx/svdmodel.hxx>
  45 #include <svx/svdoutl.hxx>
  46 #include <com/sun/star/beans/XPropertySet.hpp>
  47
  48 //////////////////////////////////////////////////////////////////////////////
  49
  50 using namespace com::sun::star;
  51
  52 //////////////////////////////////////////////////////////////////////////////
  53
  54 namespace
  55 {
  56     sal_Int16 getPageNumber(const uno::Reference< drawing::XDrawPage >& rxDrawPage)
  57     {
  58         sal_Int16 nRetval(0);
  59         uno::Reference< beans::XPropertySet > xSet(rxDrawPage, uno::UNO_QUERY);
  60
  61         if (xSet.is())
  62         {
  63             try
  64             {
  65                 const uno::Any aNumber(xSet->getPropertyValue(::rtl::OUString::createFromAscii("Number")));
  66                 aNumber >>= nRetval;
  67             }
  68             catch(const uno::Exception&)
  69             {
  70                 OSL_ASSERT(false);
  71             }
  72         }
  73
  74         return nRetval;
  75     }
  76
  77     sal_Int16 getPageCount(const uno::Reference< drawing::XDrawPage >& rxDrawPage)
  78     {
  79         sal_Int16 nRetval(0);
  80         SdrPage* pPage = GetSdrPageFromXDrawPage(rxDrawPage);
  81
  82         if(pPage && pPage->GetModel())
  83         {
  84             const sal_uInt16 nPageCount(pPage->GetModel()->GetPageCount());
  85             nRetval = ((sal_Int16)nPageCount - 1) / 2;
  86         }
  87
  88         return nRetval;
  89     }
  90 } // end of anonymous namespace
  91
  92 //////////////////////////////////////////////////////////////////////////////
  93
  94 namespace drawinglayer
  95 {
  96     namespace primitive2d
  97     {
  98         // support for XTEXT_PAINTSHAPE_BEGIN/XTEXT_PAINTSHAPE_END Metafile comments
  99         // for slideshow. This uses TextHierarchyBlockPrimitive2D to mark a text block.
 100         // ATM there is only one text block per SdrObject, this may get more in the future
 101         Primitive2DSequence SdrTextPrimitive2D::encapsulateWithTextHierarchyBlockPrimitive2D(const Primitive2DSequence& rCandidate) const
 102         {
 103             Primitive2DReference xReference(new TextHierarchyBlockPrimitive2D(rCandidate));
 104             Primitive2DSequence xRetval(&xReference, 1);
 105
 106             return xRetval;
 107         }
 108
 109         SdrTextPrimitive2D::SdrTextPrimitive2D(
 110             const SdrText* pSdrText,
 111             const OutlinerParaObject& rOutlinerParaObject)
 112         :       BasePrimitive2D(),
 113             mrSdrText(const_cast< SdrText* >(pSdrText)),
 114             maOutlinerParaObject(rOutlinerParaObject),
 115             mxLastVisualizingPage(),
 116             mnLastPageNumber(0),
 117             mnLastPageCount(0),
 118             maLastTextBackgroundColor(),
 119             mbLastSpellCheck(false),
 120             mbContainsPageField(false),
 121             mbContainsPageCountField(false),
 122             mbContainsOtherFields(false)
 123         {
 124             const EditTextObject& rETO = maOutlinerParaObject.GetTextObject();
 125
 126             mbContainsPageField = rETO.HasField(SvxPageField::StaticType());
 127             mbContainsPageCountField = rETO.HasField(SvxPagesField::StaticType());
 128             mbContainsOtherFields = rETO.HasField(SvxHeaderField::StaticType())
 129                 || rETO.HasField(SvxFooterField::StaticType())
 130                 || rETO.HasField(SvxDateTimeField::StaticType())
 131                 || rETO.HasField(SvxAuthorField::StaticType());
 132         }
 133
 134         bool SdrTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 135         {
 136             if(BasePrimitive2D::operator==(rPrimitive))
 137             {
 138                 const SdrTextPrimitive2D& rCompare = (SdrTextPrimitive2D&)rPrimitive;
 139
 140                 return (getOutlinerParaObject() == rCompare.getOutlinerParaObject());
 141             }
 142
 143             return false;
 144         }
 145
 146         Primitive2DSequence SdrTextPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
 147         {
 148             const bool bCurrentSpellCheck(getSdrText()
 149                 ? getSdrText()->GetObject().impCheckSpellCheckForDecomposeTextPrimitive()
 150                 : false);
 151             uno::Reference< drawing::XDrawPage > xCurrentlyVisualizingPage;
 152             bool bCurrentlyVisualizingPageIsSet(false);
 153             Color aNewTextBackgroundColor;
 154             bool bNewTextBackgroundColorIsSet(false);
 155             sal_Int16 nCurrentlyValidPageNumber(0);
 156             sal_Int16 nCurrentlyValidPageCount(0);
 157
 158             if(getLocalDecomposition().hasElements())
 159             {
 160                 bool bDoDelete(getLastSpellCheck() != bCurrentSpellCheck);
 161
 162                 // check visualized page
 163                 if(!bDoDelete && (mbContainsPageField || mbContainsPageCountField || mbContainsOtherFields))
 164                 {
 165                     // get visualized page and remember
 166                     xCurrentlyVisualizingPage = rViewInformation.getVisualizedPage();
 167                     bCurrentlyVisualizingPageIsSet = true;
 168
 169                     if(xCurrentlyVisualizingPage != mxLastVisualizingPage)
 170                     {
 171                         bDoDelete = true;
 172                     }
 173
 174                     // #i98870# check visualized PageNumber
 175                     if(!bDoDelete && mbContainsPageField)
 176                     {
 177                         nCurrentlyValidPageNumber = getPageNumber(xCurrentlyVisualizingPage);
 178
 179                         if(nCurrentlyValidPageNumber != mnLastPageNumber)
 180                         {
 181                             bDoDelete = true;
 182                         }
 183                     }
 184
 185                     // #i98870# check visualized PageCount, too
 186                     if(!bDoDelete && mbContainsPageCountField)
 187                     {
 188                         nCurrentlyValidPageCount = getPageCount(xCurrentlyVisualizingPage);
 189
 190                         if(nCurrentlyValidPageCount != mnLastPageCount)
 191                         {
 192                             bDoDelete = true;
 193                         }
 194                     }
 195                 }
 196
 197                 // #i101443#  check change of TextBackgroundolor
 198                 if(!bDoDelete && getSdrText() && getSdrText()->GetModel())
 199                 {
 200                     SdrOutliner& rDrawOutliner = getSdrText()->GetModel()->GetDrawOutliner(0);
 201                     aNewTextBackgroundColor = rDrawOutliner.GetBackgroundColor();
 202                     bNewTextBackgroundColorIsSet = true;
 203
 204                     if(aNewTextBackgroundColor != maLastTextBackgroundColor)
 205                     {
 206                         bDoDelete = true;
 207                     }
 208                 }
 209
 210                 if(bDoDelete)
 211                 {
 212                     const_cast< SdrTextPrimitive2D* >(this)->setLocalDecomposition(Primitive2DSequence());
 213                 }
 214             }
 215
 216             if(!getLocalDecomposition().hasElements())
 217             {
 218                 if(!bCurrentlyVisualizingPageIsSet && mbContainsPageField)
 219                 {
 220                     xCurrentlyVisualizingPage = rViewInformation.getVisualizedPage();
 221                 }
 222
 223                 if(!nCurrentlyValidPageNumber && mbContainsPageField)
 224                 {
 225                     nCurrentlyValidPageNumber = getPageNumber(xCurrentlyVisualizingPage);
 226                 }
 227
 228                 if(!nCurrentlyValidPageCount && mbContainsPageCountField)
 229                 {
 230                     nCurrentlyValidPageCount = getPageCount(xCurrentlyVisualizingPage);
 231                 }
 232
 233                 if(!bNewTextBackgroundColorIsSet && getSdrText() && getSdrText()->GetModel())
 234                 {
 235                     SdrOutliner& rDrawOutliner = getSdrText()->GetModel()->GetDrawOutliner(0);
 236                     aNewTextBackgroundColor = rDrawOutliner.GetBackgroundColor();
 237                 }
 238
 239                 const_cast< SdrTextPrimitive2D* >(this)->setLastSpellCheck(bCurrentSpellCheck);
 240                 const_cast< SdrTextPrimitive2D* >(this)->mxLastVisualizingPage = xCurrentlyVisualizingPage;
 241                 const_cast< SdrTextPrimitive2D* >(this)->mnLastPageNumber = nCurrentlyValidPageNumber;
 242                 const_cast< SdrTextPrimitive2D* >(this)->mnLastPageCount = nCurrentlyValidPageCount;
 243                 const_cast< SdrTextPrimitive2D* >(this)->maLastTextBackgroundColor = aNewTextBackgroundColor;
 244             }
 245
 246             // call parent
 247             return BasePrimitive2D::get2DDecomposition(rViewInformation);
 248         }
 249     } // end of namespace primitive2d
 250 } // end of namespace drawinglayer
 251
 252 //////////////////////////////////////////////////////////////////////////////
 253
 254 namespace drawinglayer
 255 {
 256     namespace primitive2d
 257     {
 258         Primitive2DSequence SdrContourTextPrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& aViewInformation) const
 259         {
 260             Primitive2DSequence aRetval;
 261             const bool bCurrentSpellCheck(getSdrText()
 262                 ? getSdrText()->GetObject().impDecomposeContourTextPrimitive(aRetval, *this, aViewInformation)
 263                 : false);
 264
 265             if(getLastSpellCheck() != bCurrentSpellCheck)
 266             {
 267                 // remember last spell check state; this is part of the decomposition source data definition
 268                 const_cast< SdrContourTextPrimitive2D* >(this)->setLastSpellCheck(bCurrentSpellCheck);
 269             }
 270
 271             return encapsulateWithTextHierarchyBlockPrimitive2D(aRetval);
 272         }
 273
 274         SdrContourTextPrimitive2D::SdrContourTextPrimitive2D(
 275             const SdrText* pSdrText,
 276             const OutlinerParaObject& rOutlinerParaObject,
 277             const basegfx::B2DPolyPolygon& rUnitPolyPolygon,
 278             const basegfx::B2DHomMatrix& rObjectTransform)
 279         :       SdrTextPrimitive2D(pSdrText, rOutlinerParaObject),
 280             maUnitPolyPolygon(rUnitPolyPolygon),
 281             maObjectTransform(rObjectTransform)
 282         {
 283         }
 284
 285         bool SdrContourTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 286         {
 287             if(SdrTextPrimitive2D::operator==(rPrimitive))
 288             {
 289                 const SdrContourTextPrimitive2D& rCompare = (SdrContourTextPrimitive2D&)rPrimitive;
 290
 291                 return (getUnitPolyPolygon() == rCompare.getUnitPolyPolygon()
 292                     && getObjectTransform() == rCompare.getObjectTransform());
 293             }
 294
 295             return false;
 296         }
 297
 298         SdrTextPrimitive2D* SdrContourTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const
 299         {
 300             return new SdrContourTextPrimitive2D(
 301                 getSdrText(),
 302                 getOutlinerParaObject(),
 303                 getUnitPolyPolygon(),
 304                 rTransform * getObjectTransform());
 305         }
 306
 307         // provide unique ID
 308         ImplPrimitrive2DIDBlock(SdrContourTextPrimitive2D, PRIMITIVE2D_ID_SDRCONTOURTEXTPRIMITIVE2D)
 309
 310     } // end of namespace primitive2d
 311 } // end of namespace drawinglayer
 312
 313 //////////////////////////////////////////////////////////////////////////////
 314
 315 namespace drawinglayer
 316 {
 317     namespace primitive2d
 318     {
 319         Primitive2DSequence SdrPathTextPrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& aViewInformation) const
 320         {
 321             Primitive2DSequence aRetval;
 322             const bool bCurrentSpellCheck(getSdrText()
 323                 ? getSdrText()->GetObject().impDecomposePathTextPrimitive(aRetval, *this, aViewInformation)
 324                 : false);
 325
 326             if(getLastSpellCheck() != bCurrentSpellCheck)
 327             {
 328                 // remember last spell check state; this is part of the decomposition source data definition
 329                 const_cast< SdrPathTextPrimitive2D* >(this)->setLastSpellCheck(bCurrentSpellCheck);
 330             }
 331
 332             return encapsulateWithTextHierarchyBlockPrimitive2D(aRetval);
 333         }
 334
 335         SdrPathTextPrimitive2D::SdrPathTextPrimitive2D(
 336             const SdrText* pSdrText,
 337             const OutlinerParaObject& rOutlinerParaObject,
 338             const basegfx::B2DPolyPolygon& rPathPolyPolygon,
 339             const attribute::SdrFormTextAttribute& rSdrFormTextAttribute)
 340         :       SdrTextPrimitive2D(pSdrText, rOutlinerParaObject),
 341             maPathPolyPolygon(rPathPolyPolygon),
 342             maSdrFormTextAttribute(rSdrFormTextAttribute)
 343         {
 344         }
 345
 346         bool SdrPathTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 347         {
 348             if(SdrTextPrimitive2D::operator==(rPrimitive))
 349             {
 350                 const SdrPathTextPrimitive2D& rCompare = (SdrPathTextPrimitive2D&)rPrimitive;
 351
 352                 return (getPathPolyPolygon() == rCompare.getPathPolyPolygon()
 353                     && getSdrFormTextAttribute() == rCompare.getSdrFormTextAttribute());
 354             }
 355
 356             return false;
 357         }
 358
 359         SdrTextPrimitive2D* SdrPathTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const
 360         {
 361             basegfx::B2DPolyPolygon aNewPolyPolygon(getPathPolyPolygon());
 362             aNewPolyPolygon.transform(rTransform);
 363
 364             return new SdrPathTextPrimitive2D(
 365                 getSdrText(),
 366                 getOutlinerParaObject(),
 367                 aNewPolyPolygon,
 368                 getSdrFormTextAttribute());
 369         }
 370
 371         // provide unique ID
 372         ImplPrimitrive2DIDBlock(SdrPathTextPrimitive2D, PRIMITIVE2D_ID_SDRPATHTEXTPRIMITIVE2D)
 373
 374     } // end of namespace primitive2d
 375 } // end of namespace drawinglayer
 376
 377 //////////////////////////////////////////////////////////////////////////////
 378
 379 namespace drawinglayer
 380 {
 381     namespace primitive2d
 382     {
 383         Primitive2DSequence SdrBlockTextPrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& aViewInformation) const
 384         {
 385             Primitive2DSequence aRetval;
 386             const bool bCurrentSpellCheck(getSdrText()
 387                 ? getSdrText()->GetObject().impDecomposeBlockTextPrimitive(aRetval, *this, aViewInformation)
 388                 : false);
 389
 390             if(getLastSpellCheck() != bCurrentSpellCheck)
 391             {
 392                 // remember last spell check state; this is part of the decomposition source data definition
 393                 const_cast< SdrBlockTextPrimitive2D* >(this)->setLastSpellCheck(bCurrentSpellCheck);
 394             }
 395
 396             return encapsulateWithTextHierarchyBlockPrimitive2D(aRetval);
 397         }
 398
 399         SdrBlockTextPrimitive2D::SdrBlockTextPrimitive2D(
 400             const SdrText* pSdrText,
 401             const OutlinerParaObject& rOutlinerParaObject,
 402             const basegfx::B2DHomMatrix& rTextRangeTransform,
 403             bool bUnlimitedPage,
 404             bool bCellText,
 405             bool bWordWrap)
 406         :       SdrTextPrimitive2D(pSdrText, rOutlinerParaObject),
 407             maTextRangeTransform(rTextRangeTransform),
 408             mbUnlimitedPage(bUnlimitedPage),
 409             mbCellText(bCellText),
 410             mbWordWrap(bWordWrap)
 411         {
 412         }
 413
 414         bool SdrBlockTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 415         {
 416             if(SdrTextPrimitive2D::operator==(rPrimitive))
 417             {
 418                 const SdrBlockTextPrimitive2D& rCompare = (SdrBlockTextPrimitive2D&)rPrimitive;
 419
 420                 return (getTextRangeTransform() == rCompare.getTextRangeTransform()
 421                     && getUnlimitedPage() == rCompare.getUnlimitedPage()
 422                     && getCellText() == rCompare.getCellText()
 423                     && getWordWrap() == rCompare.getWordWrap());
 424             }
 425
 426             return false;
 427         }
 428
 429         SdrTextPrimitive2D* SdrBlockTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const
 430         {
 431             return new SdrBlockTextPrimitive2D(
 432                 getSdrText(),
 433                 getOutlinerParaObject(),
 434                 rTransform * getTextRangeTransform(),
 435                 getUnlimitedPage(),
 436                 getCellText(),
 437                 getWordWrap());
 438         }
 439
 440         // provide unique ID
 441         ImplPrimitrive2DIDBlock(SdrBlockTextPrimitive2D, PRIMITIVE2D_ID_SDRBLOCKTEXTPRIMITIVE2D)
 442
 443     } // end of namespace primitive2d
 444 } // end of namespace drawinglayer
 445
 446 //////////////////////////////////////////////////////////////////////////////
 447
 448 namespace drawinglayer
 449 {
 450     namespace primitive2d
 451     {
 452                 Primitive2DSequence SdrAutoFitTextPrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& aViewInformation) const
 453                 {
 454             Primitive2DSequence aRetval;
 455             const bool bCurrentSpellCheck(getSdrText()->GetObject().impDecomposeAutoFitTextPrimitive(aRetval, *this, aViewInformation));
 456
 457             if(getLastSpellCheck() != bCurrentSpellCheck)
 458             {
 459                 // remember last spell check state; this is part of the decomposition source data definition
 460                 const_cast< SdrAutoFitTextPrimitive2D* >(this)->setLastSpellCheck(bCurrentSpellCheck);
 461             }
 462
 463             return encapsulateWithTextHierarchyBlockPrimitive2D(aRetval);
 464                 }
 465
 466                 SdrAutoFitTextPrimitive2D::SdrAutoFitTextPrimitive2D(
 467                         const SdrText* pSdrText,
 468             const OutlinerParaObject& rParaObj,
 469                         const ::basegfx::B2DHomMatrix& rTextRangeTransform,
 470             bool bWordWrap)
 471                 :       SdrTextPrimitive2D(pSdrText, rParaObj),
 472                         maTextRangeTransform(rTextRangeTransform),
 473             mbWordWrap(bWordWrap)
 474                 {
 475                 }
 476
 477                 bool SdrAutoFitTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 478                 {
 479                         if(SdrTextPrimitive2D::operator==(rPrimitive))
 480                         {
 481                                 const SdrBlockTextPrimitive2D& rCompare = (SdrBlockTextPrimitive2D&)rPrimitive;
 482
 483                                 return (getTextRangeTransform() == rCompare.getTextRangeTransform()
 484                     && getWordWrap() == rCompare.getWordWrap());
 485                         }
 486
 487                         return false;
 488                 }
 489
 490                 SdrTextPrimitive2D* SdrAutoFitTextPrimitive2D::createTransformedClone(const ::basegfx::B2DHomMatrix& rTransform) const
 491                 {
 492                         return new SdrAutoFitTextPrimitive2D(getSdrText(), getOutlinerParaObject(), rTransform * getTextRangeTransform(), getWordWrap());
 493                 }
 494
 495                 // provide unique ID
 496                 ImplPrimitrive2DIDBlock(SdrAutoFitTextPrimitive2D, PRIMITIVE2D_ID_SDRAUTOFITTEXTPRIMITIVE2D)
 497
 498         } // end of namespace primitive2d
 499 } // end of namespace drawinglayer
 500
 501 //////////////////////////////////////////////////////////////////////////////
 502
 503 namespace drawinglayer
 504 {
 505         namespace primitive2d
 506         {
 507         Primitive2DSequence SdrStretchTextPrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& aViewInformation) const
 508         {
 509             Primitive2DSequence aRetval;
 510             const bool bCurrentSpellCheck(getSdrText()
 511                 ? getSdrText()->GetObject().impDecomposeStretchTextPrimitive(aRetval, *this, aViewInformation)
 512                 : false);
 513
 514             if(getLastSpellCheck() != bCurrentSpellCheck)
 515             {
 516                 // remember last spell check state; this is part of the decomposition source data definition
 517                 const_cast< SdrStretchTextPrimitive2D* >(this)->setLastSpellCheck(bCurrentSpellCheck);
 518             }
 519
 520             return encapsulateWithTextHierarchyBlockPrimitive2D(aRetval);
 521         }
 522
 523         SdrStretchTextPrimitive2D::SdrStretchTextPrimitive2D(
 524             const SdrText* pSdrText,
 525             const OutlinerParaObject& rOutlinerParaObject,
 526             const basegfx::B2DHomMatrix& rTextRangeTransform)
 527         :       SdrTextPrimitive2D(pSdrText, rOutlinerParaObject),
 528             maTextRangeTransform(rTextRangeTransform)
 529         {
 530         }
 531
 532         bool SdrStretchTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 533         {
 534             if(SdrTextPrimitive2D::operator==(rPrimitive))
 535             {
 536                 const SdrStretchTextPrimitive2D& rCompare = (SdrStretchTextPrimitive2D&)rPrimitive;
 537
 538                 return (getTextRangeTransform() == rCompare.getTextRangeTransform());
 539             }
 540
 541             return false;
 542         }
 543
 544         SdrTextPrimitive2D* SdrStretchTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const
 545         {
 546             return new SdrStretchTextPrimitive2D(
 547                 getSdrText(),
 548                 getOutlinerParaObject(),
 549                 rTransform * getTextRangeTransform());
 550         }
 551
 552         // provide unique ID
 553         ImplPrimitrive2DIDBlock(SdrStretchTextPrimitive2D, PRIMITIVE2D_ID_SDRSTRETCHTEXTPRIMITIVE2D)
 554
 555     } // end of namespace primitive2d
 556 } // end of namespace drawinglayer
 557
 558 //////////////////////////////////////////////////////////////////////////////
 559 // eof