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

Generated by: LCOV version 1.10