svx/source/svdraw/svdotext.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <comphelper/string.hxx>
  22 #include <svx/svdotext.hxx>
  23 #include <svx/svdpagv.hxx>
  24 #include <svx/svdview.hxx>
  25 #include <svx/svdpage.hxx>
  26 #include <svx/svdetc.hxx>
  27 #include <svx/svdoutl.hxx>
  28 #include <svx/svdmodel.hxx>
  29 #include "svdglob.hxx"
  30 #include "svx/svdstr.hrc"
  31 #include <editeng/writingmodeitem.hxx>
  32 #include <svx/sdtfchim.hxx>
  33 #include <svtools/colorcfg.hxx>
  34 #include <editeng/editdata.hxx>
  35 #include <editeng/eeitem.hxx>
  36 #include <editeng/editstat.hxx>
  37 #include <editeng/outlobj.hxx>
  38 #include <editeng/editobj.hxx>
  39 #include <editeng/outliner.hxx>
  40 #include <editeng/fhgtitem.hxx>
  41 #include <svl/itempool.hxx>
  42 #include <editeng/adjustitem.hxx>
  43 #include <editeng/flditem.hxx>
  44 #include <svx/xftouit.hxx>
  45 #include <tools/helpers.hxx>
  46 #include <svx/xflgrit.hxx>
  47 #include <svx/svdpool.hxx>
  48 #include <svx/xflclit.hxx>
  49 #include <svl/style.hxx>
  50 #include <editeng/editeng.hxx>
  51 #include <svl/itemiter.hxx>
  52 #include <sdr/properties/textproperties.hxx>
  53 #include <vcl/metaact.hxx>
  54 #include <svx/sdr/contact/viewcontactoftextobj.hxx>
  55 #include <basegfx/tuple/b2dtuple.hxx>
  56 #include <basegfx/matrix/b2dhommatrix.hxx>
  57 #include <basegfx/polygon/b2dpolygon.hxx>
  58 #include <drawinglayer/geometry/viewinformation2d.hxx>
  59 #include <vcl/virdev.hxx>
  60 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  61 #include "svdconv.hxx"
  62
  63 using namespace com::sun::star;
  64
  65
  66 // BaseProperties section
  67
  68 sdr::properties::BaseProperties* SdrTextObj::CreateObjectSpecificProperties()
  69 {
  70     return new sdr::properties::TextProperties(*this);
  71 }
  72
  73
  74 // DrawContact section
  75
  76 sdr::contact::ViewContact* SdrTextObj::CreateObjectSpecificViewContact()
  77 {
  78     return new sdr::contact::ViewContactOfTextObj(*this);
  79 }
  80
  81
  82
  83 TYPEINIT1(SdrTextObj,SdrAttrObj);
  84
  85 SdrTextObj::SdrTextObj()
  86 :   SdrAttrObj(),
  87     mpText(NULL),
  88     pEdtOutl(NULL),
  89     pFormTextBoundRect(NULL),
  90     eTextKind(OBJ_TEXT)
  91 {
  92     bTextSizeDirty=false;
  93     bTextFrame=false;
  94     bPortionInfoChecked=false;
  95     bNoShear=false;
  96     bNoRotate=false;
  97     bNoMirror=false;
  98     bDisableAutoWidthOnDragging=false;
  99
 100     mbInEditMode = false;
 101     mbTextHidden = false;
 102     mbTextAnimationAllowed = true;
 103     maTextEditOffset = Point(0, 0);
 104
 105     // #i25616#
 106     mbSupportTextIndentingOnLineWidthChange = true;
 107     mbInDownScale = false;
 108 }
 109
 110 SdrTextObj::SdrTextObj(const Rectangle& rNewRect)
 111 :   SdrAttrObj(),
 112     maRect(rNewRect),
 113     mpText(NULL),
 114     pEdtOutl(NULL),
 115     pFormTextBoundRect(NULL),
 116     eTextKind(OBJ_TEXT)
 117 {
 118     bTextSizeDirty=false;
 119     bTextFrame=false;
 120     bPortionInfoChecked=false;
 121     bNoShear=false;
 122     bNoRotate=false;
 123     bNoMirror=false;
 124     bDisableAutoWidthOnDragging=false;
 125     ImpJustifyRect(maRect);
 126
 127     mbInEditMode = false;
 128     mbTextHidden = false;
 129     mbTextAnimationAllowed = true;
 130     mbInDownScale = false;
 131     maTextEditOffset = Point(0, 0);
 132
 133     // #i25616#
 134     mbSupportTextIndentingOnLineWidthChange = true;
 135 }
 136
 137 SdrTextObj::SdrTextObj(SdrObjKind eNewTextKind)
 138 :   SdrAttrObj(),
 139     mpText(NULL),
 140     pEdtOutl(NULL),
 141     pFormTextBoundRect(NULL),
 142     eTextKind(eNewTextKind)
 143 {
 144     bTextSizeDirty=false;
 145     bTextFrame=true;
 146     bPortionInfoChecked=false;
 147     bNoShear=true;
 148     bNoRotate=false;
 149     bNoMirror=true;
 150     bDisableAutoWidthOnDragging=false;
 151
 152     mbInEditMode = false;
 153     mbTextHidden = false;
 154     mbTextAnimationAllowed = true;
 155     mbInDownScale = false;
 156     maTextEditOffset = Point(0, 0);
 157
 158     // #i25616#
 159     mbSupportTextIndentingOnLineWidthChange = true;
 160 }
 161
 162 SdrTextObj::SdrTextObj(SdrObjKind eNewTextKind, const Rectangle& rNewRect)
 163 :   SdrAttrObj(),
 164     maRect(rNewRect),
 165     mpText(NULL),
 166     pEdtOutl(NULL),
 167     pFormTextBoundRect(NULL),
 168     eTextKind(eNewTextKind)
 169 {
 170     bTextSizeDirty=false;
 171     bTextFrame=true;
 172     bPortionInfoChecked=false;
 173     bNoShear=true;
 174     bNoRotate=false;
 175     bNoMirror=true;
 176     bDisableAutoWidthOnDragging=false;
 177     ImpJustifyRect(maRect);
 178
 179     mbInEditMode = false;
 180     mbTextHidden = false;
 181     mbTextAnimationAllowed = true;
 182     mbInDownScale = false;
 183     maTextEditOffset = Point(0, 0);
 184
 185     // #i25616#
 186     mbSupportTextIndentingOnLineWidthChange = true;
 187 }
 188
 189 SdrTextObj::~SdrTextObj()
 190 {
 191     if( pModel )
 192     {
 193         SdrOutliner& rOutl = pModel->GetHitTestOutliner();
 194         if( rOutl.GetTextObj() == this )
 195             rOutl.SetTextObj( NULL );
 196     }
 197
 198     delete mpText;
 199
 200     delete pFormTextBoundRect;
 201
 202     ImpLinkAbmeldung();
 203 }
 204
 205 void SdrTextObj::FitFrameToTextSize()
 206 {
 207     DBG_ASSERT(pModel!=NULL,"SdrTextObj::FitFrameToTextSize(): pModel=NULL!");
 208     ImpJustifyRect(maRect);
 209
 210     SdrText* pText = getActiveText();
 211     if( pText!=NULL && pText->GetOutlinerParaObject() && pModel!=NULL)
 212     {
 213         SdrOutliner& rOutliner=ImpGetDrawOutliner();
 214         rOutliner.SetPaperSize(Size(maRect.Right()-maRect.Left(),maRect.Bottom()-maRect.Top()));
 215         rOutliner.SetUpdateMode(true);
 216         rOutliner.SetText(*pText->GetOutlinerParaObject());
 217         Size aNewSize(rOutliner.CalcTextSize());
 218         rOutliner.Clear();
 219         aNewSize.Width()++; // because of possible rounding errors
 220         aNewSize.Width()+=GetTextLeftDistance()+GetTextRightDistance();
 221         aNewSize.Height()+=GetTextUpperDistance()+GetTextLowerDistance();
 222         Rectangle aNewRect(maRect);
 223         aNewRect.SetSize(aNewSize);
 224         ImpJustifyRect(aNewRect);
 225         if (aNewRect!=maRect) {
 226             SetLogicRect(aNewRect);
 227         }
 228     }
 229 }
 230
 231 void SdrTextObj::NbcSetText(const OUString& rStr)
 232 {
 233     SdrOutliner& rOutliner=ImpGetDrawOutliner();
 234     rOutliner.SetStyleSheet( 0, GetStyleSheet());
 235     rOutliner.SetUpdateMode(true);
 236     rOutliner.SetText(rStr,rOutliner.GetParagraph( 0 ));
 237     OutlinerParaObject* pNewText=rOutliner.CreateParaObject();
 238     Size aSiz(rOutliner.CalcTextSize());
 239     rOutliner.Clear();
 240     NbcSetOutlinerParaObject(pNewText);
 241     aTextSize=aSiz;
 242     bTextSizeDirty=false;
 243 }
 244
 245 void SdrTextObj::SetText(const OUString& rStr)
 246 {
 247     Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
 248     NbcSetText(rStr);
 249     SetChanged();
 250     BroadcastObjectChange();
 251     SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
 252 }
 253
 254 void SdrTextObj::NbcSetText(SvStream& rInput, const OUString& rBaseURL, sal_uInt16 eFormat)
 255 {
 256     SdrOutliner& rOutliner=ImpGetDrawOutliner();
 257     rOutliner.SetStyleSheet( 0, GetStyleSheet());
 258     rOutliner.Read(rInput,rBaseURL,eFormat);
 259     OutlinerParaObject* pNewText=rOutliner.CreateParaObject();
 260     rOutliner.SetUpdateMode(true);
 261     Size aSiz(rOutliner.CalcTextSize());
 262     rOutliner.Clear();
 263     NbcSetOutlinerParaObject(pNewText);
 264     aTextSize=aSiz;
 265     bTextSizeDirty=false;
 266 }
 267
 268 void SdrTextObj::SetText(SvStream& rInput, const OUString& rBaseURL, sal_uInt16 eFormat)
 269 {
 270     Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
 271     NbcSetText(rInput,rBaseURL,eFormat);
 272     SetChanged();
 273     BroadcastObjectChange();
 274     SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
 275 }
 276
 277 const Size& SdrTextObj::GetTextSize() const
 278 {
 279     if (bTextSizeDirty)
 280     {
 281         Size aSiz;
 282         SdrText* pText = getActiveText();
 283         if( pText && pText->GetOutlinerParaObject ())
 284         {
 285             SdrOutliner& rOutliner=ImpGetDrawOutliner();
 286             rOutliner.SetText(*pText->GetOutlinerParaObject());
 287             rOutliner.SetUpdateMode(true);
 288             aSiz=rOutliner.CalcTextSize();
 289             rOutliner.Clear();
 290         }
 291         // casting to nonconst twice
 292         const_cast<SdrTextObj*>(this)->aTextSize=aSiz;
 293         const_cast<SdrTextObj*>(this)->bTextSizeDirty=false;
 294     }
 295     return aTextSize;
 296 }
 297
 298 bool SdrTextObj::IsAutoGrowHeight() const
 299 {
 300     if(!bTextFrame)
 301         return false; // AutoGrow only together with TextFrames
 302
 303     const SfxItemSet& rSet = GetObjectItemSet();
 304     bool bRet = static_cast<const SdrOnOffItem&>(rSet.Get(SDRATTR_TEXT_AUTOGROWHEIGHT)).GetValue();
 305
 306     if(bRet)
 307     {
 308         SdrTextAniKind eAniKind = static_cast<const SdrTextAniKindItem&>(rSet.Get(SDRATTR_TEXT_ANIKIND)).GetValue();
 309
 310         if(eAniKind == SDRTEXTANI_SCROLL || eAniKind == SDRTEXTANI_ALTERNATE || eAniKind == SDRTEXTANI_SLIDE)
 311         {
 312             SdrTextAniDirection eDirection = static_cast<const SdrTextAniDirectionItem&>(rSet.Get(SDRATTR_TEXT_ANIDIRECTION)).GetValue();
 313
 314             if(eDirection == SDRTEXTANI_UP || eDirection == SDRTEXTANI_DOWN)
 315             {
 316                 bRet = false;
 317             }
 318         }
 319     }
 320     return bRet;
 321 }
 322
 323 bool SdrTextObj::IsAutoGrowWidth() const
 324 {
 325     if(!bTextFrame)
 326         return false; // AutoGrow only together with TextFrames
 327
 328     const SfxItemSet& rSet = GetObjectItemSet();
 329     bool bRet = static_cast<const SdrOnOffItem&>(rSet.Get(SDRATTR_TEXT_AUTOGROWWIDTH)).GetValue();
 330
 331     bool bInEditMOde = IsInEditMode();
 332
 333     if(!bInEditMOde && bRet)
 334     {
 335         SdrTextAniKind eAniKind = static_cast<const SdrTextAniKindItem&>(rSet.Get(SDRATTR_TEXT_ANIKIND)).GetValue();
 336
 337         if(eAniKind == SDRTEXTANI_SCROLL || eAniKind == SDRTEXTANI_ALTERNATE || eAniKind == SDRTEXTANI_SLIDE)
 338         {
 339             SdrTextAniDirection eDirection = static_cast<const SdrTextAniDirectionItem&>(rSet.Get(SDRATTR_TEXT_ANIDIRECTION)).GetValue();
 340
 341             if(eDirection == SDRTEXTANI_LEFT || eDirection == SDRTEXTANI_RIGHT)
 342             {
 343                 bRet = false;
 344             }
 345         }
 346     }
 347     return bRet;
 348 }
 349
 350 SdrTextHorzAdjust SdrTextObj::GetTextHorizontalAdjust() const
 351 {
 352     return GetTextHorizontalAdjust(GetObjectItemSet());
 353 }
 354
 355 SdrTextHorzAdjust SdrTextObj::GetTextHorizontalAdjust(const SfxItemSet& rSet) const
 356 {
 357     if(IsContourTextFrame())
 358         return SDRTEXTHORZADJUST_BLOCK;
 359
 360     SdrTextHorzAdjust eRet = static_cast<const SdrTextHorzAdjustItem&>(rSet.Get(SDRATTR_TEXT_HORZADJUST)).GetValue();
 361
 362     bool bInEditMode = IsInEditMode();
 363
 364     if(!bInEditMode && eRet == SDRTEXTHORZADJUST_BLOCK)
 365     {
 366         SdrTextAniKind eAniKind = static_cast<const SdrTextAniKindItem&>(rSet.Get(SDRATTR_TEXT_ANIKIND)).GetValue();
 367
 368         if(eAniKind == SDRTEXTANI_SCROLL || eAniKind == SDRTEXTANI_ALTERNATE || eAniKind == SDRTEXTANI_SLIDE)
 369         {
 370             SdrTextAniDirection eDirection = static_cast<const SdrTextAniDirectionItem&>(rSet.Get(SDRATTR_TEXT_ANIDIRECTION)).GetValue();
 371
 372             if(eDirection == SDRTEXTANI_LEFT || eDirection == SDRTEXTANI_RIGHT)
 373             {
 374                 eRet = SDRTEXTHORZADJUST_LEFT;
 375             }
 376         }
 377     }
 378
 379     return eRet;
 380 } // defaults: BLOCK (justify) for text frame, CENTER for captions of drawing objects
 381
 382 SdrTextVertAdjust SdrTextObj::GetTextVerticalAdjust() const
 383 {
 384     return GetTextVerticalAdjust(GetObjectItemSet());
 385 }
 386
 387 SdrTextVertAdjust SdrTextObj::GetTextVerticalAdjust(const SfxItemSet& rSet) const
 388 {
 389     if(IsContourTextFrame())
 390         return SDRTEXTVERTADJUST_TOP;
 391
 392     // Take care for vertical text animation here
 393     SdrTextVertAdjust eRet = static_cast<const SdrTextVertAdjustItem&>(rSet.Get(SDRATTR_TEXT_VERTADJUST)).GetValue();
 394     bool bInEditMode = IsInEditMode();
 395
 396     // Take care for vertical text animation here
 397     if(!bInEditMode && eRet == SDRTEXTVERTADJUST_BLOCK)
 398     {
 399         SdrTextAniKind eAniKind = static_cast<const SdrTextAniKindItem&>(rSet.Get(SDRATTR_TEXT_ANIKIND)).GetValue();
 400
 401         if(eAniKind == SDRTEXTANI_SCROLL || eAniKind == SDRTEXTANI_ALTERNATE || eAniKind == SDRTEXTANI_SLIDE)
 402         {
 403             SdrTextAniDirection eDirection = static_cast<const SdrTextAniDirectionItem&>(rSet.Get(SDRATTR_TEXT_ANIDIRECTION)).GetValue();
 404
 405             if(eDirection == SDRTEXTANI_LEFT || eDirection == SDRTEXTANI_RIGHT)
 406             {
 407                 eRet = SDRTEXTVERTADJUST_TOP;
 408             }
 409         }
 410     }
 411
 412     return eRet;
 413 } // defaults: TOP for text frame, CENTER for captions of drawing objects
 414
 415 void SdrTextObj::ImpJustifyRect(Rectangle& rRect)
 416 {
 417     if (!rRect.IsEmpty()) {
 418         rRect.Justify();
 419         if (rRect.Left()==rRect.Right()) rRect.Right()++;
 420         if (rRect.Top()==rRect.Bottom()) rRect.Bottom()++;
 421     }
 422 }
 423
 424 void SdrTextObj::ImpCheckShear()
 425 {
 426     if (bNoShear && aGeo.nShearAngle!=0) {
 427         aGeo.nShearAngle=0;
 428         aGeo.nTan=0;
 429     }
 430 }
 431
 432 void SdrTextObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
 433 {
 434     bool bNoTextFrame=!IsTextFrame();
 435     rInfo.bResizeFreeAllowed=bNoTextFrame || aGeo.nRotationAngle%9000==0;
 436     rInfo.bResizePropAllowed=true;
 437     rInfo.bRotateFreeAllowed=true;
 438     rInfo.bRotate90Allowed  =true;
 439     rInfo.bMirrorFreeAllowed=bNoTextFrame;
 440     rInfo.bMirror45Allowed  =bNoTextFrame;
 441     rInfo.bMirror90Allowed  =bNoTextFrame;
 442
 443     // allow transparency
 444     rInfo.bTransparenceAllowed = true;
 445
 446     // gradient depends on fillstyle
 447     drawing::FillStyle eFillStyle = static_cast<const XFillStyleItem&>(GetObjectItem(XATTR_FILLSTYLE)).GetValue();
 448     rInfo.bGradientAllowed = (eFillStyle == drawing::FillStyle_GRADIENT);
 449     rInfo.bShearAllowed     =bNoTextFrame;
 450     rInfo.bEdgeRadiusAllowed=true;
 451     bool bCanConv=ImpCanConvTextToCurve();
 452     rInfo.bCanConvToPath    =bCanConv;
 453     rInfo.bCanConvToPoly    =bCanConv;
 454     rInfo.bCanConvToPathLineToArea=bCanConv;
 455     rInfo.bCanConvToPolyLineToArea=bCanConv;
 456     rInfo.bCanConvToContour = (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary());
 457 }
 458
 459 sal_uInt16 SdrTextObj::GetObjIdentifier() const
 460 {
 461     return sal_uInt16(eTextKind);
 462 }
 463
 464 bool SdrTextObj::HasTextImpl( SdrOutliner* pOutliner )
 465 {
 466     bool bRet=false;
 467     if(pOutliner)
 468     {
 469         Paragraph* p1stPara=pOutliner->GetParagraph( 0 );
 470         sal_Int32 nParaCount=pOutliner->GetParagraphCount();
 471         if(p1stPara==NULL)
 472             nParaCount=0;
 473
 474         if(nParaCount==1)
 475         {
 476             // if it is only one paragraph, check if that paragraph is empty
 477             if( pOutliner->GetText(p1stPara).isEmpty() )
 478                 nParaCount = 0;
 479         }
 480
 481         bRet= nParaCount!=0;
 482     }
 483     return bRet;
 484 }
 485
 486 bool SdrTextObj::HasEditText() const
 487 {
 488     return HasTextImpl( pEdtOutl );
 489 }
 490
 491 void SdrTextObj::SetPage(SdrPage* pNewPage)
 492 {
 493     bool bRemove=pNewPage==NULL && pPage!=NULL;
 494     bool bInsert=pNewPage!=NULL && pPage==NULL;
 495     bool bLinked=IsLinkedText();
 496
 497     if (bLinked && bRemove) {
 498         ImpLinkAbmeldung();
 499     }
 500
 501     SdrAttrObj::SetPage(pNewPage);
 502
 503     if (bLinked && bInsert) {
 504         ImpLinkAnmeldung();
 505     }
 506 }
 507
 508 void SdrTextObj::SetModel(SdrModel* pNewModel)
 509 {
 510     SdrModel* pOldModel=pModel;
 511     bool bLinked=IsLinkedText();
 512     bool bChg=pNewModel!=pModel;
 513
 514     if (bLinked && bChg)
 515     {
 516         ImpLinkAbmeldung();
 517     }
 518
 519     SdrAttrObj::SetModel(pNewModel);
 520
 521     if( bChg )
 522     {
 523         if( pNewModel != 0 && pOldModel != 0 )
 524             SetTextSizeDirty();
 525
 526         sal_Int32 nCount = getTextCount();
 527         for( sal_Int32 nText = 0; nText < nCount; nText++ )
 528         {
 529             SdrText* pText = getText( nText );
 530             if( pText )
 531                 pText->SetModel( pNewModel );
 532         }
 533     }
 534
 535     if (bLinked && bChg)
 536     {
 537         ImpLinkAnmeldung();
 538     }
 539 }
 540
 541 bool SdrTextObj::NbcSetEckenradius(long nRad)
 542 {
 543     SetObjectItem(makeSdrEckenradiusItem(nRad));
 544     return true;
 545 }
 546
 547 // #115391# This implementation is based on the object size (aRect) and the
 548 // states of IsAutoGrowWidth/Height to correctly set TextMinFrameWidth/Height
 549 void SdrTextObj::AdaptTextMinSize()
 550 {
 551     if (!bTextFrame)
 552         // Only do this for text frame.
 553         return;
 554
 555     if (pModel && pModel->IsPasteResize())
 556         // Don't do this during paste resize.
 557         return;
 558
 559     const bool bW = IsAutoGrowWidth();
 560     const bool bH = IsAutoGrowHeight();
 561
 562     if (!bW && !bH)
 563         // No auto grow requested.  Bail out.
 564         return;
 565
 566     SfxItemSet aSet(
 567         *GetObjectItemSet().GetPool(),
 568         SDRATTR_TEXT_MINFRAMEHEIGHT, SDRATTR_TEXT_AUTOGROWHEIGHT,
 569         SDRATTR_TEXT_MINFRAMEWIDTH, SDRATTR_TEXT_AUTOGROWWIDTH, // contains SDRATTR_TEXT_MAXFRAMEWIDTH
 570         0, 0);
 571
 572     if(bW)
 573     {
 574         // Set minimum width.
 575         const long nDist = GetTextLeftDistance() + GetTextRightDistance();
 576         const long nW = std::max<long>(0, maRect.GetWidth() - 1 - nDist); // text width without margins
 577
 578         aSet.Put(makeSdrTextMinFrameWidthItem(nW));
 579
 580         if(!IsVerticalWriting() && bDisableAutoWidthOnDragging)
 581         {
 582             bDisableAutoWidthOnDragging = true;
 583             aSet.Put(makeSdrTextAutoGrowWidthItem(false));
 584         }
 585     }
 586
 587     if(bH)
 588     {
 589         // Set Minimum height.
 590         const long nDist = GetTextUpperDistance() + GetTextLowerDistance();
 591         const long nH = std::max<long>(0, maRect.GetHeight() - 1 - nDist); // text height without margins
 592
 593         aSet.Put(makeSdrTextMinFrameHeightItem(nH));
 594
 595         if(IsVerticalWriting() && bDisableAutoWidthOnDragging)
 596         {
 597             bDisableAutoWidthOnDragging = false;
 598             aSet.Put(makeSdrTextAutoGrowHeightItem(false));
 599         }
 600     }
 601
 602     SetObjectItemSet(aSet);
 603 }
 604
 605 void SdrTextObj::ImpSetContourPolygon( SdrOutliner& rOutliner, Rectangle& rAnchorRect, bool bLineWidth ) const
 606 {
 607     basegfx::B2DPolyPolygon aXorPolyPolygon(TakeXorPoly());
 608     basegfx::B2DPolyPolygon* pContourPolyPolygon = 0L;
 609     basegfx::B2DHomMatrix aMatrix(basegfx::tools::createTranslateB2DHomMatrix(
 610         -rAnchorRect.Left(), -rAnchorRect.Top()));
 611
 612     if(aGeo.nRotationAngle)
 613     {
 614         // Unrotate!
 615         aMatrix.rotate(-aGeo.nRotationAngle * nPi180);
 616     }
 617
 618     aXorPolyPolygon.transform(aMatrix);
 619
 620     if( bLineWidth )
 621     {
 622         // Take line width into account.
 623         // When doing the hit test, avoid this. (Performance!)
 624         pContourPolyPolygon = new basegfx::B2DPolyPolygon();
 625
 626         // test if shadow needs to be avoided for TakeContour()
 627         const SfxItemSet& rSet = GetObjectItemSet();
 628         bool bShadowOn = static_cast<const SdrOnOffItem&>(rSet.Get(SDRATTR_SHADOW)).GetValue();
 629
 630         // #i33696#
 631         // Remember TextObject currently set at the DrawOutliner, it WILL be
 632         // replaced during calculating the outline since it uses an own paint
 633         // and that one uses the DrawOutliner, too.
 634         const SdrTextObj* pLastTextObject = rOutliner.GetTextObj();
 635
 636         if(bShadowOn)
 637         {
 638             // force shadow off
 639             SdrObject* pCopy = Clone();
 640             pCopy->SetMergedItem(makeSdrShadowItem(false));
 641             *pContourPolyPolygon = pCopy->TakeContour();
 642             SdrObject::Free( pCopy );
 643         }
 644         else
 645         {
 646             *pContourPolyPolygon = TakeContour();
 647         }
 648
 649         // #i33696#
 650         // restore remembered text object
 651         if(pLastTextObject != rOutliner.GetTextObj())
 652         {
 653             rOutliner.SetTextObj(pLastTextObject);
 654         }
 655
 656         pContourPolyPolygon->transform(aMatrix);
 657     }
 658
 659     rOutliner.SetPolygon(aXorPolyPolygon, pContourPolyPolygon);
 660     delete pContourPolyPolygon;
 661 }
 662
 663 void SdrTextObj::TakeUnrotatedSnapRect(Rectangle& rRect) const
 664 {
 665     rRect=maRect;
 666 }
 667
 668 void SdrTextObj::TakeTextAnchorRect(Rectangle& rAnchorRect) const
 669 {
 670     long nLeftDist=GetTextLeftDistance();
 671     long nRightDist=GetTextRightDistance();
 672     long nUpperDist=GetTextUpperDistance();
 673     long nLowerDist=GetTextLowerDistance();
 674     Rectangle aAnkRect(maRect); // the rectangle in which we anchor
 675     bool bFrame=IsTextFrame();
 676     if (!bFrame) {
 677         TakeUnrotatedSnapRect(aAnkRect);
 678     }
 679     Point aRotateRef(aAnkRect.TopLeft());
 680     aAnkRect.Left()+=nLeftDist;
 681     aAnkRect.Top()+=nUpperDist;
 682     aAnkRect.Right()-=nRightDist;
 683     aAnkRect.Bottom()-=nLowerDist;
 684
 685     // Since sizes may be bigger than the object bounds it is necessary to
 686     // justify the rect now.
 687     ImpJustifyRect(aAnkRect);
 688
 689     if (bFrame) {
 690         // TODO: Optimize this.
 691         if (aAnkRect.GetWidth()<2) aAnkRect.Right()=aAnkRect.Left()+1; // minimum size h and v: 2 px
 692         if (aAnkRect.GetHeight()<2) aAnkRect.Bottom()=aAnkRect.Top()+1;
 693     }
 694     if (aGeo.nRotationAngle!=0) {
 695         Point aTmpPt(aAnkRect.TopLeft());
 696         RotatePoint(aTmpPt,aRotateRef,aGeo.nSin,aGeo.nCos);
 697         aTmpPt-=aAnkRect.TopLeft();
 698         aAnkRect.Move(aTmpPt.X(),aTmpPt.Y());
 699     }
 700     rAnchorRect=aAnkRect;
 701 }
 702
 703 void SdrTextObj::TakeTextRect( SdrOutliner& rOutliner, Rectangle& rTextRect, bool bNoEditText,
 704                                Rectangle* pAnchorRect, bool bLineWidth ) const
 705 {
 706     Rectangle aAnkRect; // the rectangle in which we anchor
 707     TakeTextAnchorRect(aAnkRect);
 708     SdrTextVertAdjust eVAdj=GetTextVerticalAdjust();
 709     SdrTextHorzAdjust eHAdj=GetTextHorizontalAdjust();
 710     SdrTextAniKind      eAniKind=GetTextAniKind();
 711     SdrTextAniDirection eAniDirection=GetTextAniDirection();
 712
 713     bool bFitToSize(IsFitToSize());
 714     bool bContourFrame=IsContourTextFrame();
 715
 716     bool bFrame=IsTextFrame();
 717     EEControlBits nStat0=rOutliner.GetControlWord();
 718     Size aNullSize;
 719     if (!bContourFrame)
 720     {
 721         rOutliner.SetControlWord(nStat0|EEControlBits::AUTOPAGESIZE);
 722         rOutliner.SetMinAutoPaperSize(aNullSize);
 723         rOutliner.SetMaxAutoPaperSize(Size(1000000,1000000));
 724     }
 725
 726     if (!bFitToSize && !bContourFrame)
 727     {
 728         long nAnkWdt=aAnkRect.GetWidth();
 729         long nAnkHgt=aAnkRect.GetHeight();
 730         if (bFrame)
 731         {
 732             long nWdt=nAnkWdt;
 733             long nHgt=nAnkHgt;
 734
 735             bool bInEditMode = IsInEditMode();
 736
 737             if (!bInEditMode && (eAniKind==SDRTEXTANI_SCROLL || eAniKind==SDRTEXTANI_ALTERNATE || eAniKind==SDRTEXTANI_SLIDE))
 738             {
 739                 // unlimited paper size for ticker text
 740                 if (eAniDirection==SDRTEXTANI_LEFT || eAniDirection==SDRTEXTANI_RIGHT) nWdt=1000000;
 741                 if (eAniDirection==SDRTEXTANI_UP || eAniDirection==SDRTEXTANI_DOWN) nHgt=1000000;
 742             }
 743
 744             // #i119885# Do not limit/force height to geometrical frame (vice versa for vertical writing)
 745             if(IsVerticalWriting())
 746             {
 747                 nWdt = 1000000;
 748             }
 749             else
 750             {
 751                 nHgt = 1000000;
 752             }
 753
 754             rOutliner.SetMaxAutoPaperSize(Size(nWdt,nHgt));
 755         }
 756
 757         // New try with _BLOCK for hor and ver after completely
 758         // supporting full width for vertical text.
 759         if(SDRTEXTHORZADJUST_BLOCK == eHAdj && !IsVerticalWriting())
 760         {
 761             rOutliner.SetMinAutoPaperSize(Size(nAnkWdt, 0));
 762         }
 763
 764         if(SDRTEXTVERTADJUST_BLOCK == eVAdj && IsVerticalWriting())
 765         {
 766             rOutliner.SetMinAutoPaperSize(Size(0, nAnkHgt));
 767         }
 768     }
 769
 770     rOutliner.SetPaperSize(aNullSize);
 771     if (bContourFrame)
 772         ImpSetContourPolygon( rOutliner, aAnkRect, bLineWidth );
 773
 774     // put text into the outliner, if available from the edit outliner
 775     SdrText* pText = getActiveText();
 776     OutlinerParaObject* pOutlinerParaObject = pText ? pText->GetOutlinerParaObject() : 0;
 777     OutlinerParaObject* pPara = (pEdtOutl && !bNoEditText) ? pEdtOutl->CreateParaObject() : pOutlinerParaObject;
 778
 779     if (pPara)
 780     {
 781         bool bHitTest = false;
 782         if( pModel )
 783             bHitTest = &pModel->GetHitTestOutliner() == &rOutliner;
 784
 785         const SdrTextObj* pTestObj = rOutliner.GetTextObj();
 786         if( !pTestObj || !bHitTest || pTestObj != this ||
 787             pTestObj->GetOutlinerParaObject() != pOutlinerParaObject )
 788         {
 789             if( bHitTest ) // #i33696# take back fix #i27510#
 790             {
 791                 rOutliner.SetTextObj( this );
 792                 rOutliner.SetFixedCellHeight(static_cast<const SdrTextFixedCellHeightItem&>(GetMergedItem(SDRATTR_TEXT_USEFIXEDCELLHEIGHT)).GetValue());
 793             }
 794
 795             rOutliner.SetUpdateMode(true);
 796             rOutliner.SetText(*pPara);
 797         }
 798     }
 799     else
 800     {
 801         rOutliner.SetTextObj( NULL );
 802     }
 803
 804     if (pEdtOutl && !bNoEditText && pPara)
 805         delete pPara;
 806
 807     rOutliner.SetUpdateMode(true);
 808     rOutliner.SetControlWord(nStat0);
 809
 810     if( pText )
 811         pText->CheckPortionInfo(rOutliner);
 812
 813     Point aTextPos(aAnkRect.TopLeft());
 814     Size aTextSiz(rOutliner.GetPaperSize()); // GetPaperSize() adds a little tolerance, right?
 815
 816     // For draw objects containing text correct hor/ver alignment if text is bigger
 817     // than the object itself. Without that correction, the text would always be
 818     // formatted to the left edge (or top edge when vertical) of the draw object.
 819     if(!IsTextFrame())
 820     {
 821         if(aAnkRect.GetWidth() < aTextSiz.Width() && !IsVerticalWriting())
 822         {
 823             // Horizontal case here. Correct only if eHAdj == SDRTEXTHORZADJUST_BLOCK,
 824             // else the alignment is wanted.
 825             if(SDRTEXTHORZADJUST_BLOCK == eHAdj)
 826             {
 827                 eHAdj = SDRTEXTHORZADJUST_CENTER;
 828             }
 829         }
 830
 831         if(aAnkRect.GetHeight() < aTextSiz.Height() && IsVerticalWriting())
 832         {
 833             // Vertical case here. Correct only if eHAdj == SDRTEXTVERTADJUST_BLOCK,
 834             // else the alignment is wanted.
 835             if(SDRTEXTVERTADJUST_BLOCK == eVAdj)
 836             {
 837                 eVAdj = SDRTEXTVERTADJUST_CENTER;
 838             }
 839         }
 840     }
 841
 842     if (eHAdj==SDRTEXTHORZADJUST_CENTER || eHAdj==SDRTEXTHORZADJUST_RIGHT)
 843     {
 844         long nFreeWdt=aAnkRect.GetWidth()-aTextSiz.Width();
 845         if (eHAdj==SDRTEXTHORZADJUST_CENTER)
 846             aTextPos.X()+=nFreeWdt/2;
 847         if (eHAdj==SDRTEXTHORZADJUST_RIGHT)
 848             aTextPos.X()+=nFreeWdt;
 849     }
 850     if (eVAdj==SDRTEXTVERTADJUST_CENTER || eVAdj==SDRTEXTVERTADJUST_BOTTOM)
 851     {
 852         long nFreeHgt=aAnkRect.GetHeight()-aTextSiz.Height();
 853         if (eVAdj==SDRTEXTVERTADJUST_CENTER)
 854             aTextPos.Y()+=nFreeHgt/2;
 855         if (eVAdj==SDRTEXTVERTADJUST_BOTTOM)
 856             aTextPos.Y()+=nFreeHgt;
 857     }
 858     if (aGeo.nRotationAngle!=0)
 859         RotatePoint(aTextPos,aAnkRect.TopLeft(),aGeo.nSin,aGeo.nCos);
 860
 861     if (pAnchorRect)
 862         *pAnchorRect=aAnkRect;
 863
 864     // rTextRect might not be correct in some cases at ContourFrame
 865     rTextRect=Rectangle(aTextPos,aTextSiz);
 866     if (bContourFrame)
 867         rTextRect=aAnkRect;
 868 }
 869
 870 OutlinerParaObject* SdrTextObj::GetEditOutlinerParaObject() const
 871 {
 872     OutlinerParaObject* pPara=NULL;
 873     if( HasTextImpl( pEdtOutl ) )
 874     {
 875         sal_Int32 nParaCount = pEdtOutl->GetParagraphCount();
 876         pPara = pEdtOutl->CreateParaObject(0, nParaCount);
 877     }
 878     return pPara;
 879 }
 880
 881 void SdrTextObj::ImpSetCharStretching(SdrOutliner& rOutliner, const Size& rTextSize, const Size& rShapeSize, Fraction& rFitXKorreg)
 882 {
 883     OutputDevice* pOut = rOutliner.GetRefDevice();
 884     bool bNoStretching(false);
 885
 886     if(pOut && pOut->GetOutDevType() == OUTDEV_PRINTER)
 887     {
 888         // check whether CharStretching is possible at all
 889         GDIMetaFile* pMtf = pOut->GetConnectMetaFile();
 890         OUString aTestString(static_cast<sal_Unicode>('J'));
 891
 892         if(pMtf && (!pMtf->IsRecord() || pMtf->IsPause()))
 893             pMtf = NULL;
 894
 895         if(pMtf)
 896             pMtf->Pause(true);
 897
 898         vcl::Font aFontMerk(pOut->GetFont());
 899         vcl::Font aTmpFont( OutputDevice::GetDefaultFont( DefaultFontType::SERIF, LANGUAGE_SYSTEM, GetDefaultFontFlags::OnlyOne ) );
 900
 901         aTmpFont.SetSize(Size(0,100));
 902         pOut->SetFont(aTmpFont);
 903         Size aSize1(pOut->GetTextWidth(aTestString), pOut->GetTextHeight());
 904         aTmpFont.SetSize(Size(800,100));
 905         pOut->SetFont(aTmpFont);
 906         Size aSize2(pOut->GetTextWidth(aTestString), pOut->GetTextHeight());
 907         pOut->SetFont(aFontMerk);
 908
 909         if(pMtf)
 910             pMtf->Pause(false);
 911
 912         bNoStretching = (aSize1 == aSize2);
 913
 914 #ifdef WNT
 915         // Windows zooms the font proportionally when using Size(100,500),
 916         // we don't like that.
 917         if(aSize2.Height() >= aSize1.Height() * 2)
 918         {
 919             bNoStretching = true;
 920         }
 921 #endif
 922     }
 923     unsigned nLoopCount=0;
 924     bool bNoMoreLoop = false;
 925     long nXDiff0=0x7FFFFFFF;
 926     long nWantWdt=rShapeSize.Width();
 927     long nIsWdt=rTextSize.Width();
 928     if (nIsWdt==0) nIsWdt=1;
 929
 930     long nWantHgt=rShapeSize.Height();
 931     long nIsHgt=rTextSize.Height();
 932     if (nIsHgt==0) nIsHgt=1;
 933
 934     long nXTolPl=nWantWdt/100; // tolerance: +1%
 935     long nXTolMi=nWantWdt/25;  // tolerance: -4%
 936     long nXKorr =nWantWdt/20;  // correction scale: 5%
 937
 938     long nX=(nWantWdt*100) /nIsWdt; // calculate X stretching
 939     long nY=(nWantHgt*100) /nIsHgt; // calculate Y stretching
 940     bool bChkX = true;
 941     if (bNoStretching) { // might only be possible proportionally
 942         if (nX>nY) { nX=nY; bChkX=false; }
 943         else { nY=nX; }
 944     }
 945
 946     while (nLoopCount<5 && !bNoMoreLoop) {
 947         if (nX<0) nX=-nX;
 948         if (nX<1) { nX=1; bNoMoreLoop = true; }
 949         if (nX>65535) { nX=65535; bNoMoreLoop = true; }
 950
 951         if (nY<0) nY=-nY;
 952         if (nY<1) { nY=1; bNoMoreLoop = true; }
 953         if (nY>65535) { nY=65535; bNoMoreLoop = true; }
 954
 955         // exception, there is no text yet (horizontal case)
 956         if(nIsWdt <= 1)
 957         {
 958             nX = nY;
 959             bNoMoreLoop = true;
 960         }
 961
 962         // exception, there is no text yet (vertical case)
 963         if(nIsHgt <= 1)
 964         {
 965             nY = nX;
 966             bNoMoreLoop = true;
 967         }
 968
 969         rOutliner.SetGlobalCharStretching((sal_uInt16)nX,(sal_uInt16)nY);
 970         nLoopCount++;
 971         Size aSiz(rOutliner.CalcTextSize());
 972         long nXDiff=aSiz.Width()-nWantWdt;
 973         rFitXKorreg=Fraction(nWantWdt,aSiz.Width());
 974         if (((nXDiff>=nXTolMi || !bChkX) && nXDiff<=nXTolPl) || nXDiff==nXDiff0) {
 975             bNoMoreLoop = true;
 976         } else {
 977             // correct stretching factors
 978             long nMul=nWantWdt;
 979             long nDiv=aSiz.Width();
 980             if (std::abs(nXDiff)<=2*nXKorr) {
 981                 if (nMul>nDiv) nDiv+=(nMul-nDiv)/2; // but only add half of what we calculated,
 982                 else nMul+=(nDiv-nMul)/2;           // because the EditEngine calculates wrongly later on
 983             }
 984             nX=nX*nMul/nDiv;
 985             if (bNoStretching) nY=nX;
 986         }
 987         nXDiff0=nXDiff;
 988     }
 989 }
 990
 991 OUString SdrTextObj::TakeObjNameSingul() const
 992 {
 993     OUString aStr;
 994
 995     switch(eTextKind)
 996     {
 997         case OBJ_OUTLINETEXT:
 998         {
 999             aStr = ImpGetResStr(STR_ObjNameSingulOUTLINETEXT);
1000             break;
1001         }
1002
1003         case OBJ_TITLETEXT  :
1004         {
1005             aStr = ImpGetResStr(STR_ObjNameSingulTITLETEXT);
1006             break;
1007         }
1008
1009         default:
1010         {
1011             if(IsLinkedText())
1012                 aStr = ImpGetResStr(STR_ObjNameSingulTEXTLNK);
1013             else
1014                 aStr = ImpGetResStr(STR_ObjNameSingulTEXT);
1015             break;
1016         }
1017     }
1018
1019     OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject();
1020     if(pOutlinerParaObject && eTextKind != OBJ_OUTLINETEXT)
1021     {
1022         // shouldn't currently cause any problems at OUTLINETEXT
1023         OUString aStr2(comphelper::string::stripStart(pOutlinerParaObject->GetTextObject().GetText(0), ' '));
1024
1025         // avoid non expanded text portions in object name
1026         // (second condition is new)
1027         if(!aStr2.isEmpty() && aStr2.indexOf(sal_Unicode(255)) == -1)
1028         {
1029             // space between ResStr and content text
1030             aStr += " ";
1031
1032             aStr += "\'";
1033
1034             if(aStr2.getLength() > 10)
1035             {
1036                 aStr2 = aStr2.copy(0, 8);
1037                 aStr2 += "...";
1038             }
1039
1040             aStr += aStr2;
1041             aStr += "\'";
1042         }
1043     }
1044
1045     OUStringBuffer sName(aStr);
1046
1047     OUString aName(GetName());
1048     if (!aName.isEmpty())
1049     {
1050         sName.append(' ');
1051         sName.append('\'');
1052         sName.append(aName);
1053         sName.append('\'');
1054     }
1055
1056     return sName.makeStringAndClear();
1057 }
1058
1059 OUString SdrTextObj::TakeObjNamePlural() const
1060 {
1061     OUString sName;
1062     switch (eTextKind) {
1063         case OBJ_OUTLINETEXT: sName=ImpGetResStr(STR_ObjNamePluralOUTLINETEXT); break;
1064         case OBJ_TITLETEXT  : sName=ImpGetResStr(STR_ObjNamePluralTITLETEXT);   break;
1065         default: {
1066             if (IsLinkedText()) {
1067                 sName=ImpGetResStr(STR_ObjNamePluralTEXTLNK);
1068             } else {
1069                 sName=ImpGetResStr(STR_ObjNamePluralTEXT);
1070             }
1071         } break;
1072     } // switch
1073     return sName;
1074 }
1075
1076 SdrTextObj* SdrTextObj::Clone() const
1077 {
1078     return CloneHelper< SdrTextObj >();
1079 }
1080
1081 SdrTextObj& SdrTextObj::operator=(const SdrTextObj& rObj)
1082 {
1083     if( this == &rObj )
1084         return *this;
1085     // call parent
1086     SdrObject::operator=(rObj);
1087
1088     maRect = rObj.maRect;
1089     aGeo      =rObj.aGeo;
1090     eTextKind =rObj.eTextKind;
1091     bTextFrame=rObj.bTextFrame;
1092     aTextSize=rObj.aTextSize;
1093     bTextSizeDirty=rObj.bTextSizeDirty;
1094
1095     // Not all of the necessary parameters were copied yet.
1096     bNoShear = rObj.bNoShear;
1097     bNoRotate = rObj.bNoRotate;
1098     bNoMirror = rObj.bNoMirror;
1099     bDisableAutoWidthOnDragging = rObj.bDisableAutoWidthOnDragging;
1100
1101     OutlinerParaObject* pNewOutlinerParaObject = 0;
1102
1103     SdrText* pText = getActiveText();
1104
1105     if( pText && rObj.HasText() )
1106     {
1107         const Outliner* pEO=rObj.pEdtOutl;
1108         if (pEO!=NULL)
1109         {
1110             pNewOutlinerParaObject = pEO->CreateParaObject();
1111         }
1112         else
1113         {
1114             pNewOutlinerParaObject = new OutlinerParaObject(*rObj.getActiveText()->GetOutlinerParaObject());
1115         }
1116     }
1117
1118     mpText->SetOutlinerParaObject( pNewOutlinerParaObject );
1119     ImpSetTextStyleSheetListeners();
1120     return *this;
1121 }
1122
1123 basegfx::B2DPolyPolygon SdrTextObj::TakeXorPoly() const
1124 {
1125     Polygon aPol(maRect);
1126     if (aGeo.nShearAngle!=0) ShearPoly(aPol,maRect.TopLeft(),aGeo.nTan);
1127     if (aGeo.nRotationAngle!=0) RotatePoly(aPol,maRect.TopLeft(),aGeo.nSin,aGeo.nCos);
1128
1129     basegfx::B2DPolyPolygon aRetval;
1130     aRetval.append(aPol.getB2DPolygon());
1131     return aRetval;
1132 }
1133
1134 basegfx::B2DPolyPolygon SdrTextObj::TakeContour() const
1135 {
1136     basegfx::B2DPolyPolygon aRetval(SdrAttrObj::TakeContour());
1137
1138     // and now add the BoundRect of the text, if necessary
1139     if ( pModel && GetOutlinerParaObject() && !IsFontwork() && !IsContourTextFrame() )
1140     {
1141         // using Clone()-Paint() strategy inside TakeContour() leaves a destroyed
1142         // SdrObject as pointer in DrawOutliner. Set *this again in fetching the outliner
1143         // in every case
1144         SdrOutliner& rOutliner=ImpGetDrawOutliner();
1145
1146         Rectangle aAnchor2;
1147         Rectangle aR;
1148         TakeTextRect(rOutliner,aR,false,&aAnchor2);
1149         rOutliner.Clear();
1150         bool bFitToSize(IsFitToSize());
1151         if (bFitToSize) aR=aAnchor2;
1152         Polygon aPol(aR);
1153         if (aGeo.nRotationAngle!=0) RotatePoly(aPol,aR.TopLeft(),aGeo.nSin,aGeo.nCos);
1154
1155         aRetval.append(aPol.getB2DPolygon());
1156     }
1157
1158     return aRetval;
1159 }
1160
1161 void SdrTextObj::RecalcSnapRect()
1162 {
1163     if (aGeo.nRotationAngle!=0 || aGeo.nShearAngle!=0)
1164     {
1165         Polygon aPol(maRect);
1166         if (aGeo.nShearAngle!=0) ShearPoly(aPol,maRect.TopLeft(),aGeo.nTan);
1167         if (aGeo.nRotationAngle!=0) RotatePoly(aPol,maRect.TopLeft(),aGeo.nSin,aGeo.nCos);
1168         maSnapRect=aPol.GetBoundRect();
1169     } else {
1170         maSnapRect = maRect;
1171     }
1172 }
1173
1174 sal_uInt32 SdrTextObj::GetSnapPointCount() const
1175 {
1176     return 4L;
1177 }
1178
1179 Point SdrTextObj::GetSnapPoint(sal_uInt32 i) const
1180 {
1181     Point aP;
1182     switch (i) {
1183         case 0: aP=maRect.TopLeft(); break;
1184         case 1: aP=maRect.TopRight(); break;
1185         case 2: aP=maRect.BottomLeft(); break;
1186         case 3: aP=maRect.BottomRight(); break;
1187         default: aP=maRect.Center(); break;
1188     }
1189     if (aGeo.nShearAngle!=0) ShearPoint(aP,maRect.TopLeft(),aGeo.nTan);
1190     if (aGeo.nRotationAngle!=0) RotatePoint(aP,maRect.TopLeft(),aGeo.nSin,aGeo.nCos);
1191     return aP;
1192 }
1193
1194 void SdrTextObj::ImpCheckMasterCachable()
1195 {
1196     bNotMasterCachable=false;
1197
1198     OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject();
1199
1200     if(!bNotVisibleAsMaster && pOutlinerParaObject && pOutlinerParaObject->IsEditDoc() )
1201     {
1202         const EditTextObject& rText= pOutlinerParaObject->GetTextObject();
1203         bNotMasterCachable=rText.HasField(SvxPageField::StaticClassId());
1204         if( !bNotMasterCachable )
1205         {
1206             bNotMasterCachable=rText.HasField(SvxHeaderField::StaticClassId());
1207             if( !bNotMasterCachable )
1208             {
1209                 bNotMasterCachable=rText.HasField(SvxFooterField::StaticClassId());
1210                 if( !bNotMasterCachable )
1211                 {
1212                     bNotMasterCachable=rText.HasField(SvxDateTimeField::StaticClassId());
1213                 }
1214             }
1215         }
1216     }
1217 }
1218
1219 // Extracted from ImpGetDrawOutliner()
1220 void SdrTextObj::ImpInitDrawOutliner( SdrOutliner& rOutl ) const
1221 {
1222     rOutl.SetUpdateMode(false);
1223     sal_uInt16 nOutlinerMode = OUTLINERMODE_OUTLINEOBJECT;
1224     if ( !IsOutlText() )
1225         nOutlinerMode = OUTLINERMODE_TEXTOBJECT;
1226     rOutl.Init( nOutlinerMode );
1227
1228     rOutl.SetGlobalCharStretching(100,100);
1229     EEControlBits nStat=rOutl.GetControlWord();
1230     nStat &= ~EEControlBits(EEControlBits::STRETCHING|EEControlBits::AUTOPAGESIZE);
1231     rOutl.SetControlWord(nStat);
1232     Size aNullSize;
1233     Size aMaxSize(100000,100000);
1234     rOutl.SetMinAutoPaperSize(aNullSize);
1235     rOutl.SetMaxAutoPaperSize(aMaxSize);
1236     rOutl.SetPaperSize(aMaxSize);
1237     rOutl.ClearPolygon();
1238 }
1239
1240 SdrOutliner& SdrTextObj::ImpGetDrawOutliner() const
1241 {
1242     SdrOutliner& rOutl=pModel->GetDrawOutliner(this);
1243
1244     // Code extracted to ImpInitDrawOutliner()
1245     ImpInitDrawOutliner( rOutl );
1246
1247     return rOutl;
1248 }
1249
1250 // Extracted from Paint()
1251 void SdrTextObj::ImpSetupDrawOutlinerForPaint( bool             bContourFrame,
1252                                                SdrOutliner&     rOutliner,
1253                                                Rectangle&       rTextRect,
1254                                                Rectangle&       rAnchorRect,
1255                                                Rectangle&       rPaintRect,
1256                                                Fraction&        rFitXKorreg ) const
1257 {
1258     if (!bContourFrame)
1259     {
1260         // FitToSize can't be used together with ContourFrame for now
1261         if (IsFitToSize() || IsAutoFit())
1262         {
1263             EEControlBits nStat=rOutliner.GetControlWord();
1264             nStat|=EEControlBits::STRETCHING|EEControlBits::AUTOPAGESIZE;
1265             rOutliner.SetControlWord(nStat);
1266         }
1267     }
1268     rOutliner.SetFixedCellHeight(static_cast<const SdrTextFixedCellHeightItem&>(GetMergedItem(SDRATTR_TEXT_USEFIXEDCELLHEIGHT)).GetValue());
1269     TakeTextRect(rOutliner, rTextRect, false, &rAnchorRect);
1270     rPaintRect = rTextRect;
1271
1272     if (!bContourFrame)
1273     {
1274         // FitToSize can't be used together with ContourFrame for now
1275         if (IsFitToSize())
1276         {
1277             ImpSetCharStretching(rOutliner,rTextRect.GetSize(),rAnchorRect.GetSize(),rFitXKorreg);
1278             rPaintRect=rAnchorRect;
1279         }
1280         else if (IsAutoFit())
1281         {
1282             ImpAutoFitText(rOutliner);
1283         }
1284     }
1285 }
1286
1287 void SdrTextObj::ImpAutoFitText( SdrOutliner& rOutliner ) const
1288 {
1289     const Size aShapeSize=GetSnapRect().GetSize();
1290     ImpAutoFitText( rOutliner,
1291                     Size(aShapeSize.Width()-GetTextLeftDistance()-GetTextRightDistance(),
1292                          aShapeSize.Height()-GetTextUpperDistance()-GetTextLowerDistance()),
1293                     IsVerticalWriting() );
1294 }
1295
1296 void SdrTextObj::ImpAutoFitText( SdrOutliner& rOutliner, const Size& rTextSize, bool bIsVerticalWriting )
1297 {
1298     // EditEngine formatting is unstable enough for
1299     // line-breaking text that we need some more samples
1300
1301     // loop early-exits if we detect an already attained value
1302     sal_uInt16 nMinStretchX=0, nMinStretchY=0;
1303     sal_uInt16 aOldStretchXVals[]={0,0,0,0,0,0,0,0,0,0};
1304     const size_t aStretchArySize=SAL_N_ELEMENTS(aOldStretchXVals);
1305     for(unsigned int i=0; i<aStretchArySize; ++i)
1306     {
1307         const Size aCurrTextSize = rOutliner.CalcTextSizeNTP();
1308         double fFactor(1.0);
1309         if( bIsVerticalWriting )
1310             fFactor = double(rTextSize.Width())/aCurrTextSize.Width();
1311         else
1312             fFactor = double(rTextSize.Height())/aCurrTextSize.Height();
1313         // fFactor scales in both x and y directions
1314         // - this is fine for bulleted words
1315         // - but it scales too much for a long paragraph
1316         // - taking sqrt scales long paragraphs the best
1317         // - bulleted words will have to go through more iterations
1318         fFactor = std::sqrt(fFactor);
1319
1320         sal_uInt16 nCurrStretchX, nCurrStretchY;
1321         rOutliner.GetGlobalCharStretching(nCurrStretchX, nCurrStretchY);
1322
1323         if (fFactor >= 1.0 )
1324         {
1325             // resulting text area fits into available shape rect -
1326             // err on the larger stretching, to optimally fill area
1327             nMinStretchX = std::max(nMinStretchX,nCurrStretchX);
1328             nMinStretchY = std::max(nMinStretchY,nCurrStretchY);
1329         }
1330
1331         aOldStretchXVals[i] = nCurrStretchX;
1332         if( std::find(aOldStretchXVals, aOldStretchXVals+i, nCurrStretchX) != aOldStretchXVals+i )
1333             break; // same value already attained once; algo is looping, exit
1334
1335         if (fFactor < 1.0 || (fFactor >= 1.0 && nCurrStretchX != 100))
1336         {
1337             nCurrStretchX = sal::static_int_cast<sal_uInt16>(nCurrStretchX*fFactor);
1338             nCurrStretchY = sal::static_int_cast<sal_uInt16>(nCurrStretchY*fFactor);
1339             rOutliner.SetGlobalCharStretching(std::min(sal_uInt16(100),nCurrStretchX),
1340                                               std::min(sal_uInt16(100),nCurrStretchY));
1341             OSL_TRACE("SdrTextObj::onEditOutlinerStatusEvent(): zoom is %d", nCurrStretchX);
1342         }
1343     }
1344
1345     OSL_TRACE("---- SdrTextObj::onEditOutlinerStatusEvent(): final zoom is %d ----", nMinStretchX);
1346     rOutliner.SetGlobalCharStretching(std::min(sal_uInt16(100),nMinStretchX),
1347                                       std::min(sal_uInt16(100),nMinStretchY));
1348 }
1349
1350 void SdrTextObj::SetupOutlinerFormatting( SdrOutliner& rOutl, Rectangle& rPaintRect ) const
1351 {
1352     ImpInitDrawOutliner( rOutl );
1353     UpdateOutlinerFormatting( rOutl, rPaintRect );
1354 }
1355
1356 void SdrTextObj::UpdateOutlinerFormatting( SdrOutliner& rOutl, Rectangle& rPaintRect ) const
1357 {
1358     Rectangle aTextRect;
1359     Rectangle aAnchorRect;
1360     Fraction aFitXKorreg(1,1);
1361
1362     bool bContourFrame=IsContourTextFrame();
1363
1364     if( GetModel() )
1365     {
1366         MapMode aMapMode(GetModel()->GetScaleUnit(), Point(0,0),
1367                          GetModel()->GetScaleFraction(),
1368                          GetModel()->GetScaleFraction());
1369         rOutl.SetRefMapMode(aMapMode);
1370     }
1371
1372     ImpSetupDrawOutlinerForPaint( bContourFrame, rOutl, aTextRect, aAnchorRect, rPaintRect, aFitXKorreg );
1373 }
1374
1375
1376
1377 OutlinerParaObject* SdrTextObj::GetOutlinerParaObject() const
1378 {
1379     SdrText* pText = getActiveText();
1380     if( pText )
1381         return pText->GetOutlinerParaObject();
1382     else
1383         return 0;
1384 }
1385
1386 void SdrTextObj::NbcSetOutlinerParaObject(OutlinerParaObject* pTextObject)
1387 {
1388     NbcSetOutlinerParaObjectForText( pTextObject, getActiveText() );
1389 }
1390
1391 void SdrTextObj::NbcSetOutlinerParaObjectForText( OutlinerParaObject* pTextObject, SdrText* pText )
1392 {
1393     if( pText )
1394         pText->SetOutlinerParaObject( pTextObject );
1395
1396     if (pText && pText->GetOutlinerParaObject())
1397     {
1398         SvxWritingModeItem aWritingMode(pText->GetOutlinerParaObject()->IsVertical()
1399             ? com::sun::star::text::WritingMode_TB_RL
1400             : com::sun::star::text::WritingMode_LR_TB,
1401             SDRATTR_TEXTDIRECTION);
1402         GetProperties().SetObjectItemDirect(aWritingMode);
1403     }
1404
1405     SetTextSizeDirty();
1406     if (IsTextFrame() && (IsAutoGrowHeight() || IsAutoGrowWidth()))
1407     { // adapt text frame!
1408         NbcAdjustTextFrameWidthAndHeight();
1409     }
1410     if (!IsTextFrame())
1411     {
1412         // the SnapRect keeps its size
1413         SetRectsDirty(true);
1414     }
1415
1416     // always invalidate BoundRect on change
1417     SetBoundRectDirty();
1418     ActionChanged();
1419
1420     ImpSetTextStyleSheetListeners();
1421     ImpCheckMasterCachable();
1422 }
1423
1424 void SdrTextObj::NbcReformatText()
1425 {
1426     SdrText* pText = getActiveText();
1427     if( pText && pText->GetOutlinerParaObject() )
1428     {
1429         pText->ReformatText();
1430         if (bTextFrame)
1431         {
1432             NbcAdjustTextFrameWidthAndHeight();
1433         }
1434         else
1435         {
1436             // the SnapRect keeps its size
1437             SetBoundRectDirty();
1438             SetRectsDirty(true);
1439         }
1440         SetTextSizeDirty();
1441         ActionChanged();
1442         // i22396
1443         // Necessary here since we have no compare operator at the outliner
1444         // para object which may detect changes regarding the combination
1445         // of outliner para data and configuration (e.g., change of
1446         // formatting of text numerals)
1447         GetViewContact().flushViewObjectContacts(false);
1448     }
1449 }
1450
1451 void SdrTextObj::ReformatText()
1452 {
1453     if(GetOutlinerParaObject())
1454     {
1455         Rectangle aBoundRect0;
1456         if (pUserCall!=NULL)
1457             aBoundRect0=GetLastBoundRect();
1458
1459         NbcReformatText();
1460         SetChanged();
1461         BroadcastObjectChange();
1462         SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
1463     }
1464 }
1465
1466 SdrObjGeoData* SdrTextObj::NewGeoData() const
1467 {
1468     return new SdrTextObjGeoData;
1469 }
1470
1471 void SdrTextObj::SaveGeoData(SdrObjGeoData& rGeo) const
1472 {
1473     SdrAttrObj::SaveGeoData(rGeo);
1474     SdrTextObjGeoData& rTGeo=static_cast<SdrTextObjGeoData&>(rGeo);
1475     rTGeo.aRect = maRect;
1476     rTGeo.aGeo   =aGeo;
1477 }
1478
1479 void SdrTextObj::RestGeoData(const SdrObjGeoData& rGeo)
1480 { // RectsDirty is called by SdrObject
1481     SdrAttrObj::RestGeoData(rGeo);
1482     const SdrTextObjGeoData& rTGeo=static_cast<const SdrTextObjGeoData&>(rGeo);
1483     NbcSetLogicRect(rTGeo.aRect);
1484     aGeo   =rTGeo.aGeo;
1485     SetTextSizeDirty();
1486 }
1487
1488 SdrFitToSizeType SdrTextObj::GetFitToSize() const
1489 {
1490     SdrFitToSizeType eType = SDRTEXTFIT_NONE;
1491
1492     if(!IsAutoGrowWidth())
1493         eType = static_cast<const SdrTextFitToSizeTypeItem&>(GetObjectItem(SDRATTR_TEXT_FITTOSIZE)).GetValue();
1494
1495     return eType;
1496 }
1497
1498 const Rectangle& SdrTextObj::GetGeoRect() const
1499 {
1500     return maRect;
1501 }
1502
1503 void SdrTextObj::ForceOutlinerParaObject()
1504 {
1505     SdrText* pText = getActiveText();
1506     if( pText && (pText->GetOutlinerParaObject() == 0) )
1507     {
1508         sal_uInt16 nOutlMode = OUTLINERMODE_TEXTOBJECT;
1509         if( IsTextFrame() && eTextKind == OBJ_OUTLINETEXT )
1510             nOutlMode = OUTLINERMODE_OUTLINEOBJECT;
1511
1512         pText->ForceOutlinerParaObject( nOutlMode );
1513     }
1514 }
1515
1516 bool SdrTextObj::IsVerticalWriting() const
1517 {
1518     if(pEdtOutl)
1519     {
1520         return pEdtOutl->IsVertical();
1521     }
1522
1523     OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject();
1524     if(pOutlinerParaObject)
1525     {
1526         return pOutlinerParaObject->IsVertical();
1527     }
1528
1529     return false;
1530 }
1531
1532 void SdrTextObj::SetVerticalWriting(bool bVertical)
1533 {
1534     OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject();
1535     if( !pOutlinerParaObject && bVertical )
1536     {
1537         // we only need to force a outliner para object if the default of
1538         // horizontal text is changed
1539         ForceOutlinerParaObject();
1540         pOutlinerParaObject = GetOutlinerParaObject();
1541     }
1542
1543     if( pOutlinerParaObject && (pOutlinerParaObject->IsVertical() != (bool)bVertical) )
1544     {
1545         // get item settings
1546         const SfxItemSet& rSet = GetObjectItemSet();
1547         bool bAutoGrowWidth = static_cast<const SdrOnOffItem&>(rSet.Get(SDRATTR_TEXT_AUTOGROWWIDTH)).GetValue();
1548         bool bAutoGrowHeight = static_cast<const SdrOnOffItem&>(rSet.Get(SDRATTR_TEXT_AUTOGROWHEIGHT)).GetValue();
1549
1550         // Also exchange hor/ver adjust items
1551         SdrTextHorzAdjust eHorz = static_cast<const SdrTextHorzAdjustItem&>(rSet.Get(SDRATTR_TEXT_HORZADJUST)).GetValue();
1552         SdrTextVertAdjust eVert = static_cast<const SdrTextVertAdjustItem&>(rSet.Get(SDRATTR_TEXT_VERTADJUST)).GetValue();
1553
1554         // rescue object size
1555         Rectangle aObjectRect = GetSnapRect();
1556
1557         // prepare ItemSet to set exchanged width and height items
1558         SfxItemSet aNewSet(*rSet.GetPool(),
1559             SDRATTR_TEXT_AUTOGROWHEIGHT, SDRATTR_TEXT_AUTOGROWHEIGHT,
1560             // Expanded item ranges to also support hor and ver adjust.
1561             SDRATTR_TEXT_VERTADJUST, SDRATTR_TEXT_VERTADJUST,
1562             SDRATTR_TEXT_AUTOGROWWIDTH, SDRATTR_TEXT_HORZADJUST,
1563             0, 0);
1564
1565         aNewSet.Put(rSet);
1566         aNewSet.Put(makeSdrTextAutoGrowWidthItem(bAutoGrowHeight));
1567         aNewSet.Put(makeSdrTextAutoGrowHeightItem(bAutoGrowWidth));
1568
1569         // Exchange horz and vert adjusts
1570         switch(eVert)
1571         {
1572             case SDRTEXTVERTADJUST_TOP: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT)); break;
1573             case SDRTEXTVERTADJUST_CENTER: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_CENTER)); break;
1574             case SDRTEXTVERTADJUST_BOTTOM: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_LEFT)); break;
1575             case SDRTEXTVERTADJUST_BLOCK: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_BLOCK)); break;
1576         }
1577         switch(eHorz)
1578         {
1579             case SDRTEXTHORZADJUST_LEFT: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BOTTOM)); break;
1580             case SDRTEXTHORZADJUST_CENTER: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_CENTER)); break;
1581             case SDRTEXTHORZADJUST_RIGHT: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_TOP)); break;
1582             case SDRTEXTHORZADJUST_BLOCK: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BLOCK)); break;
1583         }
1584
1585         SetObjectItemSet(aNewSet);
1586
1587         pOutlinerParaObject = GetOutlinerParaObject();
1588         if( pOutlinerParaObject )
1589         {
1590             // set ParaObject orientation accordingly
1591             pOutlinerParaObject->SetVertical(bVertical);
1592         }
1593
1594         // restore object size
1595         SetSnapRect(aObjectRect);
1596     }
1597 }
1598
1599
1600
1601 // transformation interface for StarOfficeAPI. This implements support for
1602 // homogeneous 3x3 matrices containing the transformation of the SdrObject. At the
1603 // moment it contains a shearX, rotation and translation, but for setting all linear
1604 // transforms like Scale, ShearX, ShearY, Rotate and Translate are supported.
1605
1606
1607 // gets base transformation and rectangle of object. If it's an SdrPathObj it fills the PolyPolygon
1608 // with the base geometry and returns TRUE. Otherwise it returns FALSE.
1609 bool SdrTextObj::TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& /*rPolyPolygon*/) const
1610 {
1611     // get turn and shear
1612     double fRotate = (aGeo.nRotationAngle / 100.0) * F_PI180;
1613     double fShearX = (aGeo.nShearAngle / 100.0) * F_PI180;
1614
1615     // get aRect, this is the unrotated snaprect
1616     Rectangle aRectangle(maRect);
1617
1618     // fill other values
1619     basegfx::B2DTuple aScale(aRectangle.GetWidth(), aRectangle.GetHeight());
1620     basegfx::B2DTuple aTranslate(aRectangle.Left(), aRectangle.Top());
1621
1622     // position maybe relative to anchorpos, convert
1623     if( pModel && pModel->IsWriter() )
1624     {
1625         if(GetAnchorPos().X() || GetAnchorPos().Y())
1626         {
1627             aTranslate -= basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y());
1628         }
1629     }
1630
1631     // force MapUnit to 100th mm
1632     const SfxMapUnit eMapUnit(GetObjectMapUnit());
1633     if(eMapUnit != SFX_MAPUNIT_100TH_MM)
1634     {
1635         switch(eMapUnit)
1636         {
1637             case SFX_MAPUNIT_TWIP :
1638             {
1639                 // position
1640                 aTranslate.setX(ImplTwipsToMM(aTranslate.getX()));
1641                 aTranslate.setY(ImplTwipsToMM(aTranslate.getY()));
1642
1643                 // size
1644                 aScale.setX(ImplTwipsToMM(aScale.getX()));
1645                 aScale.setY(ImplTwipsToMM(aScale.getY()));
1646
1647                 break;
1648             }
1649             default:
1650             {
1651                 OSL_FAIL("TRGetBaseGeometry: Missing unit translation to 100th mm!");
1652             }
1653         }
1654     }
1655
1656     // build matrix
1657     rMatrix = basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix(
1658         aScale,
1659         basegfx::fTools::equalZero(fShearX) ? 0.0 : tan(fShearX),
1660         basegfx::fTools::equalZero(fRotate) ? 0.0 : -fRotate,
1661         aTranslate);
1662
1663     return false;
1664 }
1665
1666 // sets the base geometry of the object using infos contained in the homogeneous 3x3 matrix.
1667 // If it's an SdrPathObj it will use the provided geometry information. The Polygon has
1668 // to use (0,0) as upper left and will be scaled to the given size in the matrix.
1669 void SdrTextObj::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& /*rPolyPolygon*/)
1670 {
1671     // break up matrix
1672     basegfx::B2DTuple aScale;
1673     basegfx::B2DTuple aTranslate;
1674     double fRotate(0.0);
1675     double fShearX(0.0);
1676     rMatrix.decompose(aScale, aTranslate, fRotate, fShearX);
1677
1678     // #i75086# Old DrawingLayer (GeoStat and geometry) does not support holding negative scalings
1679     // in X and Y which equal a 180 degree rotation. Recognize it and react accordingly
1680     if(basegfx::fTools::less(aScale.getX(), 0.0) && basegfx::fTools::less(aScale.getY(), 0.0))
1681     {
1682         aScale.setX(fabs(aScale.getX()));
1683         aScale.setY(fabs(aScale.getY()));
1684         fRotate = fmod(fRotate + F_PI, F_2PI);
1685     }
1686
1687     // reset object shear and rotations
1688     aGeo.nRotationAngle = 0;
1689     aGeo.RecalcSinCos();
1690     aGeo.nShearAngle = 0;
1691     aGeo.RecalcTan();
1692
1693     // force metric to pool metric
1694     const SfxMapUnit eMapUnit(GetObjectMapUnit());
1695     if(eMapUnit != SFX_MAPUNIT_100TH_MM)
1696     {
1697         switch(eMapUnit)
1698         {
1699             case SFX_MAPUNIT_TWIP :
1700             {
1701                 // position
1702                 aTranslate.setX(ImplMMToTwips(aTranslate.getX()));
1703                 aTranslate.setY(ImplMMToTwips(aTranslate.getY()));
1704
1705                 // size
1706                 aScale.setX(ImplMMToTwips(aScale.getX()));
1707                 aScale.setY(ImplMMToTwips(aScale.getY()));
1708
1709                 break;
1710             }
1711             default:
1712             {
1713                 OSL_FAIL("TRSetBaseGeometry: Missing unit translation to PoolMetric!");
1714             }
1715         }
1716     }
1717
1718     // if anchor is used, make position relative to it
1719     if( pModel && pModel->IsWriter() )
1720     {
1721         if(GetAnchorPos().X() || GetAnchorPos().Y())
1722         {
1723             aTranslate += basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y());
1724         }
1725     }
1726
1727     // build and set BaseRect (use scale)
1728     Point aPoint = Point();
1729     Size aSize(FRound(aScale.getX()), FRound(aScale.getY()));
1730     Rectangle aBaseRect(aPoint, aSize);
1731     SetSnapRect(aBaseRect);
1732
1733     // shear?
1734     if(!basegfx::fTools::equalZero(fShearX))
1735     {
1736         GeoStat aGeoStat;
1737         aGeoStat.nShearAngle = FRound((atan(fShearX) / F_PI180) * 100.0);
1738         aGeoStat.RecalcTan();
1739         Shear(Point(), aGeoStat.nShearAngle, aGeoStat.nTan, false);
1740     }
1741
1742     // rotation?
1743     if(!basegfx::fTools::equalZero(fRotate))
1744     {
1745         GeoStat aGeoStat;
1746
1747         // #i78696#
1748         // fRotate is matematically correct, but aGeoStat.nRotationAngle is
1749         // mirrored -> mirror value here
1750         aGeoStat.nRotationAngle = NormAngle360(FRound(-fRotate / F_PI18000));
1751         aGeoStat.RecalcSinCos();
1752         Rotate(Point(), aGeoStat.nRotationAngle, aGeoStat.nSin, aGeoStat.nCos);
1753     }
1754
1755     // translate?
1756     if(!aTranslate.equalZero())
1757     {
1758         Move(Size(FRound(aTranslate.getX()), FRound(aTranslate.getY())));
1759     }
1760 }
1761
1762 bool SdrTextObj::IsReallyEdited() const
1763 {
1764     return pEdtOutl && pEdtOutl->IsModified();
1765 }
1766
1767 // moved inlines here form hxx
1768
1769 long SdrTextObj::GetEckenradius() const
1770 {
1771     return static_cast<const SdrMetricItem&>(GetObjectItemSet().Get(SDRATTR_ECKENRADIUS)).GetValue();
1772 }
1773
1774 long SdrTextObj::GetMinTextFrameHeight() const
1775 {
1776     return static_cast<const SdrMetricItem&>(GetObjectItemSet().Get(SDRATTR_TEXT_MINFRAMEHEIGHT)).GetValue();
1777 }
1778
1779 long SdrTextObj::GetMaxTextFrameHeight() const
1780 {
1781     return static_cast<const SdrMetricItem&>(GetObjectItemSet().Get(SDRATTR_TEXT_MAXFRAMEHEIGHT)).GetValue();
1782 }
1783
1784 long SdrTextObj::GetMinTextFrameWidth() const
1785 {
1786     return static_cast<const SdrMetricItem&>(GetObjectItemSet().Get(SDRATTR_TEXT_MINFRAMEWIDTH)).GetValue();
1787 }
1788
1789 long SdrTextObj::GetMaxTextFrameWidth() const
1790 {
1791     return static_cast<const SdrMetricItem&>(GetObjectItemSet().Get(SDRATTR_TEXT_MAXFRAMEWIDTH)).GetValue();
1792 }
1793
1794 bool SdrTextObj::IsFontwork() const
1795 {
1796     return !bTextFrame // Default is FALSE
1797         && static_cast<const XFormTextStyleItem&>(GetObjectItemSet().Get(XATTR_FORMTXTSTYLE)).GetValue() != XFT_NONE;
1798 }
1799
1800 bool SdrTextObj::IsHideContour() const
1801 {
1802     return !bTextFrame // Default is: no, don't HideContour; HideContour not together with TextFrames
1803         && static_cast<const XFormTextHideFormItem&>(GetObjectItemSet().Get(XATTR_FORMTXTHIDEFORM)).GetValue();
1804 }
1805
1806 bool SdrTextObj::IsContourTextFrame() const
1807 {
1808     return !bTextFrame // ContourFrame not together with normal TextFrames
1809         && static_cast<const SdrOnOffItem&>(GetObjectItemSet().Get(SDRATTR_TEXT_CONTOURFRAME)).GetValue();
1810 }
1811
1812 long SdrTextObj::GetTextLeftDistance() const
1813 {
1814     return static_cast<const SdrMetricItem&>(GetObjectItemSet().Get(SDRATTR_TEXT_LEFTDIST)).GetValue();
1815 }
1816
1817 long SdrTextObj::GetTextRightDistance() const
1818 {
1819     return static_cast<const SdrMetricItem&>(GetObjectItemSet().Get(SDRATTR_TEXT_RIGHTDIST)).GetValue();
1820 }
1821
1822 long SdrTextObj::GetTextUpperDistance() const
1823 {
1824     return static_cast<const SdrMetricItem&>(GetObjectItemSet().Get(SDRATTR_TEXT_UPPERDIST)).GetValue();
1825 }
1826
1827 long SdrTextObj::GetTextLowerDistance() const
1828 {
1829     return static_cast<const SdrMetricItem&>(GetObjectItemSet().Get(SDRATTR_TEXT_LOWERDIST)).GetValue();
1830 }
1831
1832 SdrTextAniKind SdrTextObj::GetTextAniKind() const
1833 {
1834     return static_cast<const SdrTextAniKindItem&>(GetObjectItemSet().Get(SDRATTR_TEXT_ANIKIND)).GetValue();
1835 }
1836
1837 SdrTextAniDirection SdrTextObj::GetTextAniDirection() const
1838 {
1839     return static_cast<const SdrTextAniDirectionItem&>(GetObjectItemSet().Get(SDRATTR_TEXT_ANIDIRECTION)).GetValue();
1840 }
1841
1842 // Get necessary data for text scroll animation. ATM base it on a Text-Metafile and a
1843 // painting rectangle. Rotation is excluded from the returned values.
1844 GDIMetaFile* SdrTextObj::GetTextScrollMetaFileAndRectangle(
1845     Rectangle& rScrollRectangle, Rectangle& rPaintRectangle)
1846 {
1847     GDIMetaFile* pRetval = 0L;
1848     SdrOutliner& rOutliner = ImpGetDrawOutliner();
1849     Rectangle aTextRect;
1850     Rectangle aAnchorRect;
1851     Rectangle aPaintRect;
1852     Fraction aFitXKorreg(1,1);
1853     bool bContourFrame(IsContourTextFrame());
1854
1855     // get outliner set up. To avoid getting a somehow rotated MetaFile,
1856     // temporarily disable object rotation.
1857     sal_Int32 nAngle(aGeo.nRotationAngle);
1858     aGeo.nRotationAngle = 0L;
1859     ImpSetupDrawOutlinerForPaint( bContourFrame, rOutliner, aTextRect, aAnchorRect, aPaintRect, aFitXKorreg );
1860     aGeo.nRotationAngle = nAngle;
1861
1862     Rectangle aScrollFrameRect(aPaintRect);
1863     const SfxItemSet& rSet = GetObjectItemSet();
1864     SdrTextAniDirection eDirection = static_cast<const SdrTextAniDirectionItem&>(rSet.Get(SDRATTR_TEXT_ANIDIRECTION)).GetValue();
1865
1866     if(SDRTEXTANI_LEFT == eDirection || SDRTEXTANI_RIGHT == eDirection)
1867     {
1868         aScrollFrameRect.Left() = aAnchorRect.Left();
1869         aScrollFrameRect.Right() = aAnchorRect.Right();
1870     }
1871
1872     if(SDRTEXTANI_UP == eDirection || SDRTEXTANI_DOWN == eDirection)
1873     {
1874         aScrollFrameRect.Top() = aAnchorRect.Top();
1875         aScrollFrameRect.Bottom() = aAnchorRect.Bottom();
1876     }
1877
1878     // create the MetaFile
1879     pRetval = new GDIMetaFile;
1880     ScopedVclPtrInstance< VirtualDevice > pBlackHole;
1881     pBlackHole->EnableOutput(false);
1882     pRetval->Record(pBlackHole);
1883     Point aPaintPos = aPaintRect.TopLeft();
1884
1885     rOutliner.Draw(pBlackHole, aPaintPos);
1886
1887     pRetval->Stop();
1888     pRetval->WindStart();
1889
1890     // return PaintRectanglePixel and pRetval;
1891     rScrollRectangle = aScrollFrameRect;
1892     rPaintRectangle = aPaintRect;
1893
1894     return pRetval;
1895 }
1896
1897 // Access to TextAnimationAllowed flag
1898 bool SdrTextObj::IsAutoFit() const
1899 {
1900     return GetFitToSize()==SDRTEXTFIT_AUTOFIT;
1901 }
1902
1903 bool SdrTextObj::IsFitToSize() const
1904 {
1905     const SdrFitToSizeType eFit=GetFitToSize();
1906     return (eFit==SDRTEXTFIT_PROPORTIONAL || eFit==SDRTEXTFIT_ALLLINES);
1907 }
1908
1909 void SdrTextObj::SetTextAnimationAllowed(bool bNew)
1910 {
1911     if(mbTextAnimationAllowed != bNew)
1912     {
1913         mbTextAnimationAllowed = bNew;
1914         ActionChanged();
1915     }
1916 }
1917
1918 /** called from the SdrObjEditView during text edit when the status of the edit outliner changes */
1919 void SdrTextObj::onEditOutlinerStatusEvent( EditStatus* pEditStatus )
1920 {
1921     const EditStatusFlags nStat = pEditStatus->GetStatusWord();
1922     const bool bGrowX = bool(nStat & EditStatusFlags::TEXTWIDTHCHANGED);
1923     const bool bGrowY = bool(nStat & EditStatusFlags::TEXTHEIGHTCHANGED);
1924     if(bTextFrame && (bGrowX || bGrowY))
1925     {
1926         if ((bGrowX && IsAutoGrowWidth()) || (bGrowY && IsAutoGrowHeight()))
1927         {
1928             AdjustTextFrameWidthAndHeight();
1929         }
1930         else if (IsAutoFit() && !mbInDownScale)
1931         {
1932             assert(pEdtOutl);
1933             mbInDownScale = true;
1934
1935             // sucks that we cannot disable paints via
1936             // pEdtOutl->SetUpdateMode(FALSE) - but EditEngine skips
1937             // formatting as well, then.
1938             ImpAutoFitText(*pEdtOutl);
1939             mbInDownScale = false;
1940         }
1941     }
1942 }
1943
1944 /** returns the currently active text. */
1945 SdrText* SdrTextObj::getActiveText() const
1946 {
1947     if( !mpText )
1948         return getText( 0 );
1949     else
1950         return mpText;
1951 }
1952
1953 /** returns the nth available text. */
1954 SdrText* SdrTextObj::getText( sal_Int32 nIndex ) const
1955 {
1956     if( nIndex == 0 )
1957     {
1958         if( mpText == 0 )
1959             const_cast< SdrTextObj* >(this)->mpText = new SdrText( *(const_cast< SdrTextObj* >(this)) );
1960         return mpText;
1961     }
1962     else
1963     {
1964         return 0;
1965     }
1966 }
1967
1968 /** returns the number of texts available for this object. */
1969 sal_Int32 SdrTextObj::getTextCount() const
1970 {
1971     return 1;
1972 }
1973
1974 /** changes the current active text */
1975 void SdrTextObj::setActiveText( sal_Int32 /*nIndex*/ )
1976 {
1977 }
1978
1979 /** returns the index of the text that contains the given point or -1 */
1980 sal_Int32 SdrTextObj::CheckTextHit(const Point& /*rPnt*/) const
1981 {
1982     return 0;
1983 }
1984
1985 void SdrTextObj::SetObjectItemNoBroadcast(const SfxPoolItem& rItem)
1986 {
1987     static_cast< sdr::properties::TextProperties& >(GetProperties()).SetObjectItemNoBroadcast(rItem);
1988 }
1989
1990
1991
1992 // The concept of the text object:
1993 // ~~~~~~~~~~~~~~~~~~~~~~~~
1994 // Attributes/Variations:
1995 // - bool text frame / graphics object with caption
1996 // - bool FontWork                 (if it is not a text frame and not a ContourTextFrame)
1997 // - bool ContourTextFrame         (if it is not a text frame and not Fontwork)
1998 // - long rotation angle               (if it is not FontWork)
1999 // - long text frame margins           (if it is not FontWork)
2000 // - bool FitToSize                (if it is not FontWork)
2001 // - bool AutoGrowingWidth/Height  (if it is not FitToSize and not FontWork)
2002 // - long Min/MaxFrameWidth/Height     (if AutoGrowingWidth/Height)
2003 // - enum horizontal text anchoring left,center,right,justify/block,Stretch(ni)
2004 // - enum vertical text anchoring top, middle, bottom, block, stretch(ni)
2005 // - enum ticker text                  (if it is not FontWork)
2006
2007 // Every derived object is either a text frame (bTextFrame=true)
2008 // or a drawing object with a caption (bTextFrame=false).
2009
2010 // Default anchoring for text frames:
2011 //   SDRTEXTHORZADJUST_BLOCK, SDRTEXTVERTADJUST_TOP
2012 //   = static Pool defaults
2013 // Default anchoring for drawing objects with a caption:
2014 //   SDRTEXTHORZADJUST_CENTER, SDRTEXTVERTADJUST_CENTER
2015 //   via "hard" attribution of SdrAttrObj
2016
2017 // Every object derived from SdrTextObj must return an "UnrotatedSnapRect"
2018 // (->TakeUnrotatedSnapRect()) (the reference point for the rotation is the top
2019 // left of the rectangle (aGeo.nRotationAngle)) which is the basis for anchoring
2020 // text. We then subtract the text frame margins from this rectangle, as a re-
2021 // sult we get the anchoring area (->TakeTextAnchorRect()). Within this area, we
2022 // calculate the anchoring point and the painting area, depending on the hori-
2023 // zontal and vertical adjustment of the text (SdrTextVertAdjust,
2024 // SdrTextHorzAdjust).
2025 // In the case of drawing objects with a caption the painting area might well
2026 // be larger than the anchoring area, for text frames on the other hand, it is
2027 // always of the same or a smaller size (except when there are negative text
2028 // frame margins).
2029
2030 // FitToSize takes priority over text anchoring and AutoGrowHeight/Width. When
2031 // FitToSize is turned on, the painting area is always equal to the anchoring
2032 // area. Additionally, FitToSize doesn't allow automatic line breaks.
2033
2034 // ContourTextFrame:
2035 // - long rotation angle
2036 // - long text frame margins (maybe later)
2037 // - bool FitToSize (maybe later)
2038 // - bool AutoGrowingWidth/Height (maybe much later)
2039 // - long Min/MaxFrameWidth/Height (maybe much later)
2040 // - enum horizontal text anchoring (maybe later, for now: left, centered)
2041 // - enum vertical text anchoring (maybe later, for now: top)
2042 // - enum ticker text (maybe later, maybe even with correct clipping)
2043
2044 // When making changes, check these:
2045 // - Paint
2046 // - HitTest
2047 // - ConvertToPoly
2048 // - Edit
2049 // - Printing, Saving, Painting in neighboring View while editing
2050 // - ModelChanged (e. g. through a neighboring View or rulers) while editing
2051 // - FillColorChanged while editin
2052 // - and many more...
2053
2054
2055
2056 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */