LCOV - code coverage report
Current view: top level - svx/source/svdraw - svdotext.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 653 1019 64.1 %
Date: 2015-06-13 12:38:46 Functions: 74 101 73.3 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.11