svx/source/svdraw/svdotextdecomposition.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: svdotextdecomposition.cxx,v $
  10  *
  11  * $Revision: 1.2.18.2 $
  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 // MARKER(update_precomp.py): autogen include statement, do not remove
  33 #include "precompiled_svx.hxx"
  34
  35 #include <svx/svdotext.hxx>
  36 #include <svx/svdoutl.hxx>
  37 #include <basegfx/vector/b2dvector.hxx>
  38 #include <svx/sdr/primitive2d/sdrtextprimitive2d.hxx>
  39 #include <drawinglayer/primitive2d/textprimitive2d.hxx>
  40 #include <drawinglayer/primitive2d/textdecoratedprimitive2d.hxx>
  41 #include <basegfx/range/b2drange.hxx>
  42 #include <editstat.hxx>
  43 #include <vcl/salbtype.hxx>
  44 #include <svx/sdtfchim.hxx>
  45 #include <svtools/itemset.hxx>
  46 #include <basegfx/polygon/b2dpolygontools.hxx>
  47 #include <basegfx/polygon/b2dpolygon.hxx>
  48 #include <drawinglayer/animation/animationtiming.hxx>
  49 #include <basegfx/color/bcolor.hxx>
  50 #include <vcl/svapp.hxx>
  51 #include <svx/eeitemid.hxx>
  52 #include <svx/escpitem.hxx>
  53 #include <svx/svxenum.hxx>
  54 #include <svx/flditem.hxx>
  55 #include <drawinglayer/primitive2d/texthierarchyprimitive2d.hxx>
  56 #include <vcl/metaact.hxx>
  57 #include <drawinglayer/primitive2d/wrongspellprimitive2d.hxx>
  58 #include <drawinglayer/primitive2d/graphicprimitive2d.hxx>
  59 #include <drawinglayer/primitive2d/textlayoutdevice.hxx>
  60 #include <unoapi.hxx>
  61 #include <drawinglayer/geometry/viewinformation2d.hxx>
  62 #include <svx/outlobj.hxx>
  63
  64 //////////////////////////////////////////////////////////////////////////////
  65 // helpers
  66
  67 namespace
  68 {
  69     drawinglayer::primitive2d::Primitive2DSequence impConvertVectorToPrimitive2DSequence(const std::vector< drawinglayer::primitive2d::BasePrimitive2D* >& rPrimitiveVector)
  70     {
  71         const sal_Int32 nCount(rPrimitiveVector.size());
  72         drawinglayer::primitive2d::Primitive2DSequence aRetval(nCount);
  73
  74         for(sal_Int32 a(0L); a < nCount; a++)
  75         {
  76             aRetval[a] = drawinglayer::primitive2d::Primitive2DReference(rPrimitiveVector[a]);
  77         }
  78
  79         return aRetval;
  80     }
  81
  82     static drawinglayer::primitive2d::FontUnderline mapTextLineStyle(FontUnderline eLineStyle)
  83     {
  84         switch(eLineStyle)
  85         {
  86             case UNDERLINE_SINGLE:          return drawinglayer::primitive2d::FONT_UNDERLINE_SINGLE;
  87             case UNDERLINE_DOUBLE:          return drawinglayer::primitive2d::FONT_UNDERLINE_DOUBLE;
  88             case UNDERLINE_DOTTED:          return drawinglayer::primitive2d::FONT_UNDERLINE_DOTTED;
  89             case UNDERLINE_DASH:            return drawinglayer::primitive2d::FONT_UNDERLINE_DASH;
  90             case UNDERLINE_LONGDASH:        return drawinglayer::primitive2d::FONT_UNDERLINE_LONGDASH;
  91             case UNDERLINE_DASHDOT:         return drawinglayer::primitive2d::FONT_UNDERLINE_DASHDOT;
  92             case UNDERLINE_DASHDOTDOT:      return drawinglayer::primitive2d::FONT_UNDERLINE_DASHDOTDOT;
  93             case UNDERLINE_SMALLWAVE:       return drawinglayer::primitive2d::FONT_UNDERLINE_SMALLWAVE;
  94             case UNDERLINE_WAVE:            return drawinglayer::primitive2d::FONT_UNDERLINE_WAVE;
  95             case UNDERLINE_DOUBLEWAVE:      return drawinglayer::primitive2d::FONT_UNDERLINE_DOUBLEWAVE;
  96             case UNDERLINE_BOLD:            return drawinglayer::primitive2d::FONT_UNDERLINE_BOLD;
  97             case UNDERLINE_BOLDDOTTED:      return drawinglayer::primitive2d::FONT_UNDERLINE_BOLDDOTTED;
  98             case UNDERLINE_BOLDDASH:        return drawinglayer::primitive2d::FONT_UNDERLINE_BOLDDASH;
  99             case UNDERLINE_BOLDLONGDASH:    return drawinglayer::primitive2d::FONT_UNDERLINE_BOLDLONGDASH;
 100             case UNDERLINE_BOLDDASHDOT:     return drawinglayer::primitive2d::FONT_UNDERLINE_BOLDDASHDOT;
 101             case UNDERLINE_BOLDDASHDOTDOT:  return drawinglayer::primitive2d::FONT_UNDERLINE_BOLDDASHDOTDOT;
 102             case UNDERLINE_BOLDWAVE:        return drawinglayer::primitive2d::FONT_UNDERLINE_BOLDWAVE;
 103             // FontUnderline_FORCE_EQUAL_SIZE, UNDERLINE_DONTKNOW, UNDERLINE_NONE
 104             default:                        return drawinglayer::primitive2d::FONT_UNDERLINE_NONE;
 105         }
 106     }
 107
 108     class impTextBreakupHandler
 109     {
 110     private:
 111         std::vector< drawinglayer::primitive2d::BasePrimitive2D* >      maTextPortionPrimitives;
 112         std::vector< drawinglayer::primitive2d::BasePrimitive2D* >      maLinePrimitives;
 113         std::vector< drawinglayer::primitive2d::BasePrimitive2D* >      maParagraphPrimitives;
 114
 115         SdrOutliner&                                                                                            mrOutliner;
 116         basegfx::B2DHomMatrix                                                                           maNewTransformA;
 117         basegfx::B2DHomMatrix                                                                           maNewTransformB;
 118
 119         // the visible area for contour text decomposition
 120         basegfx::B2DVector                                          maScale;
 121
 122         // #SJ# ClipRange for BlockText decomposition; only text portions completely
 123         // inside are to be accepted, so this is different from geometric clipping
 124         // (which would allow e.g. upper parts of portions to remain). Only used for
 125         // BlockText (see there)
 126         basegfx::B2DRange                                           maClipRange;
 127
 128         DECL_LINK(decomposeContourTextPrimitive, DrawPortionInfo* );
 129         DECL_LINK(decomposeBlockTextPrimitive, DrawPortionInfo* );
 130         DECL_LINK(decomposeStretchTextPrimitive, DrawPortionInfo* );
 131
 132         DECL_LINK(decomposeContourBulletPrimitive, DrawBulletInfo* );
 133         DECL_LINK(decomposeBlockBulletPrimitive, DrawBulletInfo* );
 134         DECL_LINK(decomposeStretchBulletPrimitive, DrawBulletInfo* );
 135
 136         bool impIsUnderlineAbove(const Font& rFont) const;
 137         void impCreateTextPortionPrimitive(const DrawPortionInfo& rInfo);
 138         drawinglayer::primitive2d::BasePrimitive2D* impCheckFieldPrimitive(drawinglayer::primitive2d::BasePrimitive2D* pPrimitive, const DrawPortionInfo& rInfo) const;
 139         void impFlushTextPortionPrimitivesToLinePrimitives();
 140         void impFlushLinePrimitivesToParagraphPrimitives();
 141         void impHandleDrawPortionInfo(const DrawPortionInfo& rInfo);
 142         void impHandleDrawBulletInfo(const DrawBulletInfo& rInfo);
 143
 144     public:
 145         impTextBreakupHandler(SdrOutliner& rOutliner)
 146         :       maTextPortionPrimitives(),
 147             maLinePrimitives(),
 148             maParagraphPrimitives(),
 149             mrOutliner(rOutliner),
 150             maNewTransformA(),
 151             maNewTransformB(),
 152             maScale(),
 153             maClipRange()
 154         {
 155         }
 156
 157         void decomposeContourTextPrimitive(const basegfx::B2DHomMatrix& rNewTransformA, const basegfx::B2DHomMatrix& rNewTransformB, const basegfx::B2DVector& rScale)
 158         {
 159             maScale = rScale;
 160             maNewTransformA = rNewTransformA;
 161             maNewTransformB = rNewTransformB;
 162             mrOutliner.SetDrawPortionHdl(LINK(this, impTextBreakupHandler, decomposeContourTextPrimitive));
 163             mrOutliner.SetDrawBulletHdl(LINK(this, impTextBreakupHandler, decomposeContourBulletPrimitive));
 164             mrOutliner.StripPortions();
 165             mrOutliner.SetDrawPortionHdl(Link());
 166             mrOutliner.SetDrawBulletHdl(Link());
 167         }
 168
 169         void decomposeBlockTextPrimitive(
 170             const basegfx::B2DHomMatrix& rNewTransformA,
 171             const basegfx::B2DHomMatrix& rNewTransformB,
 172             const basegfx::B2DRange& rClipRange)
 173         {
 174             maNewTransformA = rNewTransformA;
 175             maNewTransformB = rNewTransformB;
 176             maClipRange = rClipRange;
 177             mrOutliner.SetDrawPortionHdl(LINK(this, impTextBreakupHandler, decomposeBlockTextPrimitive));
 178             mrOutliner.SetDrawBulletHdl(LINK(this, impTextBreakupHandler, decomposeBlockBulletPrimitive));
 179             mrOutliner.StripPortions();
 180             mrOutliner.SetDrawPortionHdl(Link());
 181             mrOutliner.SetDrawBulletHdl(Link());
 182         }
 183
 184         void decomposeStretchTextPrimitive(const basegfx::B2DHomMatrix& rNewTransformA, const basegfx::B2DHomMatrix& rNewTransformB)
 185         {
 186             maNewTransformA = rNewTransformA;
 187             maNewTransformB = rNewTransformB;
 188             mrOutliner.SetDrawPortionHdl(LINK(this, impTextBreakupHandler, decomposeStretchTextPrimitive));
 189             mrOutliner.SetDrawBulletHdl(LINK(this, impTextBreakupHandler, decomposeStretchBulletPrimitive));
 190             mrOutliner.StripPortions();
 191             mrOutliner.SetDrawPortionHdl(Link());
 192             mrOutliner.SetDrawBulletHdl(Link());
 193         }
 194
 195         drawinglayer::primitive2d::Primitive2DSequence getPrimitive2DSequence();
 196     };
 197
 198     bool impTextBreakupHandler::impIsUnderlineAbove(const Font& rFont) const
 199     {
 200         if(!rFont.IsVertical())
 201         {
 202             return false;
 203         }
 204
 205         if((LANGUAGE_JAPANESE == rFont.GetLanguage()) || (LANGUAGE_JAPANESE == rFont.GetCJKContextLanguage()))
 206         {
 207             // the underline is right for Japanese only
 208             return true;
 209         }
 210
 211         return false;
 212     }
 213
 214     void impTextBreakupHandler::impCreateTextPortionPrimitive(const DrawPortionInfo& rInfo)
 215     {
 216         if(rInfo.mrText.Len() && rInfo.mnTextLen)
 217         {
 218             basegfx::B2DVector aFontScaling;
 219             drawinglayer::primitive2d::FontAttributes aFontAttributes(
 220                 drawinglayer::primitive2d::getFontAttributesFromVclFont(
 221                     aFontScaling,
 222                     rInfo.mrFont,
 223                     rInfo.IsRTL(),
 224                     false));
 225             basegfx::B2DHomMatrix aNewTransform;
 226
 227             // add font scale to new transform
 228             aNewTransform.scale(aFontScaling.getX(), aFontScaling.getY());
 229
 230             // look for proportional font scaling, evtl scale accordingly
 231             if(100 != rInfo.mrFont.GetPropr())
 232             {
 233                 const double fFactor(rInfo.mrFont.GetPropr() / 100.0);
 234                 aNewTransform.scale(fFactor, fFactor);
 235             }
 236
 237             // apply font rotate
 238             if(rInfo.mrFont.GetOrientation())
 239             {
 240                 aNewTransform.rotate(-rInfo.mrFont.GetOrientation() * F_PI1800);
 241             }
 242
 243             // look for escapement, evtl translate accordingly
 244             if(rInfo.mrFont.GetEscapement())
 245             {
 246                 sal_Int16 nEsc(rInfo.mrFont.GetEscapement());
 247
 248                 if(DFLT_ESC_AUTO_SUPER == nEsc)
 249                 {
 250                     nEsc = 33;
 251                 }
 252                 else if(DFLT_ESC_AUTO_SUB == nEsc)
 253                 {
 254                     nEsc = -20;
 255                 }
 256
 257                 if(nEsc > 100)
 258                 {
 259                     nEsc = 100;
 260                 }
 261                 else if(nEsc < -100)
 262                 {
 263                     nEsc = -100;
 264                 }
 265
 266                 const double fEscapement(nEsc / -100.0);
 267                 aNewTransform.translate(0.0, fEscapement * aFontScaling.getY());
 268             }
 269
 270             // apply transformA
 271             aNewTransform *= maNewTransformA;
 272
 273             // apply local offset
 274             aNewTransform.translate(rInfo.mrStartPos.X(), rInfo.mrStartPos.Y());
 275
 276             // also apply embedding object's transform
 277             aNewTransform *= maNewTransformB;
 278
 279             // prepare DXArray content. To make it independent from font size (and such from
 280             // the text transformation), scale it to unit coordinates
 281             ::std::vector< double > aDXArray;
 282             static bool bDisableTextArray(false);
 283
 284             if(!bDisableTextArray && rInfo.mpDXArray && rInfo.mnTextLen)
 285             {
 286                 aDXArray.reserve(rInfo.mnTextLen);
 287
 288                 for(xub_StrLen a(0); a < rInfo.mnTextLen; a++)
 289                 {
 290                     aDXArray.push_back((double)rInfo.mpDXArray[a]);
 291                 }
 292             }
 293
 294             // create complex text primitive and append
 295             const Color aFontColor(rInfo.mrFont.GetColor());
 296             const basegfx::BColor aBFontColor(aFontColor.getBColor());
 297
 298             // prepare new primitive
 299             drawinglayer::primitive2d::BasePrimitive2D* pNewPrimitive = 0;
 300             const bool bDecoratedIsNeeded(
 301                    UNDERLINE_NONE != rInfo.mrFont.GetOverline()
 302                 || UNDERLINE_NONE != rInfo.mrFont.GetUnderline()
 303                 || STRIKEOUT_NONE != rInfo.mrFont.GetStrikeout()
 304                 || EMPHASISMARK_NONE != (rInfo.mrFont.GetEmphasisMark() & EMPHASISMARK_STYLE)
 305                 || RELIEF_NONE != rInfo.mrFont.GetRelief()
 306                 || rInfo.mrFont.IsShadow());
 307
 308             if(bDecoratedIsNeeded)
 309             {
 310                 // TextDecoratedPortionPrimitive2D needed, prepare some more data
 311                 // get overline and underline color. If it's on automatic (0xffffffff) use FontColor instead
 312                 const Color aUnderlineColor(rInfo.maTextLineColor);
 313                 const basegfx::BColor aBUnderlineColor((0xffffffff == aUnderlineColor.GetColor()) ? aBFontColor : aUnderlineColor.getBColor());
 314                 const Color aOverlineColor(rInfo.maOverlineColor);
 315                 const basegfx::BColor aBOverlineColor((0xffffffff == aOverlineColor.GetColor()) ? aBFontColor : aOverlineColor.getBColor());
 316
 317                 // prepare overline and underline data
 318                 const drawinglayer::primitive2d::FontUnderline eFontOverline(mapTextLineStyle(rInfo.mrFont.GetOverline()));
 319                 const drawinglayer::primitive2d::FontUnderline eFontUnderline(mapTextLineStyle(rInfo.mrFont.GetUnderline()));
 320
 321                 // check UndelineAbove
 322                 const bool bUnderlineAbove(drawinglayer::primitive2d::FONT_UNDERLINE_NONE != eFontUnderline && impIsUnderlineAbove(rInfo.mrFont));
 323
 324                 // prepare strikeout data
 325                 drawinglayer::primitive2d::FontStrikeout eFontStrikeout(drawinglayer::primitive2d::FONT_STRIKEOUT_NONE);
 326
 327                 switch(rInfo.mrFont.GetStrikeout())
 328                 {
 329                     case STRIKEOUT_SINGLE:      eFontStrikeout = drawinglayer::primitive2d::FONT_STRIKEOUT_SINGLE; break;
 330                     case STRIKEOUT_DOUBLE:      eFontStrikeout = drawinglayer::primitive2d::FONT_STRIKEOUT_DOUBLE; break;
 331                     case STRIKEOUT_BOLD:        eFontStrikeout = drawinglayer::primitive2d::FONT_STRIKEOUT_BOLD; break;
 332                     case STRIKEOUT_SLASH:       eFontStrikeout = drawinglayer::primitive2d::FONT_STRIKEOUT_SLASH; break;
 333                     case STRIKEOUT_X:           eFontStrikeout = drawinglayer::primitive2d::FONT_STRIKEOUT_X; break;
 334                     default : break; // FontStrikeout_FORCE_EQUAL_SIZE, STRIKEOUT_NONE, STRIKEOUT_DONTKNOW
 335                 }
 336
 337                 // prepare wordLineMode (for underline and strikeout)
 338                 // NOT for bullet texts. It is set (this may be an error by itself), but needs to be suppressed to hinder e.g. '1)'
 339                 // to be splitted which would not look like the original
 340                 const bool bWordLineMode(rInfo.mrFont.IsWordLineMode() && !rInfo.mbEndOfBullet);
 341
 342                 // prepare emphasis mark data
 343                 drawinglayer::primitive2d::FontEmphasisMark eFontEmphasisMark(drawinglayer::primitive2d::FONT_EMPHASISMARK_NONE);
 344
 345                 switch(rInfo.mrFont.GetEmphasisMark() & EMPHASISMARK_STYLE)
 346                 {
 347                     case EMPHASISMARK_DOT : eFontEmphasisMark = drawinglayer::primitive2d::FONT_EMPHASISMARK_DOT; break;
 348                     case EMPHASISMARK_CIRCLE : eFontEmphasisMark = drawinglayer::primitive2d::FONT_EMPHASISMARK_CIRCLE; break;
 349                     case EMPHASISMARK_DISC : eFontEmphasisMark = drawinglayer::primitive2d::FONT_EMPHASISMARK_DISC; break;
 350                     case EMPHASISMARK_ACCENT : eFontEmphasisMark = drawinglayer::primitive2d::FONT_EMPHASISMARK_ACCENT; break;
 351                 }
 352
 353                 const bool bEmphasisMarkAbove(rInfo.mrFont.GetEmphasisMark() & EMPHASISMARK_POS_ABOVE);
 354                 const bool bEmphasisMarkBelow(rInfo.mrFont.GetEmphasisMark() & EMPHASISMARK_POS_BELOW);
 355
 356                 // prepare font relief data
 357                 drawinglayer::primitive2d::FontRelief eFontRelief(drawinglayer::primitive2d::FONT_RELIEF_NONE);
 358
 359                 switch(rInfo.mrFont.GetRelief())
 360                 {
 361                     case RELIEF_EMBOSSED : eFontRelief = drawinglayer::primitive2d::FONT_RELIEF_EMBOSSED; break;
 362                     case RELIEF_ENGRAVED : eFontRelief = drawinglayer::primitive2d::FONT_RELIEF_ENGRAVED; break;
 363                     default : break; // RELIEF_NONE, FontRelief_FORCE_EQUAL_SIZE
 364                 }
 365
 366                 // prepare shadow/outline data
 367                 const bool bShadow(rInfo.mrFont.IsShadow());
 368
 369                 // TextDecoratedPortionPrimitive2D is needed, create one
 370                 pNewPrimitive = new drawinglayer::primitive2d::TextDecoratedPortionPrimitive2D(
 371
 372                     // attributes for TextSimplePortionPrimitive2D
 373                     aNewTransform,
 374                     rInfo.mrText,
 375                     rInfo.mnTextStart,
 376                     rInfo.mnTextLen,
 377                     aDXArray,
 378                     aFontAttributes,
 379                     rInfo.mpLocale ? *rInfo.mpLocale : ::com::sun::star::lang::Locale(),
 380                     aBFontColor,
 381
 382                     // attributes for TextDecoratedPortionPrimitive2D
 383                     aBOverlineColor,
 384                     aBUnderlineColor,
 385                     eFontOverline,
 386                     eFontUnderline,
 387                     bUnderlineAbove,
 388                     eFontStrikeout,
 389                     bWordLineMode,
 390                     eFontEmphasisMark,
 391                     bEmphasisMarkAbove,
 392                     bEmphasisMarkBelow,
 393                     eFontRelief,
 394                     bShadow);
 395             }
 396             else
 397             {
 398                 // TextSimplePortionPrimitive2D is enough
 399                 pNewPrimitive = new drawinglayer::primitive2d::TextSimplePortionPrimitive2D(
 400                     aNewTransform,
 401                     rInfo.mrText,
 402                     rInfo.mnTextStart,
 403                     rInfo.mnTextLen,
 404                     aDXArray,
 405                     aFontAttributes,
 406                     rInfo.mpLocale ? *rInfo.mpLocale : ::com::sun::star::lang::Locale(),
 407                     aBFontColor);
 408             }
 409
 410             if(rInfo.mbEndOfBullet)
 411             {
 412                 // embed in TextHierarchyBulletPrimitive2D
 413                 const drawinglayer::primitive2d::Primitive2DReference aNewReference(pNewPrimitive);
 414                 const drawinglayer::primitive2d::Primitive2DSequence aNewSequence(&aNewReference, 1);
 415                 pNewPrimitive = new drawinglayer::primitive2d::TextHierarchyBulletPrimitive2D(aNewSequence);
 416             }
 417
 418             if(rInfo.mpFieldData)
 419             {
 420                 pNewPrimitive = impCheckFieldPrimitive(pNewPrimitive, rInfo);
 421             }
 422
 423             maTextPortionPrimitives.push_back(pNewPrimitive);
 424
 425             // support for WrongSpellVector. Create WrongSpellPrimitives as needed
 426             if(rInfo.mpWrongSpellVector && !aDXArray.empty())
 427             {
 428                 const sal_uInt32 nSize(rInfo.mpWrongSpellVector->size());
 429                 const sal_uInt32 nDXCount(aDXArray.size());
 430                 const basegfx::BColor aSpellColor(1.0, 0.0, 0.0); // red, hard coded
 431
 432                 for(sal_uInt32 a(0); a < nSize; a++)
 433                 {
 434                     const EEngineData::WrongSpellClass& rCandidate = (*rInfo.mpWrongSpellVector)[a];
 435
 436                     if(rCandidate.nStart >= rInfo.mnTextStart && rCandidate.nEnd >= rInfo.mnTextStart && rCandidate.nEnd > rCandidate.nStart)
 437                     {
 438                         const sal_uInt32 nStart(rCandidate.nStart - rInfo.mnTextStart);
 439                         const sal_uInt32 nEnd(rCandidate.nEnd - rInfo.mnTextStart);
 440                         double fStart(0.0);
 441                         double fEnd(0.0);
 442
 443                         if(nStart > 0 && nStart - 1 < nDXCount)
 444                         {
 445                             fStart = aDXArray[nStart - 1];
 446                         }
 447
 448                         if(nEnd > 0 && nEnd - 1 < nDXCount)
 449                         {
 450                             fEnd = aDXArray[nEnd - 1];
 451                         }
 452
 453                         if(!basegfx::fTools::equal(fStart, fEnd))
 454                         {
 455                             if(rInfo.IsRTL())
 456                             {
 457                                 // #i98523#
 458                                 // When the portion is RTL, mirror the redlining using the
 459                                 // full portion width
 460                                 const double fTextWidth(aDXArray[aDXArray.size() - 1]);
 461
 462                                 fStart = fTextWidth - fStart;
 463                                 fEnd = fTextWidth - fEnd;
 464                             }
 465
 466                             // need to take FontScaling out of values; it's already part of
 467                             // aNewTransform and would be double applied
 468                             const double fFontScaleX(aFontScaling.getX());
 469
 470                             if(!basegfx::fTools::equal(fFontScaleX, 1.0)
 471                                 && !basegfx::fTools::equalZero(fFontScaleX))
 472                             {
 473                                 fStart /= fFontScaleX;
 474                                 fEnd /= fFontScaleX;
 475                             }
 476
 477                             maTextPortionPrimitives.push_back(new drawinglayer::primitive2d::WrongSpellPrimitive2D(
 478                                 aNewTransform,
 479                                 fStart,
 480                                 fEnd,
 481                                 aSpellColor));
 482                         }
 483                     }
 484                 }
 485             }
 486         }
 487     }
 488
 489     drawinglayer::primitive2d::BasePrimitive2D* impTextBreakupHandler::impCheckFieldPrimitive(drawinglayer::primitive2d::BasePrimitive2D* pPrimitive, const DrawPortionInfo& rInfo) const
 490     {
 491         if(rInfo.mpFieldData)
 492         {
 493             // Support for FIELD_SEQ_BEGIN, FIELD_SEQ_END. If used, create a TextHierarchyFieldPrimitive2D
 494             // which holds the field type and evtl. the URL
 495             const SvxURLField* pURLField = dynamic_cast< const SvxURLField* >(rInfo.mpFieldData);
 496             const SvxPageField* pPageField = dynamic_cast< const SvxPageField* >(rInfo.mpFieldData);
 497
 498             // embed current primitive to a sequence
 499             drawinglayer::primitive2d::Primitive2DSequence aSequence;
 500
 501             if(pPrimitive)
 502             {
 503                 aSequence.realloc(1);
 504                 aSequence[0] = drawinglayer::primitive2d::Primitive2DReference(pPrimitive);
 505             }
 506
 507             if(pURLField)
 508             {
 509                 pPrimitive = new drawinglayer::primitive2d::TextHierarchyFieldPrimitive2D(aSequence, drawinglayer::primitive2d::FIELD_TYPE_URL, pURLField->GetURL());
 510             }
 511             else if(pPageField)
 512             {
 513                 pPrimitive = new drawinglayer::primitive2d::TextHierarchyFieldPrimitive2D(aSequence, drawinglayer::primitive2d::FIELD_TYPE_PAGE, String());
 514             }
 515             else
 516             {
 517                 pPrimitive = new drawinglayer::primitive2d::TextHierarchyFieldPrimitive2D(aSequence, drawinglayer::primitive2d::FIELD_TYPE_COMMON, String());
 518             }
 519         }
 520
 521         return pPrimitive;
 522     }
 523
 524     void impTextBreakupHandler::impFlushTextPortionPrimitivesToLinePrimitives()
 525     {
 526         // only create a line primitive when we had content; there is no need for
 527         // empty line primitives (contrary to paragraphs, see below).
 528         if(maTextPortionPrimitives.size())
 529         {
 530             drawinglayer::primitive2d::Primitive2DSequence aLineSequence(impConvertVectorToPrimitive2DSequence(maTextPortionPrimitives));
 531             maTextPortionPrimitives.clear();
 532             maLinePrimitives.push_back(new drawinglayer::primitive2d::TextHierarchyLinePrimitive2D(aLineSequence));
 533         }
 534     }
 535
 536     void impTextBreakupHandler::impFlushLinePrimitivesToParagraphPrimitives()
 537     {
 538         // ALWAYS create a paragraph primitive, even when no content was added. This is done to
 539         // have the correct paragraph count even with empty paragraphs. Those paragraphs will
 540         // have an empty sub-PrimitiveSequence.
 541         drawinglayer::primitive2d::Primitive2DSequence aParagraphSequence(impConvertVectorToPrimitive2DSequence(maLinePrimitives));
 542         maLinePrimitives.clear();
 543         maParagraphPrimitives.push_back(new drawinglayer::primitive2d::TextHierarchyParagraphPrimitive2D(aParagraphSequence));
 544     }
 545
 546     void impTextBreakupHandler::impHandleDrawPortionInfo(const DrawPortionInfo& rInfo)
 547     {
 548         impCreateTextPortionPrimitive(rInfo);
 549
 550         if(rInfo.mbEndOfLine || rInfo.mbEndOfParagraph)
 551         {
 552             impFlushTextPortionPrimitivesToLinePrimitives();
 553         }
 554
 555         if(rInfo.mbEndOfParagraph)
 556         {
 557             impFlushLinePrimitivesToParagraphPrimitives();
 558         }
 559     }
 560
 561     void impTextBreakupHandler::impHandleDrawBulletInfo(const DrawBulletInfo& rInfo)
 562     {
 563         basegfx::B2DHomMatrix aNewTransform;
 564
 565         // add size to new transform
 566         aNewTransform.scale(rInfo.maBulletSize.getWidth(), rInfo.maBulletSize.getHeight());
 567
 568         // apply transformA
 569         aNewTransform *= maNewTransformA;
 570
 571         // apply local offset
 572         aNewTransform.translate(rInfo.maBulletPosition.X(), rInfo.maBulletPosition.Y());
 573
 574         // also apply embedding object's transform
 575         aNewTransform *= maNewTransformB;
 576
 577         // prepare empty GraphicAttr
 578         const GraphicAttr aGraphicAttr;
 579
 580         // create GraphicPrimitive2D
 581         const drawinglayer::primitive2d::Primitive2DReference aNewReference(new drawinglayer::primitive2d::GraphicPrimitive2D(
 582             aNewTransform,
 583             rInfo.maBulletGraphicObject,
 584             aGraphicAttr));
 585
 586         // embed in TextHierarchyBulletPrimitive2D
 587         const drawinglayer::primitive2d::Primitive2DSequence aNewSequence(&aNewReference, 1);
 588         drawinglayer::primitive2d::BasePrimitive2D* pNewPrimitive = new drawinglayer::primitive2d::TextHierarchyBulletPrimitive2D(aNewSequence);
 589
 590         // add to output
 591         maTextPortionPrimitives.push_back(pNewPrimitive);
 592     }
 593
 594     IMPL_LINK(impTextBreakupHandler, decomposeContourTextPrimitive, DrawPortionInfo*, pInfo)
 595     {
 596         // for contour text, ignore (clip away) all portions which are below
 597         // the visible area given by maScale
 598         if(pInfo && (double)pInfo->mrStartPos.Y() < maScale.getY())
 599         {
 600             impHandleDrawPortionInfo(*pInfo);
 601         }
 602
 603         return 0;
 604     }
 605
 606     IMPL_LINK(impTextBreakupHandler, decomposeBlockTextPrimitive, DrawPortionInfo*, pInfo)
 607     {
 608         if(pInfo)
 609         {
 610             // #SJ# Is clipping wanted? This is text clipping; only accept a portion
 611             // if it's completely in the range
 612             if(!maClipRange.isEmpty())
 613             {
 614                 // Test start position first; this allows to not get the text range at
 615                 // all if text is far outside
 616                 const basegfx::B2DPoint aStartPosition(pInfo->mrStartPos.X(), pInfo->mrStartPos.Y());
 617
 618                 if(!maClipRange.isInside(aStartPosition))
 619                 {
 620                     return 0;
 621                 }
 622
 623                 // Start position is inside. Get TextBoundRect and TopLeft next
 624                 drawinglayer::primitive2d::TextLayouterDevice aTextLayouterDevice;
 625                 aTextLayouterDevice.setFont(pInfo->mrFont);
 626
 627                 const basegfx::B2DRange aTextBoundRect(
 628                     aTextLayouterDevice.getTextBoundRect(
 629                         pInfo->mrText, pInfo->mnTextStart, pInfo->mnTextLen));
 630                 const basegfx::B2DPoint aTopLeft(aTextBoundRect.getMinimum() + aStartPosition);
 631
 632                 if(!maClipRange.isInside(aTopLeft))
 633                 {
 634                     return 0;
 635                 }
 636
 637                 // TopLeft is inside. Get BottomRight and check
 638                 const basegfx::B2DPoint aBottomRight(aTextBoundRect.getMaximum() + aStartPosition);
 639
 640                 if(!maClipRange.isInside(aBottomRight))
 641                 {
 642                     return 0;
 643                 }
 644
 645                 // all inside, clip was successful
 646             }
 647             impHandleDrawPortionInfo(*pInfo);
 648         }
 649
 650         return 0;
 651     }
 652
 653     IMPL_LINK(impTextBreakupHandler, decomposeStretchTextPrimitive, DrawPortionInfo*, pInfo)
 654     {
 655         if(pInfo)
 656         {
 657             impHandleDrawPortionInfo(*pInfo);
 658         }
 659
 660         return 0;
 661     }
 662
 663     IMPL_LINK(impTextBreakupHandler, decomposeContourBulletPrimitive, DrawBulletInfo*, pInfo)
 664     {
 665         if(pInfo)
 666         {
 667             impHandleDrawBulletInfo(*pInfo);
 668         }
 669
 670         return 0;
 671     }
 672
 673     IMPL_LINK(impTextBreakupHandler, decomposeBlockBulletPrimitive, DrawBulletInfo*, pInfo)
 674     {
 675         if(pInfo)
 676         {
 677             impHandleDrawBulletInfo(*pInfo);
 678         }
 679
 680         return 0;
 681     }
 682
 683     IMPL_LINK(impTextBreakupHandler, decomposeStretchBulletPrimitive, DrawBulletInfo*, pInfo)
 684     {
 685         if(pInfo)
 686         {
 687             impHandleDrawBulletInfo(*pInfo);
 688         }
 689
 690         return 0;
 691     }
 692
 693     drawinglayer::primitive2d::Primitive2DSequence impTextBreakupHandler::getPrimitive2DSequence()
 694     {
 695         if(maTextPortionPrimitives.size())
 696         {
 697             // collect non-closed lines
 698             impFlushTextPortionPrimitivesToLinePrimitives();
 699         }
 700
 701         if(maLinePrimitives.size())
 702         {
 703             // collect non-closed paragraphs
 704             impFlushLinePrimitivesToParagraphPrimitives();
 705         }
 706
 707         return impConvertVectorToPrimitive2DSequence(maParagraphPrimitives);
 708     }
 709 } // end of anonymous namespace
 710
 711 //////////////////////////////////////////////////////////////////////////////
 712 // primitive decompositions
 713
 714 void SdrTextObj::impDecomposeContourTextPrimitive(
 715     drawinglayer::primitive2d::Primitive2DSequence& rTarget,
 716     const drawinglayer::primitive2d::SdrContourTextPrimitive2D& rSdrContourTextPrimitive,
 717     const drawinglayer::geometry::ViewInformation2D& aViewInformation) const
 718 {
 719     // decompose matrix to have position and size of text
 720     basegfx::B2DVector aScale, aTranslate;
 721     double fRotate, fShearX;
 722     rSdrContourTextPrimitive.getObjectTransform().decompose(aScale, aTranslate, fRotate, fShearX);
 723
 724     // prepare contour polygon, force to non-mirrored for layouting
 725     basegfx::B2DPolyPolygon aPolyPolygon(rSdrContourTextPrimitive.getUnitPolyPolygon());
 726     basegfx::B2DHomMatrix aTransform;
 727     aTransform.scale(fabs(aScale.getX()), fabs(aScale.getY()));
 728     aPolyPolygon.transform(aTransform);
 729
 730     // prepare outliner
 731     SdrOutliner& rOutliner = ImpGetDrawOutliner();
 732     const Size aNullSize;
 733     rOutliner.SetPaperSize(aNullSize);
 734     rOutliner.SetPolygon(aPolyPolygon);
 735     rOutliner.SetUpdateMode(true);
 736     rOutliner.SetText(rSdrContourTextPrimitive.getOutlinerParaObject());
 737
 738     // set visualizing page at Outliner; needed e.g. for PageNumberField decomposition
 739     rOutliner.setVisualizedPage(GetSdrPageFromXDrawPage(aViewInformation.getVisualizedPage()));
 740
 741     // prepare matrices to apply to newly created primitives
 742     basegfx::B2DHomMatrix aNewTransformA;
 743     basegfx::B2DHomMatrix aNewTransformB;
 744
 745     // mirroring. We are now in the polygon sizes. When mirroring in X and Y,
 746     // move the null point which was top left to bottom right.
 747     const bool bMirrorX(basegfx::fTools::less(aScale.getX(), 0.0));
 748     const bool bMirrorY(basegfx::fTools::less(aScale.getY(), 0.0));
 749     aNewTransformB.scale(bMirrorX ? -1.0 : 1.0, bMirrorY ? -1.0 : 1.0);
 750
 751     // in-between the translations of the single primitives will take place. Afterwards,
 752     // the object's transformations need to be applied
 753     aNewTransformB.shearX(fShearX);
 754     aNewTransformB.rotate(fRotate);
 755     aNewTransformB.translate(aTranslate.getX(), aTranslate.getY());
 756
 757     // now break up text primitives.
 758     impTextBreakupHandler aConverter(rOutliner);
 759     aConverter.decomposeContourTextPrimitive(aNewTransformA, aNewTransformB, aScale);
 760
 761     // cleanup outliner
 762     rOutliner.Clear();
 763     rOutliner.setVisualizedPage(0);
 764
 765     rTarget = aConverter.getPrimitive2DSequence();
 766 }
 767
 768 void SdrTextObj::impDecomposeAutoFitTextPrimitive(
 769         drawinglayer::primitive2d::Primitive2DSequence& rTarget,
 770         const drawinglayer::primitive2d::SdrAutoFitTextPrimitive2D& rSdrAutofitTextPrimitive,
 771         const drawinglayer::geometry::ViewInformation2D& aViewInformation) const
 772 {
 773     // decompose matrix to have position and size of text
 774         basegfx::B2DVector aScale, aTranslate;
 775         double fRotate, fShearX;
 776         rSdrAutofitTextPrimitive.getTextRangeTransform().decompose(aScale, aTranslate, fRotate, fShearX);
 777
 778         // use B2DRange aAnchorTextRange for calculations
 779         basegfx::B2DRange aAnchorTextRange(aTranslate);
 780         aAnchorTextRange.expand(aTranslate + aScale);
 781
 782         // prepare outliner
 783         const SfxItemSet& rTextItemSet = rSdrAutofitTextPrimitive.getSdrText()->GetItemSet();
 784         SdrOutliner& rOutliner = ImpGetDrawOutliner();
 785         SdrTextVertAdjust eVAdj = GetTextVerticalAdjust(rTextItemSet);
 786         SdrTextHorzAdjust eHAdj = GetTextHorizontalAdjust(rTextItemSet);
 787         const sal_uInt32 nOriginalControlWord(rOutliner.GetControlWord());
 788         const Size aNullSize;
 789
 790         // set visualizing page at Outliner; needed e.g. for PageNumberField decomposition
 791         rOutliner.setVisualizedPage(GetSdrPageFromXDrawPage(aViewInformation.getVisualizedPage()));
 792
 793         rOutliner.SetControlWord(nOriginalControlWord|EE_CNTRL_AUTOPAGESIZE|EE_CNTRL_STRETCHING);
 794         rOutliner.SetMinAutoPaperSize(aNullSize);
 795         rOutliner.SetMaxAutoPaperSize(Size(1000000,1000000));
 796
 797         // add one to rage sizes to get back to the old Rectangle and outliner measurements
 798         const sal_uInt32 nAnchorTextWidth(FRound(aAnchorTextRange.getWidth() + 1L));
 799         const sal_uInt32 nAnchorTextHeight(FRound(aAnchorTextRange.getHeight() + 1L));
 800         const OutlinerParaObject* pOutlinerParaObject = rSdrAutofitTextPrimitive.getSdrText()->GetOutlinerParaObject();
 801         OSL_ENSURE(pOutlinerParaObject, "impDecomposeBlockTextPrimitive used with no OutlinerParaObject (!)");
 802         const bool bVerticalWritintg(pOutlinerParaObject->IsVertical());
 803         const Size aAnchorTextSize(Size(nAnchorTextWidth, nAnchorTextHeight));
 804
 805     if((rSdrAutofitTextPrimitive.getWordWrap() || IsTextFrame()))
 806     {
 807         rOutliner.SetMaxAutoPaperSize(aAnchorTextSize);
 808     }
 809
 810     if(SDRTEXTHORZADJUST_BLOCK == eHAdj && !bVerticalWritintg)
 811     {
 812         rOutliner.SetMinAutoPaperSize(Size(nAnchorTextWidth, 0));
 813     }
 814
 815     if(SDRTEXTVERTADJUST_BLOCK == eVAdj && bVerticalWritintg)
 816     {
 817         rOutliner.SetMinAutoPaperSize(Size(0, nAnchorTextHeight));
 818     }
 819
 820     rOutliner.SetPaperSize(aNullSize);
 821     rOutliner.SetUpdateMode(true);
 822     rOutliner.SetText(*pOutlinerParaObject);
 823     ImpAutoFitText(rOutliner,aAnchorTextSize,bVerticalWritintg);
 824
 825         // now get back the layouted text size from outliner
 826         const Size aOutlinerTextSiz(rOutliner.GetPaperSize());
 827         const basegfx::B2DVector aOutlinerScale(aOutlinerTextSiz.Width(), aOutlinerTextSiz.Height());
 828         basegfx::B2DVector aAdjustTranslate(0.0, 0.0);
 829
 830         // correct horizontal translation using the now known text size
 831         if(SDRTEXTHORZADJUST_CENTER == eHAdj || SDRTEXTHORZADJUST_RIGHT == eHAdj)
 832         {
 833                 const double fFree(aAnchorTextRange.getWidth() - aOutlinerScale.getX());
 834
 835                 if(SDRTEXTHORZADJUST_CENTER == eHAdj)
 836                 {
 837                         aAdjustTranslate.setX(fFree / 2.0);
 838                 }
 839
 840                 if(SDRTEXTHORZADJUST_RIGHT == eHAdj)
 841                 {
 842                         aAdjustTranslate.setX(fFree);
 843                 }
 844         }
 845
 846         // correct vertical translation using the now known text size
 847         if(SDRTEXTVERTADJUST_CENTER == eVAdj || SDRTEXTVERTADJUST_BOTTOM == eVAdj)
 848         {
 849                 const double fFree(aAnchorTextRange.getHeight() - aOutlinerScale.getY());
 850
 851                 if(SDRTEXTVERTADJUST_CENTER == eVAdj)
 852                 {
 853                         aAdjustTranslate.setY(fFree / 2.0);
 854                 }
 855
 856                 if(SDRTEXTVERTADJUST_BOTTOM == eVAdj)
 857                 {
 858                         aAdjustTranslate.setY(fFree);
 859                 }
 860         }
 861
 862         // prepare matrices to apply to newly created primitives. aNewTransformA
 863         // will get coordinates in aOutlinerScale size and positive in X, Y.
 864         basegfx::B2DHomMatrix aNewTransformA;
 865         basegfx::B2DHomMatrix aNewTransformB;
 866
 867         // translate relative to given primitive to get same rotation and shear
 868         // as the master shape we are working on. For vertical, use the top-right
 869         // corner
 870         const double fStartInX(bVerticalWritintg ? aAdjustTranslate.getX() + aOutlinerScale.getX() : aAdjustTranslate.getX());
 871         aNewTransformA.translate(fStartInX, aAdjustTranslate.getY());
 872
 873         // mirroring. We are now in aAnchorTextRange sizes. When mirroring in X and Y,
 874         // move the null point which was top left to bottom right.
 875         const bool bMirrorX(basegfx::fTools::less(aScale.getX(), 0.0));
 876         const bool bMirrorY(basegfx::fTools::less(aScale.getY(), 0.0));
 877         aNewTransformB.scale(bMirrorX ? -1.0 : 1.0, bMirrorY ? -1.0 : 1.0);
 878
 879         // in-between the translations of the single primitives will take place. Afterwards,
 880         // the object's transformations need to be applied
 881         aNewTransformB.shearX(fShearX);
 882         aNewTransformB.rotate(fRotate);
 883         aNewTransformB.translate(aTranslate.getX(), aTranslate.getY());
 884
 885         basegfx::B2DRange aClipRange;
 886
 887         // now break up text primitives.
 888         impTextBreakupHandler aConverter(rOutliner);
 889         aConverter.decomposeBlockTextPrimitive(aNewTransformA, aNewTransformB, aClipRange);
 890
 891         // cleanup outliner
 892         rOutliner.Clear();
 893         rOutliner.setVisualizedPage(0);
 894     rOutliner.SetControlWord(nOriginalControlWord);
 895
 896         rTarget = aConverter.getPrimitive2DSequence();
 897 }
 898
 899 void SdrTextObj::impDecomposeBlockTextPrimitive(
 900     drawinglayer::primitive2d::Primitive2DSequence& rTarget,
 901     const drawinglayer::primitive2d::SdrBlockTextPrimitive2D& rSdrBlockTextPrimitive,
 902     const drawinglayer::geometry::ViewInformation2D& aViewInformation) const
 903 {
 904     // decompose matrix to have position and size of text
 905     basegfx::B2DVector aScale, aTranslate;
 906     double fRotate, fShearX;
 907     rSdrBlockTextPrimitive.getTextRangeTransform().decompose(aScale, aTranslate, fRotate, fShearX);
 908
 909     // use B2DRange aAnchorTextRange for calculations
 910     basegfx::B2DRange aAnchorTextRange(aTranslate);
 911     aAnchorTextRange.expand(aTranslate + aScale);
 912
 913     // prepare outliner
 914     const bool bIsCell(rSdrBlockTextPrimitive.getCellText());
 915     SdrOutliner& rOutliner = ImpGetDrawOutliner();
 916     SdrTextHorzAdjust eHAdj = rSdrBlockTextPrimitive.getSdrTextHorzAdjust();
 917     SdrTextVertAdjust eVAdj = rSdrBlockTextPrimitive.getSdrTextVertAdjust();
 918     const sal_uInt32 nOriginalControlWord(rOutliner.GetControlWord());
 919     const Size aNullSize;
 920
 921     // set visualizing page at Outliner; needed e.g. for PageNumberField decomposition
 922     rOutliner.setVisualizedPage(GetSdrPageFromXDrawPage(aViewInformation.getVisualizedPage()));
 923     rOutliner.SetFixedCellHeight(rSdrBlockTextPrimitive.isFixedCellHeight());
 924     rOutliner.SetControlWord(nOriginalControlWord|EE_CNTRL_AUTOPAGESIZE);
 925     rOutliner.SetMinAutoPaperSize(aNullSize);
 926     rOutliner.SetMaxAutoPaperSize(Size(1000000,1000000));
 927
 928     // add one to rage sizes to get back to the old Rectangle and outliner measurements
 929     const sal_uInt32 nAnchorTextWidth(FRound(aAnchorTextRange.getWidth() + 1L));
 930     const sal_uInt32 nAnchorTextHeight(FRound(aAnchorTextRange.getHeight() + 1L));
 931     const bool bVerticalWritintg(rSdrBlockTextPrimitive.getOutlinerParaObject().IsVertical());
 932     const Size aAnchorTextSize(Size(nAnchorTextWidth, nAnchorTextHeight));
 933
 934     if(bIsCell)
 935     {
 936         // cell text is formated neither like a text object nor like a object
 937         // text, so use a special setup here
 938         rOutliner.SetMinAutoPaperSize(aNullSize);
 939         rOutliner.SetMaxAutoPaperSize(aAnchorTextSize);
 940         rOutliner.SetPaperSize(aAnchorTextSize);
 941         rOutliner.SetMinAutoPaperSize(Size(nAnchorTextWidth, 0));
 942         rOutliner.SetUpdateMode(TRUE);
 943         rOutliner.SetText(rSdrBlockTextPrimitive.getOutlinerParaObject());
 944         rOutliner.SetUpdateMode(TRUE);
 945         rOutliner.SetControlWord(nOriginalControlWord);
 946     }
 947     else
 948     {
 949         // check if block text is used (only one of them can be true)
 950         const bool bHorizontalIsBlock(SDRTEXTHORZADJUST_BLOCK == eHAdj && !bVerticalWritintg);
 951         const bool bVerticalIsBlock(SDRTEXTVERTADJUST_BLOCK == eVAdj && bVerticalWritintg);
 952
 953         if((rSdrBlockTextPrimitive.getWordWrap() || IsTextFrame()) && !rSdrBlockTextPrimitive.getUnlimitedPage())
 954         {
 955             // #i103454# maximal paper size hor/ver needs to be limited to text
 956             // frame size. If it's block text, still allow the 'other' direction
 957             // to grow to get a correct real text size when using GetPaperSize().
 958             // When just using aAnchorTextSize as maximum, GetPaperSize()
 959             // would just return aAnchorTextSize again: this means, the wanted
 960             // 'measurement' of the real size of block text would not work
 961             Size aMaxAutoPaperSize(aAnchorTextSize);
 962
 963             if(bHorizontalIsBlock)
 964             {
 965                 // allow to grow vertical for horizontal blocks
 966                 aMaxAutoPaperSize.setHeight(1000000);
 967             }
 968             else if(bVerticalIsBlock)
 969             {
 970                 // allow to grow horizontal for vertical blocks
 971                 aMaxAutoPaperSize.setWidth(1000000);
 972             }
 973
 974             rOutliner.SetMaxAutoPaperSize(aMaxAutoPaperSize);
 975         }
 976
 977         // set minimal paper size hor/ver if needed
 978         if(bHorizontalIsBlock)
 979         {
 980             rOutliner.SetMinAutoPaperSize(Size(nAnchorTextWidth, 0));
 981         }
 982         else if(bVerticalIsBlock)
 983         {
 984             rOutliner.SetMinAutoPaperSize(Size(0, nAnchorTextHeight));
 985         }
 986
 987         rOutliner.SetPaperSize(aNullSize);
 988         rOutliner.SetUpdateMode(true);
 989         rOutliner.SetText(rSdrBlockTextPrimitive.getOutlinerParaObject());
 990         rOutliner.SetControlWord(nOriginalControlWord);
 991     }
 992
 993     // now get back the layouted text size from outliner
 994     const Size aOutlinerTextSiz(rOutliner.GetPaperSize());
 995     const basegfx::B2DVector aOutlinerScale(aOutlinerTextSiz.Width(), aOutlinerTextSiz.Height());
 996     basegfx::B2DVector aAdjustTranslate(0.0, 0.0);
 997
 998     // For draw objects containing text correct hor/ver alignment if text is bigger
 999     // than the object itself. Without that correction, the text would always be
1000     // formatted to the left edge (or top edge when vertical) of the draw object.
1001     if(!IsTextFrame() && !bIsCell)
1002     {
1003         if(aAnchorTextRange.getWidth() < aOutlinerScale.getX() && !bVerticalWritintg)
1004         {
1005             // Horizontal case here. Correct only if eHAdj == SDRTEXTHORZADJUST_BLOCK,
1006             // else the alignment is wanted.
1007             if(SDRTEXTHORZADJUST_BLOCK == eHAdj)
1008             {
1009                 eHAdj = SDRTEXTHORZADJUST_CENTER;
1010             }
1011         }
1012
1013         if(aAnchorTextRange.getHeight() < aOutlinerScale.getY() && bVerticalWritintg)
1014         {
1015             // Vertical case here. Correct only if eHAdj == SDRTEXTVERTADJUST_BLOCK,
1016             // else the alignment is wanted.
1017             if(SDRTEXTVERTADJUST_BLOCK == eVAdj)
1018             {
1019                 eVAdj = SDRTEXTVERTADJUST_CENTER;
1020             }
1021         }
1022     }
1023
1024     // correct horizontal translation using the now known text size
1025     if(SDRTEXTHORZADJUST_CENTER == eHAdj || SDRTEXTHORZADJUST_RIGHT == eHAdj)
1026     {
1027         const double fFree(aAnchorTextRange.getWidth() - aOutlinerScale.getX());
1028
1029         if(SDRTEXTHORZADJUST_CENTER == eHAdj)
1030         {
1031             aAdjustTranslate.setX(fFree / 2.0);
1032         }
1033
1034         if(SDRTEXTHORZADJUST_RIGHT == eHAdj)
1035         {
1036             aAdjustTranslate.setX(fFree);
1037         }
1038     }
1039
1040     // correct vertical translation using the now known text size
1041     if(SDRTEXTVERTADJUST_CENTER == eVAdj || SDRTEXTVERTADJUST_BOTTOM == eVAdj)
1042     {
1043         const double fFree(aAnchorTextRange.getHeight() - aOutlinerScale.getY());
1044
1045         if(SDRTEXTVERTADJUST_CENTER == eVAdj)
1046         {
1047             aAdjustTranslate.setY(fFree / 2.0);
1048         }
1049
1050         if(SDRTEXTVERTADJUST_BOTTOM == eVAdj)
1051         {
1052             aAdjustTranslate.setY(fFree);
1053         }
1054     }
1055
1056     // prepare matrices to apply to newly created primitives. aNewTransformA
1057     // will get coordinates in aOutlinerScale size and positive in X, Y.
1058     basegfx::B2DHomMatrix aNewTransformA;
1059     basegfx::B2DHomMatrix aNewTransformB;
1060
1061     // translate relative to given primitive to get same rotation and shear
1062     // as the master shape we are working on. For vertical, use the top-right
1063     // corner
1064     const double fStartInX(bVerticalWritintg ? aAdjustTranslate.getX() + aOutlinerScale.getX() : aAdjustTranslate.getX());
1065     aNewTransformA.translate(fStartInX, aAdjustTranslate.getY());
1066
1067     // mirroring. We are now in aAnchorTextRange sizes. When mirroring in X and Y,
1068     // move the null point which was top left to bottom right.
1069     const bool bMirrorX(basegfx::fTools::less(aScale.getX(), 0.0));
1070     const bool bMirrorY(basegfx::fTools::less(aScale.getY(), 0.0));
1071     aNewTransformB.scale(bMirrorX ? -1.0 : 1.0, bMirrorY ? -1.0 : 1.0);
1072
1073     // in-between the translations of the single primitives will take place. Afterwards,
1074     // the object's transformations need to be applied
1075     aNewTransformB.shearX(fShearX);
1076     aNewTransformB.rotate(fRotate);
1077     aNewTransformB.translate(aTranslate.getX(), aTranslate.getY());
1078
1079     // #SJ# create ClipRange (if needed)
1080     basegfx::B2DRange aClipRange;
1081
1082     if(bIsCell)
1083     {
1084         aClipRange.expand(basegfx::B2DTuple(0.0, 0.0));
1085         aClipRange.expand(basegfx::B2DTuple(aAnchorTextSize.Width(), aAnchorTextSize.Height()));
1086     }
1087
1088     // now break up text primitives.
1089     impTextBreakupHandler aConverter(rOutliner);
1090     aConverter.decomposeBlockTextPrimitive(aNewTransformA, aNewTransformB, aClipRange);
1091
1092     // cleanup outliner
1093     rOutliner.Clear();
1094     rOutliner.setVisualizedPage(0);
1095
1096     rTarget = aConverter.getPrimitive2DSequence();
1097 }
1098
1099 void SdrTextObj::impDecomposeStretchTextPrimitive(
1100     drawinglayer::primitive2d::Primitive2DSequence& rTarget,
1101     const drawinglayer::primitive2d::SdrStretchTextPrimitive2D& rSdrStretchTextPrimitive,
1102     const drawinglayer::geometry::ViewInformation2D& aViewInformation) const
1103 {
1104     // decompose matrix to have position and size of text
1105     basegfx::B2DVector aScale, aTranslate;
1106     double fRotate, fShearX;
1107     rSdrStretchTextPrimitive.getTextRangeTransform().decompose(aScale, aTranslate, fRotate, fShearX);
1108
1109     // use non-mirrored B2DRange aAnchorTextRange for calculations
1110     basegfx::B2DRange aAnchorTextRange(aTranslate);
1111     aAnchorTextRange.expand(aTranslate + aScale);
1112
1113     // prepare outliner
1114     SdrOutliner& rOutliner = ImpGetDrawOutliner();
1115     const sal_uInt32 nOriginalControlWord(rOutliner.GetControlWord());
1116     const Size aNullSize;
1117
1118     rOutliner.SetControlWord(nOriginalControlWord|EE_CNTRL_STRETCHING|EE_CNTRL_AUTOPAGESIZE);
1119     rOutliner.SetFixedCellHeight(rSdrStretchTextPrimitive.isFixedCellHeight());
1120     rOutliner.SetMinAutoPaperSize(aNullSize);
1121     rOutliner.SetMaxAutoPaperSize(Size(1000000,1000000));
1122     rOutliner.SetPaperSize(aNullSize);
1123     rOutliner.SetUpdateMode(true);
1124     rOutliner.SetText(rSdrStretchTextPrimitive.getOutlinerParaObject());
1125
1126     // set visualizing page at Outliner; needed e.g. for PageNumberField decomposition
1127     rOutliner.setVisualizedPage(GetSdrPageFromXDrawPage(aViewInformation.getVisualizedPage()));
1128
1129     // now get back the layouted text size from outliner
1130     const Size aOutlinerTextSiz(rOutliner.CalcTextSize());
1131     const basegfx::B2DVector aOutlinerScale(
1132         basegfx::fTools::equalZero(aOutlinerTextSiz.Width()) ? 1.0 : aOutlinerTextSiz.Width(),
1133         basegfx::fTools::equalZero(aOutlinerTextSiz.Height()) ? 1.0 : aOutlinerTextSiz.Height());
1134
1135     // prepare matrices to apply to newly created primitives
1136     basegfx::B2DHomMatrix aNewTransformA;
1137     basegfx::B2DHomMatrix aNewTransformB;
1138
1139     // #i101957# Check for vertical text. If used, aNewTransformA
1140     // needs to translate the text initially around object width to orient
1141     // it relative to the topper right instead of the topper left
1142     const bool bVertical(rSdrStretchTextPrimitive.getOutlinerParaObject().IsVertical());
1143
1144     if(bVertical)
1145     {
1146         aNewTransformA.translate(aScale.getX(), 0.0);
1147     }
1148
1149     // calculate global char stretching scale parameters. Use non-mirrored sizes
1150     // to layout without mirroring
1151     const double fScaleX(fabs(aScale.getX()) / aOutlinerScale.getX());
1152     const double fScaleY(fabs(aScale.getY()) / aOutlinerScale.getY());
1153     rOutliner.SetGlobalCharStretching((sal_Int16)FRound(fScaleX * 100.0), (sal_Int16)FRound(fScaleY * 100.0));
1154
1155     // mirroring. We are now in aAnchorTextRange sizes. When mirroring in X and Y,
1156     // move the null point which was top left to bottom right.
1157     const bool bMirrorX(basegfx::fTools::less(aScale.getX(), 0.0));
1158     const bool bMirrorY(basegfx::fTools::less(aScale.getY(), 0.0));
1159     aNewTransformB.scale(bMirrorX ? -1.0 : 1.0, bMirrorY ? -1.0 : 1.0);
1160
1161     // in-between the translations of the single primitives will take place. Afterwards,
1162     // the object's transformations need to be applied
1163     aNewTransformB.shearX(fShearX);
1164     aNewTransformB.rotate(fRotate);
1165     aNewTransformB.translate(aTranslate.getX(), aTranslate.getY());
1166
1167     // now break up text primitives.
1168     impTextBreakupHandler aConverter(rOutliner);
1169     aConverter.decomposeStretchTextPrimitive(aNewTransformA, aNewTransformB);
1170
1171     // cleanup outliner
1172     rOutliner.SetControlWord(nOriginalControlWord);
1173     rOutliner.Clear();
1174     rOutliner.setVisualizedPage(0);
1175
1176     rTarget = aConverter.getPrimitive2DSequence();
1177 }
1178
1179 //////////////////////////////////////////////////////////////////////////////
1180 // timing generators
1181 #define ENDLESS_LOOP    (0xffffffff)
1182 #define ENDLESS_TIME    ((double)0xffffffff)
1183 #define PIXEL_DPI               (96.0)
1184
1185 void SdrTextObj::impGetBlinkTextTiming(drawinglayer::animation::AnimationEntryList& rAnimList) const
1186 {
1187     if(SDRTEXTANI_BLINK == GetTextAniKind())
1188     {
1189         // get values
1190         const SfxItemSet& rSet = GetObjectItemSet();
1191         const sal_uInt32 nRepeat((sal_uInt32)((SdrTextAniCountItem&)rSet.Get(SDRATTR_TEXT_ANICOUNT)).GetValue());
1192         bool bVisisbleWhenStopped(((SdrTextAniStopInsideItem&)rSet.Get(SDRATTR_TEXT_ANISTOPINSIDE)).GetValue());
1193         double fDelay((double)((SdrTextAniDelayItem&)rSet.Get(SDRATTR_TEXT_ANIDELAY)).GetValue());
1194
1195         if(0.0 == fDelay)
1196         {
1197             // use default
1198             fDelay = 250.0;
1199         }
1200
1201         // prepare loop and add
1202         drawinglayer::animation::AnimationEntryLoop  aLoop(nRepeat ? nRepeat : ENDLESS_LOOP);
1203         drawinglayer::animation::AnimationEntryFixed aStart(fDelay, 0.0);
1204         aLoop.append(aStart);
1205         drawinglayer::animation::AnimationEntryFixed aEnd(fDelay, 1.0);
1206         aLoop.append(aEnd);
1207         rAnimList.append(aLoop);
1208
1209         // add stopped state if loop is not endless
1210         if(0L != nRepeat)
1211         {
1212             drawinglayer::animation::AnimationEntryFixed aStop(ENDLESS_TIME, bVisisbleWhenStopped ? 0.0 : 1.0);
1213             rAnimList.append(aStop);
1214         }
1215     }
1216 }
1217
1218 void impCreateScrollTiming(const SfxItemSet& rSet, drawinglayer::animation::AnimationEntryList& rAnimList, bool bForward, double fTimeFullPath, double fFrequency)
1219 {
1220     bool bVisisbleWhenStopped(((SdrTextAniStopInsideItem&)rSet.Get(SDRATTR_TEXT_ANISTOPINSIDE)).GetValue());
1221     bool bVisisbleWhenStarted(((SdrTextAniStartInsideItem&)rSet.Get(SDRATTR_TEXT_ANISTOPINSIDE )).GetValue());
1222     const sal_uInt32 nRepeat(((SdrTextAniCountItem&)rSet.Get(SDRATTR_TEXT_ANICOUNT)).GetValue());
1223
1224     if(bVisisbleWhenStarted)
1225     {
1226         // move from center to outside
1227         drawinglayer::animation::AnimationEntryLinear aInOut(fTimeFullPath * 0.5, fFrequency, 0.5, bForward ? 1.0 : 0.0);
1228         rAnimList.append(aInOut);
1229     }
1230
1231     // loop. In loop, move through
1232     if(nRepeat || 0L == nRepeat)
1233     {
1234         drawinglayer::animation::AnimationEntryLoop aLoop(nRepeat ? nRepeat : ENDLESS_LOOP);
1235         drawinglayer::animation::AnimationEntryLinear aThrough(fTimeFullPath, fFrequency, bForward ? 0.0 : 1.0, bForward ? 1.0 : 0.0);
1236         aLoop.append(aThrough);
1237         rAnimList.append(aLoop);
1238     }
1239
1240     if(0L != nRepeat && bVisisbleWhenStopped)
1241     {
1242         // move from outside to center
1243         drawinglayer::animation::AnimationEntryLinear aOutIn(fTimeFullPath * 0.5, fFrequency, bForward ? 0.0 : 1.0, 0.5);
1244         rAnimList.append(aOutIn);
1245
1246         // add timing for staying at the end
1247         drawinglayer::animation::AnimationEntryFixed aEnd(ENDLESS_TIME, 0.5);
1248         rAnimList.append(aEnd);
1249     }
1250 }
1251
1252 void impCreateAlternateTiming(const SfxItemSet& rSet, drawinglayer::animation::AnimationEntryList& rAnimList, double fRelativeTextLength, bool bForward, double fTimeFullPath, double fFrequency)
1253 {
1254     if(basegfx::fTools::more(fRelativeTextLength, 0.5))
1255     {
1256         // this is the case when fTextLength > fFrameLength, text is bigger than animation frame.
1257         // In that case, correct direction
1258         bForward = !bForward;
1259     }
1260
1261     const double fStartPosition(bForward ? fRelativeTextLength : 1.0 - fRelativeTextLength);
1262     const double fEndPosition(bForward ? 1.0 - fRelativeTextLength : fRelativeTextLength);
1263     bool bVisisbleWhenStopped(((SdrTextAniStopInsideItem&)rSet.Get(SDRATTR_TEXT_ANISTOPINSIDE)).GetValue());
1264     bool bVisisbleWhenStarted(((SdrTextAniStartInsideItem&)rSet.Get(SDRATTR_TEXT_ANISTOPINSIDE )).GetValue());
1265     const sal_uInt32 nRepeat(((SdrTextAniCountItem&)rSet.Get(SDRATTR_TEXT_ANICOUNT)).GetValue());
1266
1267     if(!bVisisbleWhenStarted)
1268     {
1269         // move from outside to center
1270         drawinglayer::animation::AnimationEntryLinear aOutIn(fTimeFullPath * 0.5, fFrequency, bForward ? 0.0 : 1.0, 0.5);
1271         rAnimList.append(aOutIn);
1272     }
1273
1274     // loop. In loop, move out and in again. fInnerMovePath may be negative when text is bigger then frame,
1275     // so use absolute value
1276     const double fInnerMovePath(fabs(1.0 - (fRelativeTextLength * 2.0)));
1277     const double fTimeForInnerPath(fTimeFullPath * fInnerMovePath);
1278     const double fHalfInnerPath(fTimeForInnerPath * 0.5);
1279     const sal_uInt32 nDoubleRepeat(nRepeat / 2L);
1280
1281     if(nDoubleRepeat || 0L == nRepeat)
1282     {
1283         // double forth and back loop
1284         drawinglayer::animation::AnimationEntryLoop aLoop(nDoubleRepeat ? nDoubleRepeat : ENDLESS_LOOP);
1285         drawinglayer::animation::AnimationEntryLinear aTime0(fHalfInnerPath, fFrequency, 0.5, fEndPosition);
1286         aLoop.append(aTime0);
1287         drawinglayer::animation::AnimationEntryLinear aTime1(fTimeForInnerPath, fFrequency, fEndPosition, fStartPosition);
1288         aLoop.append(aTime1);
1289         drawinglayer::animation::AnimationEntryLinear aTime2(fHalfInnerPath, fFrequency, fStartPosition, 0.5);
1290         aLoop.append(aTime2);
1291         rAnimList.append(aLoop);
1292     }
1293
1294     if(nRepeat % 2L)
1295     {
1296         // repeat is uneven, so we need one more forth and back to center
1297         drawinglayer::animation::AnimationEntryLinear aTime0(fHalfInnerPath, fFrequency, 0.5, fEndPosition);
1298         rAnimList.append(aTime0);
1299         drawinglayer::animation::AnimationEntryLinear aTime1(fHalfInnerPath, fFrequency, fEndPosition, 0.5);
1300         rAnimList.append(aTime1);
1301     }
1302
1303     if(0L != nRepeat)
1304     {
1305         if(bVisisbleWhenStopped)
1306         {
1307             // add timing for staying at the end
1308             drawinglayer::animation::AnimationEntryFixed aEnd(ENDLESS_TIME, 0.5);
1309             rAnimList.append(aEnd);
1310         }
1311         else
1312         {
1313             // move from center to outside
1314             drawinglayer::animation::AnimationEntryLinear aInOut(fTimeFullPath * 0.5, fFrequency, 0.5, bForward ? 1.0 : 0.0);
1315             rAnimList.append(aInOut);
1316         }
1317     }
1318 }
1319
1320 void impCreateSlideTiming(const SfxItemSet& rSet, drawinglayer::animation::AnimationEntryList& rAnimList, bool bForward, double fTimeFullPath, double fFrequency)
1321 {
1322     // move in from outside, start outside
1323     const double fStartPosition(bForward ? 0.0 : 1.0);
1324     const sal_uInt32 nRepeat(((SdrTextAniCountItem&)rSet.Get(SDRATTR_TEXT_ANICOUNT)).GetValue());
1325
1326     // move from outside to center
1327     drawinglayer::animation::AnimationEntryLinear aOutIn(fTimeFullPath * 0.5, fFrequency, fStartPosition, 0.5);
1328     rAnimList.append(aOutIn);
1329
1330     // loop. In loop, move out and in again
1331     if(nRepeat > 1L || 0L == nRepeat)
1332     {
1333         drawinglayer::animation::AnimationEntryLoop aLoop(nRepeat ? nRepeat - 1L : ENDLESS_LOOP);
1334         drawinglayer::animation::AnimationEntryLinear aTime0(fTimeFullPath * 0.5, fFrequency, 0.5, fStartPosition);
1335         aLoop.append(aTime0);
1336         drawinglayer::animation::AnimationEntryLinear aTime1(fTimeFullPath * 0.5, fFrequency, fStartPosition, 0.5);
1337         aLoop.append(aTime1);
1338         rAnimList.append(aLoop);
1339     }
1340
1341     // always visible when stopped, so add timing for staying at the end when not endless
1342     if(0L != nRepeat)
1343     {
1344         drawinglayer::animation::AnimationEntryFixed aEnd(ENDLESS_TIME, 0.5);
1345         rAnimList.append(aEnd);
1346     }
1347 }
1348
1349 void SdrTextObj::impGetScrollTextTiming(drawinglayer::animation::AnimationEntryList& rAnimList, double fFrameLength, double fTextLength) const
1350 {
1351     const SdrTextAniKind eAniKind(GetTextAniKind());
1352
1353     if(SDRTEXTANI_SCROLL == eAniKind || SDRTEXTANI_ALTERNATE == eAniKind || SDRTEXTANI_SLIDE == eAniKind)
1354     {
1355         // get data. Goal is to calculate fTimeFullPath which is the time needed to
1356         // move animation from (0.0) to (1.0) state
1357         const SfxItemSet& rSet = GetObjectItemSet();
1358         double fAnimationDelay((double)((SdrTextAniDelayItem&)rSet.Get(SDRATTR_TEXT_ANIDELAY)).GetValue());
1359         double fSingleStepWidth((double)((SdrTextAniAmountItem&)rSet.Get(SDRATTR_TEXT_ANIAMOUNT)).GetValue());
1360         const SdrTextAniDirection eDirection(GetTextAniDirection());
1361         const bool bForward(SDRTEXTANI_RIGHT == eDirection || SDRTEXTANI_DOWN == eDirection);
1362
1363         if(basegfx::fTools::equalZero(fAnimationDelay))
1364         {
1365             // default to 1/20 second
1366             fAnimationDelay = 50.0;
1367         }
1368
1369         if(basegfx::fTools::less(fSingleStepWidth, 0.0))
1370         {
1371             // data is in pixels, convert to logic. Imply PIXEL_DPI dpi.
1372             // It makes no sense to keep the view-transformation centered
1373             // definitions, so get rid of them here.
1374             fSingleStepWidth = (-fSingleStepWidth * (2540.0 / PIXEL_DPI));
1375         }
1376
1377         if(basegfx::fTools::equalZero(fSingleStepWidth))
1378         {
1379             // default to 1 milimeter
1380             fSingleStepWidth = 100.0;
1381         }
1382
1383         // use the length of the full animation path and the number of steps
1384         // to get the full path time
1385         const double fFullPathLength(fFrameLength + fTextLength);
1386         const double fNumberOfSteps(fFullPathLength / fSingleStepWidth);
1387         double fTimeFullPath(fNumberOfSteps * fAnimationDelay);
1388
1389         if(fTimeFullPath < fAnimationDelay)
1390         {
1391             fTimeFullPath = fAnimationDelay;
1392         }
1393
1394         switch(eAniKind)
1395         {
1396             case SDRTEXTANI_SCROLL :
1397             {
1398                 impCreateScrollTiming(rSet, rAnimList, bForward, fTimeFullPath, fAnimationDelay);
1399                 break;
1400             }
1401             case SDRTEXTANI_ALTERNATE :
1402             {
1403                 double fRelativeTextLength(fTextLength / (fFrameLength + fTextLength));
1404                 impCreateAlternateTiming(rSet, rAnimList, fRelativeTextLength, bForward, fTimeFullPath, fAnimationDelay);
1405                 break;
1406             }
1407             case SDRTEXTANI_SLIDE :
1408             {
1409                 impCreateSlideTiming(rSet, rAnimList, bForward, fTimeFullPath, fAnimationDelay);
1410                 break;
1411             }
1412             default : break; // SDRTEXTANI_NONE, SDRTEXTANI_BLINK
1413         }
1414     }
1415 }
1416
1417 //////////////////////////////////////////////////////////////////////////////
1418 // eof