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             mbContainsPageField(false),
 120             mbContainsPageCountField(false),
 121             mbContainsOtherFields(false)
 122         {
 123             const EditTextObject& rETO = maOutlinerParaObject.GetTextObject();
 124
 125             mbContainsPageField = rETO.HasField(SvxPageField::StaticType());
 126             mbContainsPageCountField = rETO.HasField(SvxPagesField::StaticType());
 127             mbContainsOtherFields = rETO.HasField(SvxHeaderField::StaticType())
 128                 || rETO.HasField(SvxFooterField::StaticType())
 129                 || rETO.HasField(SvxDateTimeField::StaticType())
 130                 || rETO.HasField(SvxAuthorField::StaticType());
 131         }
 132
 133         bool SdrTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 134         {
 135             if(BasePrimitive2D::operator==(rPrimitive))
 136             {
 137                 const SdrTextPrimitive2D& rCompare = (SdrTextPrimitive2D&)rPrimitive;
 138
 139                 return (
 140
 141                     // compare OPO and content, but not WrongList
 142                     getOutlinerParaObject() == rCompare.getOutlinerParaObject()
 143
 144                     // also compare WrongList (not-persistent data, but visualized)
 145                     && getOutlinerParaObject().isWrongListEqual(rCompare.getOutlinerParaObject()));
 146             }
 147
 148             return false;
 149         }
 150
 151         Primitive2DSequence SdrTextPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
 152         {
 153             uno::Reference< drawing::XDrawPage > xCurrentlyVisualizingPage;
 154             bool bCurrentlyVisualizingPageIsSet(false);
 155             Color aNewTextBackgroundColor;
 156             bool bNewTextBackgroundColorIsSet(false);
 157             sal_Int16 nCurrentlyValidPageNumber(0);
 158             sal_Int16 nCurrentlyValidPageCount(0);
 159
 160             if(getLocalDecomposition().hasElements())
 161             {
 162                 bool bDoDelete(false);
 163
 164                 // check visualized page
 165                 if(mbContainsPageField || mbContainsPageCountField || mbContainsOtherFields)
 166                 {
 167                     // get visualized page and remember
 168                     xCurrentlyVisualizingPage = rViewInformation.getVisualizedPage();
 169                     bCurrentlyVisualizingPageIsSet = true;
 170
 171                     if(xCurrentlyVisualizingPage != mxLastVisualizingPage)
 172                     {
 173                         bDoDelete = true;
 174                     }
 175
 176                     // #i98870# check visualized PageNumber
 177                     if(!bDoDelete && mbContainsPageField)
 178                     {
 179                         nCurrentlyValidPageNumber = getPageNumber(xCurrentlyVisualizingPage);
 180
 181                         if(nCurrentlyValidPageNumber != mnLastPageNumber)
 182                         {
 183                             bDoDelete = true;
 184                         }
 185                     }
 186
 187                     // #i98870# check visualized PageCount, too
 188                     if(!bDoDelete && mbContainsPageCountField)
 189                     {
 190                         nCurrentlyValidPageCount = getPageCount(xCurrentlyVisualizingPage);
 191
 192                         if(nCurrentlyValidPageCount != mnLastPageCount)
 193                         {
 194                             bDoDelete = true;
 195                         }
 196                     }
 197                 }
 198
 199                 // #i101443#  check change of TextBackgroundolor
 200                 if(!bDoDelete && getSdrText() && getSdrText()->GetModel())
 201                 {
 202                     SdrOutliner& rDrawOutliner = getSdrText()->GetModel()->GetDrawOutliner(0);
 203                     aNewTextBackgroundColor = rDrawOutliner.GetBackgroundColor();
 204                     bNewTextBackgroundColorIsSet = true;
 205
 206                     if(aNewTextBackgroundColor != maLastTextBackgroundColor)
 207                     {
 208                         bDoDelete = true;
 209                     }
 210                 }
 211
 212                 if(bDoDelete)
 213                 {
 214                     const_cast< SdrTextPrimitive2D* >(this)->setLocalDecomposition(Primitive2DSequence());
 215                 }
 216             }
 217
 218             if(!getLocalDecomposition().hasElements())
 219             {
 220                 if(!bCurrentlyVisualizingPageIsSet && mbContainsPageField)
 221                 {
 222                     xCurrentlyVisualizingPage = rViewInformation.getVisualizedPage();
 223                 }
 224
 225                 if(!nCurrentlyValidPageNumber && mbContainsPageField)
 226                 {
 227                     nCurrentlyValidPageNumber = getPageNumber(xCurrentlyVisualizingPage);
 228                 }
 229
 230                 if(!nCurrentlyValidPageCount && mbContainsPageCountField)
 231                 {
 232                     nCurrentlyValidPageCount = getPageCount(xCurrentlyVisualizingPage);
 233                 }
 234
 235                 if(!bNewTextBackgroundColorIsSet && getSdrText() && getSdrText()->GetModel())
 236                 {
 237                     SdrOutliner& rDrawOutliner = getSdrText()->GetModel()->GetDrawOutliner(0);
 238                     aNewTextBackgroundColor = rDrawOutliner.GetBackgroundColor();
 239                 }
 240
 241                 const_cast< SdrTextPrimitive2D* >(this)->mxLastVisualizingPage = xCurrentlyVisualizingPage;
 242                 const_cast< SdrTextPrimitive2D* >(this)->mnLastPageNumber = nCurrentlyValidPageNumber;
 243                 const_cast< SdrTextPrimitive2D* >(this)->mnLastPageCount = nCurrentlyValidPageCount;
 244                 const_cast< SdrTextPrimitive2D* >(this)->maLastTextBackgroundColor = aNewTextBackgroundColor;
 245             }
 246
 247             // call parent
 248             return BasePrimitive2D::get2DDecomposition(rViewInformation);
 249         }
 250     } // end of namespace primitive2d
 251 } // end of namespace drawinglayer
 252
 253 //////////////////////////////////////////////////////////////////////////////
 254
 255 namespace drawinglayer
 256 {
 257     namespace primitive2d
 258     {
 259         Primitive2DSequence SdrContourTextPrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& aViewInformation) const
 260         {
 261             Primitive2DSequence aRetval;
 262             getSdrText()->GetObject().impDecomposeContourTextPrimitive(aRetval, *this, aViewInformation);
 263
 264             return encapsulateWithTextHierarchyBlockPrimitive2D(aRetval);
 265         }
 266
 267         SdrContourTextPrimitive2D::SdrContourTextPrimitive2D(
 268             const SdrText* pSdrText,
 269             const OutlinerParaObject& rOutlinerParaObject,
 270             const basegfx::B2DPolyPolygon& rUnitPolyPolygon,
 271             const basegfx::B2DHomMatrix& rObjectTransform)
 272         :       SdrTextPrimitive2D(pSdrText, rOutlinerParaObject),
 273             maUnitPolyPolygon(rUnitPolyPolygon),
 274             maObjectTransform(rObjectTransform)
 275         {
 276         }
 277
 278         bool SdrContourTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 279         {
 280             if(SdrTextPrimitive2D::operator==(rPrimitive))
 281             {
 282                 const SdrContourTextPrimitive2D& rCompare = (SdrContourTextPrimitive2D&)rPrimitive;
 283
 284                 return (getUnitPolyPolygon() == rCompare.getUnitPolyPolygon()
 285                     && getObjectTransform() == rCompare.getObjectTransform());
 286             }
 287
 288             return false;
 289         }
 290
 291         SdrTextPrimitive2D* SdrContourTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const
 292         {
 293             return new SdrContourTextPrimitive2D(
 294                 getSdrText(),
 295                 getOutlinerParaObject(),
 296                 getUnitPolyPolygon(),
 297                 rTransform * getObjectTransform());
 298         }
 299
 300         // provide unique ID
 301         ImplPrimitrive2DIDBlock(SdrContourTextPrimitive2D, PRIMITIVE2D_ID_SDRCONTOURTEXTPRIMITIVE2D)
 302
 303     } // end of namespace primitive2d
 304 } // end of namespace drawinglayer
 305
 306 //////////////////////////////////////////////////////////////////////////////
 307
 308 namespace drawinglayer
 309 {
 310     namespace primitive2d
 311     {
 312         Primitive2DSequence SdrPathTextPrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& aViewInformation) const
 313         {
 314             Primitive2DSequence aRetval;
 315             getSdrText()->GetObject().impDecomposePathTextPrimitive(aRetval, *this, aViewInformation);
 316
 317             return encapsulateWithTextHierarchyBlockPrimitive2D(aRetval);
 318         }
 319
 320         SdrPathTextPrimitive2D::SdrPathTextPrimitive2D(
 321             const SdrText* pSdrText,
 322             const OutlinerParaObject& rOutlinerParaObject,
 323             const basegfx::B2DPolyPolygon& rPathPolyPolygon,
 324             const attribute::SdrFormTextAttribute& rSdrFormTextAttribute)
 325         :       SdrTextPrimitive2D(pSdrText, rOutlinerParaObject),
 326             maPathPolyPolygon(rPathPolyPolygon),
 327             maSdrFormTextAttribute(rSdrFormTextAttribute)
 328         {
 329         }
 330
 331         bool SdrPathTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 332         {
 333             if(SdrTextPrimitive2D::operator==(rPrimitive))
 334             {
 335                 const SdrPathTextPrimitive2D& rCompare = (SdrPathTextPrimitive2D&)rPrimitive;
 336
 337                 return (getPathPolyPolygon() == rCompare.getPathPolyPolygon()
 338                     && getSdrFormTextAttribute() == rCompare.getSdrFormTextAttribute());
 339             }
 340
 341             return false;
 342         }
 343
 344         SdrTextPrimitive2D* SdrPathTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const
 345         {
 346             basegfx::B2DPolyPolygon aNewPolyPolygon(getPathPolyPolygon());
 347             aNewPolyPolygon.transform(rTransform);
 348
 349             return new SdrPathTextPrimitive2D(
 350                 getSdrText(),
 351                 getOutlinerParaObject(),
 352                 aNewPolyPolygon,
 353                 getSdrFormTextAttribute());
 354         }
 355
 356         // provide unique ID
 357         ImplPrimitrive2DIDBlock(SdrPathTextPrimitive2D, PRIMITIVE2D_ID_SDRPATHTEXTPRIMITIVE2D)
 358
 359     } // end of namespace primitive2d
 360 } // end of namespace drawinglayer
 361
 362 //////////////////////////////////////////////////////////////////////////////
 363
 364 namespace drawinglayer
 365 {
 366     namespace primitive2d
 367     {
 368         Primitive2DSequence SdrBlockTextPrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& aViewInformation) const
 369         {
 370             Primitive2DSequence aRetval;
 371             getSdrText()->GetObject().impDecomposeBlockTextPrimitive(aRetval, *this, aViewInformation);
 372
 373             return encapsulateWithTextHierarchyBlockPrimitive2D(aRetval);
 374         }
 375
 376         SdrBlockTextPrimitive2D::SdrBlockTextPrimitive2D(
 377             const SdrText* pSdrText,
 378             const OutlinerParaObject& rOutlinerParaObject,
 379             const basegfx::B2DHomMatrix& rTextRangeTransform,
 380             SdrTextHorzAdjust aSdrTextHorzAdjust,
 381             SdrTextVertAdjust aSdrTextVertAdjust,
 382             bool bFixedCellHeight,
 383             bool bUnlimitedPage,
 384             bool bCellText,
 385             bool bWordWrap)
 386         :       SdrTextPrimitive2D(pSdrText, rOutlinerParaObject),
 387             maTextRangeTransform(rTextRangeTransform),
 388             maSdrTextHorzAdjust(aSdrTextHorzAdjust),
 389             maSdrTextVertAdjust(aSdrTextVertAdjust),
 390             mbFixedCellHeight(bFixedCellHeight),
 391             mbUnlimitedPage(bUnlimitedPage),
 392             mbCellText(bCellText),
 393             mbWordWrap(bWordWrap)
 394         {
 395         }
 396
 397         bool SdrBlockTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 398         {
 399             if(SdrTextPrimitive2D::operator==(rPrimitive))
 400             {
 401                 const SdrBlockTextPrimitive2D& rCompare = (SdrBlockTextPrimitive2D&)rPrimitive;
 402
 403                 return (getTextRangeTransform() == rCompare.getTextRangeTransform()
 404                     && getSdrTextHorzAdjust() == rCompare.getSdrTextHorzAdjust()
 405                     && getSdrTextVertAdjust() == rCompare.getSdrTextVertAdjust()
 406                     && isFixedCellHeight() == rCompare.isFixedCellHeight()
 407                     && getUnlimitedPage() == rCompare.getUnlimitedPage()
 408                     && getCellText() == rCompare.getCellText()
 409                     && getWordWrap() == rCompare.getWordWrap());
 410             }
 411
 412             return false;
 413         }
 414
 415         SdrTextPrimitive2D* SdrBlockTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const
 416         {
 417             return new SdrBlockTextPrimitive2D(
 418                 getSdrText(),
 419                 getOutlinerParaObject(),
 420                 rTransform * getTextRangeTransform(),
 421                 getSdrTextHorzAdjust(),
 422                 getSdrTextVertAdjust(),
 423                 isFixedCellHeight(),
 424                 getUnlimitedPage(),
 425                 getCellText(),
 426                 getWordWrap());
 427         }
 428
 429         // provide unique ID
 430         ImplPrimitrive2DIDBlock(SdrBlockTextPrimitive2D, PRIMITIVE2D_ID_SDRBLOCKTEXTPRIMITIVE2D)
 431
 432     } // end of namespace primitive2d
 433 } // end of namespace drawinglayer
 434
 435 //////////////////////////////////////////////////////////////////////////////
 436
 437 namespace drawinglayer
 438 {
 439     namespace primitive2d
 440     {
 441                 Primitive2DSequence SdrAutoFitTextPrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& aViewInformation) const
 442                 {
 443             Primitive2DSequence aRetval;
 444             getSdrText()->GetObject().impDecomposeAutoFitTextPrimitive(aRetval, *this, aViewInformation);
 445
 446             return encapsulateWithTextHierarchyBlockPrimitive2D(aRetval);
 447                 }
 448
 449                 SdrAutoFitTextPrimitive2D::SdrAutoFitTextPrimitive2D(
 450                         const SdrText* pSdrText,
 451             const OutlinerParaObject& rParaObj,
 452                         const ::basegfx::B2DHomMatrix& rTextRangeTransform,
 453             bool bWordWrap)
 454                 :       SdrTextPrimitive2D(pSdrText, rParaObj),
 455                         maTextRangeTransform(rTextRangeTransform),
 456             mbWordWrap(bWordWrap)
 457                 {
 458                 }
 459
 460                 bool SdrAutoFitTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 461                 {
 462                         if(SdrTextPrimitive2D::operator==(rPrimitive))
 463                         {
 464                                 const SdrBlockTextPrimitive2D& rCompare = (SdrBlockTextPrimitive2D&)rPrimitive;
 465
 466                                 return (getTextRangeTransform() == rCompare.getTextRangeTransform()
 467                     && getWordWrap() == rCompare.getWordWrap());
 468                         }
 469
 470                         return false;
 471                 }
 472
 473                 SdrTextPrimitive2D* SdrAutoFitTextPrimitive2D::createTransformedClone(const ::basegfx::B2DHomMatrix& rTransform) const
 474                 {
 475                         return new SdrAutoFitTextPrimitive2D(getSdrText(), getOutlinerParaObject(), rTransform * getTextRangeTransform(), getWordWrap());
 476                 }
 477
 478                 // provide unique ID
 479                 ImplPrimitrive2DIDBlock(SdrAutoFitTextPrimitive2D, PRIMITIVE2D_ID_SDRAUTOFITTEXTPRIMITIVE2D)
 480
 481         } // end of namespace primitive2d
 482 } // end of namespace drawinglayer
 483
 484 //////////////////////////////////////////////////////////////////////////////
 485
 486 namespace drawinglayer
 487 {
 488         namespace primitive2d
 489         {
 490         Primitive2DSequence SdrStretchTextPrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& aViewInformation) const
 491         {
 492             Primitive2DSequence aRetval;
 493             getSdrText()->GetObject().impDecomposeStretchTextPrimitive(aRetval, *this, aViewInformation);
 494
 495             return encapsulateWithTextHierarchyBlockPrimitive2D(aRetval);
 496         }
 497
 498         SdrStretchTextPrimitive2D::SdrStretchTextPrimitive2D(
 499             const SdrText* pSdrText,
 500             const OutlinerParaObject& rOutlinerParaObject,
 501             const basegfx::B2DHomMatrix& rTextRangeTransform,
 502             bool bFixedCellHeight)
 503         :       SdrTextPrimitive2D(pSdrText, rOutlinerParaObject),
 504             maTextRangeTransform(rTextRangeTransform),
 505             mbFixedCellHeight(bFixedCellHeight)
 506         {
 507         }
 508
 509         bool SdrStretchTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 510         {
 511             if(SdrTextPrimitive2D::operator==(rPrimitive))
 512             {
 513                 const SdrStretchTextPrimitive2D& rCompare = (SdrStretchTextPrimitive2D&)rPrimitive;
 514
 515                 return (getTextRangeTransform() == rCompare.getTextRangeTransform()
 516                     && isFixedCellHeight() == rCompare.isFixedCellHeight());
 517             }
 518
 519             return false;
 520         }
 521
 522         SdrTextPrimitive2D* SdrStretchTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const
 523         {
 524             return new SdrStretchTextPrimitive2D(
 525                 getSdrText(),
 526                 getOutlinerParaObject(),
 527                 rTransform * getTextRangeTransform(),
 528                 isFixedCellHeight());
 529         }
 530
 531         // provide unique ID
 532         ImplPrimitrive2DIDBlock(SdrStretchTextPrimitive2D, PRIMITIVE2D_ID_SDRSTRETCHTEXTPRIMITIVE2D)
 533
 534     } // end of namespace primitive2d
 535 } // end of namespace drawinglayer
 536
 537 //////////////////////////////////////////////////////////////////////////////
 538 // eof