LCOV - code coverage report
Current view: top level - sw/source/core/inc - txtfrm.hxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 100 0.0 %
Date: 2014-04-14 Functions: 0 58 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             : #ifndef INCLUDED_SW_SOURCE_CORE_INC_TXTFRM_HXX
      20             : #define INCLUDED_SW_SOURCE_CORE_INC_TXTFRM_HXX
      21             : 
      22             : #include <com/sun/star/uno/Sequence.hxx>
      23             : #include <tools/mempool.hxx>
      24             : #include "cntfrm.hxx"
      25             : #include "ndtxt.hxx"
      26             : 
      27             : class SwCharRange;
      28             : class SwTxtNode;
      29             : class SwTxtFormatter;
      30             : class SwTxtFormatInfo;
      31             : class SwParaPortion;
      32             : class WidowsAndOrphans;
      33             : class SwBodyFrm;
      34             : class SwTxtFtn;
      35             : class SwInterHyphInfo;      // Hyphenate()
      36             : class SwCache;
      37             : class SwBorderAttrs;
      38             : class SwFrmFmt;
      39             : class OutputDevice;
      40             : class SwTestFormat;
      41             : struct SwCrsrMoveState;
      42             : struct SwFillData;
      43             : class SwPortionHandler;
      44             : class SwScriptInfo;
      45             : class SwViewOption;
      46             : class SwWrongList;
      47             : 
      48             : #define NON_PRINTING_CHARACTER_COLOR RGB_COLORDATA( 0x6A, 0xBE, 0xD3 )
      49             : 
      50             : /// Represents the visualization of a paragraph.
      51             : class SwTxtFrm: public SwCntntFrm
      52             : {
      53             :     friend class SwTxtIter;
      54             :     friend class SwTestFormat;
      55             :     friend class WidowsAndOrphans;
      56             :     friend class SwTxtFrmLocker;        // duerfen Lock()/Unlock()
      57             :     friend bool sw_ChangeOffset( SwTxtFrm* pFrm, sal_Int32 nNew );
      58             : 
      59             :     static SwCache *pTxtCache;  //Pointer auf den Line-Cache
      60             :     static long nMinPrtLine;    //Diese Linie darf beim Drucken nicht
      61             :         //unterschritten werden, Hack fuer Tabellenzellen ueber mehrere Seiten
      62             : 
      63             :     sal_uLong  nAllLines        :24;//Anzahl der Zeilen fuer das Paint (inkl. nThisLines)
      64             :     sal_uLong  nThisLines       :8; //Anzahl der Zeilen dieses Frames
      65             : 
      66             :     // The x position for flys anchored at this paragraph.
      67             :     // These values are calculated in SwTxtFrm::CalcBaseOfstForFly()
      68             :     SwTwips mnFlyAnchorOfst;
      69             :     // The x position for wrap-through flys anchored at this paragraph.
      70             :     SwTwips mnFlyAnchorOfstNoWrap;
      71             :     SwTwips mnFtnLine;
      72             :     // OD 2004-03-17 #i11860# - re-factoring of #i11859#
      73             :     // member for height of last line (value needed for proportional line spacing)
      74             :     SwTwips mnHeightOfLastLine;
      75             :     // member for the additional first line offset, which is caused by the list
      76             :     // label alignment for list level position and space mode LABEL_ALIGNMENT.
      77             :     // This additional first line offset is used for the text formatting.
      78             :     // It is NOT used for the determination of printing area.
      79             :     SwTwips mnAdditionalFirstLineOffset;
      80             : 
      81             :     sal_Int32 nOfst;           //nOfst gibt den Offset im Cntnt (Anzahl Zeichen) an.
      82             : 
      83             :     sal_uInt16 nCacheIdx;           //Index in den Cache, USHRT_MAX wenn definitiv
      84             :                                 //kein passendes Objekt im Cache steht.
      85             : 
      86             :     //Teilt den Master ab und erzeugt einen Follow oder passt die
      87             :     //Daten im Follow an.
      88             :            void _AdjustFollow( SwTxtFormatter &rLine, const sal_Int32 nOffset,
      89             :                                const sal_Int32 nStrEnd, const sal_uInt8 nMode );
      90             :     inline void AdjustFollow( SwTxtFormatter &rLine, const sal_Int32 nOffset,
      91             :                               const sal_Int32 nStrEnd, const sal_uInt8 nMode );
      92             : 
      93             :     //Iteriert ueber alle Zeilen und stellt das Linespacing
      94             :     //entsprechend dem Attribut ein.
      95             :     void CalcLineSpace();
      96             : 
      97             :     // Wird nur in Format gerufen:
      98             :     void AdjustFrm( const SwTwips nChgHeight, bool bHasToFit = false );
      99             : 
     100             :     // wertet in Format() die Preps aus.
     101             :     bool CalcPreps();
     102             :     void PrepWidows( const sal_uInt16 nNeed, bool bNotify = true );
     103             :     void _InvalidateRange( const SwCharRange &, const long = 0);
     104             :     inline void InvalidateRange( const SwCharRange &, const long = 0);
     105             : 
     106             :     // WidowsAndOrphans, AdjustFrm, AdjustFollow
     107             :     void FormatAdjust( SwTxtFormatter &rLine, WidowsAndOrphans &rFrmBreak,
     108             :                        const sal_Int32 nStrLen, const bool bDummy );
     109             : 
     110             :     bool bLocked        : 1;        // im Format?
     111             :     bool bWidow         : 1;        // sind wir ein Widow
     112             :     bool bJustWidow     : 1;        // haben wir soeben Widow angefordert
     113             :     bool bEmpty         : 1;        // sind wir ein leerer Absatz
     114             :     bool bInFtnConnect  : 1;        // Steht gerade im Connect
     115             :     bool bFtn           : 1;        // Hat mindestens eine Fussnote
     116             :     bool bRepaint       : 1;        // TxtFrm: Repaint steht zur Abholung bereit
     117             :     bool bBlinkPor      : 1;        // enthaelt Blink-Portions
     118             :     bool bFieldFollow   : 1;        // beginne mit Feldrest des Masters
     119             :     bool bHasAnimation  : 1;        // enthaelt animierte SwGrfNumPortion
     120             :     bool bIsSwapped     : 1;        // during text formatting we swap the
     121             :                                         // width and height for vertical formatting
     122             :     // OD 14.03.2003 #i11760# - flag to control, if follow is formatted in
     123             :     // method <CalcFollow(..)>.
     124             :     // E.g., avoid formatting of follow, if method <SwLayoutFrm::FormatWidthCols(..)>
     125             :     // is running.
     126             :     bool mbFollowFormatAllowed : 1;
     127             : 
     128             :     void ResetPreps();
     129           0 :     inline void Lock() { bLocked = true; }
     130           0 :     inline void Unlock() { bLocked = false; }
     131           0 :     inline void SetWidow( const bool bNew ) { bWidow = bNew; }
     132           0 :     inline void SetJustWidow( const bool bNew ) { bJustWidow = bNew; }
     133           0 :     inline void SetEmpty( const bool bNew ) { bEmpty = bNew; }
     134           0 :     inline void SetFieldFollow( const bool bNew ) { bFieldFollow = bNew; }
     135             : 
     136             :     bool IsIdxInside( const sal_Int32 nPos, const sal_Int32 nLen ) const;
     137             : 
     138             :     // Wechselt den Frame oder auch nicht (vgl. FlyCnt)
     139             :     bool _GetCrsrOfst(SwPosition *pPos, const Point &rPoint,
     140             :                       const bool bChgFrm, SwCrsrMoveState* = 0 ) const;
     141             :     void FillCrsrPos( SwFillData &rFill ) const;
     142             : 
     143             :     // formatiert genau eine Zeile ...
     144             :     bool FormatLine( SwTxtFormatter &rLine, const bool bPrev );
     145             : 
     146             :     // Um Stack einzusparen aufgeteilt ...
     147             :     // _Format ruft _Format mit Parametern
     148             :     void _Format( SwParaPortion *pPara );
     149             :     void _Format( SwTxtFormatter &rLine, SwTxtFormatInfo &rInf,
     150             :                   const bool bAdjust = false );
     151             :     void FormatOnceMore( SwTxtFormatter &rLine, SwTxtFormatInfo &rInf );
     152             : 
     153             :     // formatiert den Follow und sorgt fuer die Entsorgung bei Orphans
     154             :     bool CalcFollow(  const sal_Int32 nTxtOfst );
     155             : 
     156             :     // korrigiert die Stelle ab der formatiert werden muss.
     157             :     sal_Int32 FindBrk(const OUString &rTxt, const sal_Int32 nStart,
     158             :                                        const sal_Int32 nEnd) const;
     159             : 
     160             :     // inline-Weiche
     161             :     SwTwips _GetFtnFrmHeight() const;
     162             : 
     163             :     // Aus CalcPreps ausgelagert.
     164             :     bool CalcPrepFtnAdjust();
     165             : 
     166             :     // Fuer Ftn und WidOrp: Zwangsvalidierung
     167             :     void ValidateFrm();
     168             :     void ValidateBodyFrm();
     169             : 
     170             :     bool _GetDropRect( SwRect &rRect ) const;
     171             : 
     172             :     void SetPara( SwParaPortion *pNew, bool bDelete = true );
     173             : 
     174             :     bool _IsFtnNumFrm() const;
     175             : 
     176             :     // 6995: Formatinformationen auffrischen
     177             :     bool FormatQuick( bool bForceQuickFormat );
     178             : 
     179             :     // Opt: Leere Absaetze formatieren
     180             :     bool FormatEmpty();
     181             :     SwTwips EmptyHeight() const;
     182             :     // Opt: Leere Absaetze painten
     183             :     bool PaintEmpty( const SwRect &, bool bCheck ) const;
     184             : 
     185             :     void ChgThisLines();//Muss immer gerufen werden, wenn sich die Zeilenazahl
     186             :                         //veraendert haben kann.
     187             : 
     188             :     // required for 'new' relative anchor position
     189             :     void CalcBaseOfstForFly();
     190             : 
     191             :     /** method to determine height of last line, needed for proportional line spacing
     192             : 
     193             :         OD 2004-03-17 #i11860#
     194             :         OD 2005-05-20 #i47162# - introduce new optional parameter <_bUseFont>
     195             :         in order to force the usage of the former algorithm to determine the
     196             :         height of the last line, which uses the font.
     197             : 
     198             :         @param _bUseFont
     199             :         optional input parameter - boolean indicating, if the font has to be
     200             :         used to determine the height of the last line. default value: false
     201             :     */
     202             :     void _CalcHeightOfLastLine( const bool _bUseFont = false );
     203             : 
     204             :     // ST2
     205             :     SwWrongList* _SmartTagScan ( const OUString& aTxtToScan, SwWrongList *pSmartTagList,
     206             :                                  sal_Int32 nBegin,sal_Int32 nEnd,
     207             :                                  sal_Int32 nInsertPos, sal_Int32 nActPos,
     208             :                                  sal_Int32 &nChgStart, sal_Int32 &nChgEnd,
     209             :                                  sal_Int32 &nInvStart, sal_Int32 &nInvEnd);
     210             : protected:
     211             :     virtual void Modify( const SfxPoolItem*, const SfxPoolItem* ) SAL_OVERRIDE;
     212             : 
     213             : public:
     214             : 
     215             :     com::sun::star::uno::Sequence< ::com::sun::star::style::TabStop >  GetTabStopInfo( SwTwips CurrentPos ) SAL_OVERRIDE;
     216             :     //public, weil der eine oder andere die Methode rufen darf um das
     217             :     //Prepare zu sparen - mit Vorsicht zu geniessen!
     218             :     void Init();
     219             : 
     220             :     // Wird von FormatSpelling( ) gerufen
     221             :     SwRect _AutoSpell( const SwCntntNode*, const SwViewOption&, sal_Int32 );
     222             :     // is called from the FormatSpelling( ) method
     223             :     SwRect SmartTagScan( SwCntntNode* , sal_Int32 );
     224             :     // Wird vom CollectAutoCmplWords gerufen
     225             :     void CollectAutoCmplWrds( SwCntntNode* , sal_Int32 );
     226             : 
     227             :     // Returns the screen position of rPos. The values are relative to the upper
     228             :     // left position of the page frame.
     229             :     // Additional information can be obtained by passing an SwCrsrMoveState object.
     230             :     // Returns false if rPos > number of character is string
     231             :     virtual bool GetCharRect( SwRect& rRect, const SwPosition& rPos,
     232             :                                 SwCrsrMoveState* pCMS = 0 ) const SAL_OVERRIDE;
     233             :     // Eine etwas abgespeckte GetCharRect-Version fuer autopositionierte Rahmen
     234             :     bool GetAutoPos( SwRect &, const SwPosition& ) const;
     235             : 
     236             :     /** determine top of line for given position in the text frame
     237             : 
     238             :         OD 11.11.2003 #i22341#
     239             :         Assumption: given position exists in the text frame or in a follow of it
     240             :         OD 2004-02-02 - adjustment
     241             :         Top of first paragraph line is the top of the paragraph.
     242             :         OD 2004-03-18 #i11860# - Consider upper space amount considered for
     243             :         previous frame and the page grid.
     244             : 
     245             :         @param _onTopOfLine
     246             :         output parameter - top of line, if the given position is found in the
     247             :         text frame.
     248             : 
     249             :         @param _rPos
     250             :         input parameter - reference to the position in the text frame
     251             : 
     252             :         @return boolean indicating, if the top of line for the given position
     253             :         has been determined or not.
     254             :     */
     255             :     bool GetTopOfLine( SwTwips& _onTopOfLine,
     256             :                        const SwPosition& _rPos ) const;
     257             : 
     258             :     virtual bool FillSelection( SwSelectionList& rList, const SwRect& rRect ) const SAL_OVERRIDE;
     259             : 
     260             :     //Liefert in nOffset den Offset des Characters innerhalb des
     261             :     //gesetzten Textbuffers zurueck, welcher der durch aPoint
     262             :     //gegebenen Position innerhalb der SSize des Layout am
     263             :     //naechsten ist. Wenn der SPoint ausserhalb der SSize liegt,
     264             :     //liefert die Funktion false, true sonst.
     265             :     virtual bool GetCrsrOfst( SwPosition *, Point&,
     266             :                                   SwCrsrMoveState* = 0, bool bTestBackground = false ) const SAL_OVERRIDE;
     267             : 
     268             :     // GetKeyCrsrOfst sorgt dafuer, dass der Frame nicht gewechselt wird
     269             :     // (z.B. Wechsel in den zeichengebundenen Frame).
     270           0 :     inline bool GetKeyCrsrOfst(SwPosition *pPos, const Point &rPoint ) const
     271           0 :             { return _GetCrsrOfst( pPos, rPoint, false ); }
     272             : 
     273             :     void   PaintExtraData( const SwRect & rRect ) const; //Seitennummer usw.
     274             :     SwRect Paint();
     275             :     virtual void Paint( SwRect const&,
     276             :                         SwPrintData const*const pPrintData = NULL ) const SAL_OVERRIDE;
     277             :     virtual bool GetInfo( SfxPoolItem & ) const SAL_OVERRIDE;
     278             : 
     279             :     //Layoutorientiertes Cursortravelling: Linker, rechter Rand,
     280             :     //vorhergehende/naechste Zeile, gleiche horizontale Position.
     281             :     virtual bool LeftMargin(SwPaM *) const SAL_OVERRIDE;
     282             :     virtual bool RightMargin(SwPaM *, bool bAPI = false) const SAL_OVERRIDE;
     283             : 
     284             :     virtual bool UnitUp(SwPaM *, const SwTwips nOffset = 0,
     285             :                             bool bSetInReadOnly = false ) const SAL_OVERRIDE;
     286             :     virtual bool UnitDown(SwPaM *, const SwTwips nOffset = 0,
     287             :                             bool bSetInReadOnly = false ) const SAL_OVERRIDE;
     288             :     bool _UnitUp(SwPaM *, const SwTwips nOffset = 0,
     289             :                             bool bSetInReadOnly = false ) const;
     290             :     bool _UnitDown(SwPaM *, const SwTwips nOffset = 0,
     291             :                             bool bSetInReadOnly = false ) const;
     292             : 
     293             :     // Prepares the cursor position for a visual cursor move (BiDi).
     294             :     // The behaviour is different for insert and overwrite cursors
     295             :     void PrepareVisualMove( sal_Int32& nPos, sal_uInt8& nCrsrLevel,
     296             :                             bool& bRight, bool bInsertCrsr );
     297             : 
     298             :     // Methoden zur Verwaltung von FolgeFrames
     299             :            SwCntntFrm *SplitFrm( const sal_Int32 nTxtPos );
     300             :            SwCntntFrm *JoinFrm();
     301           0 :     inline sal_Int32  GetOfst() const { return nOfst; }
     302             :            void        _SetOfst( const sal_Int32 nNewOfst );
     303             :     inline void        SetOfst ( const sal_Int32 nNewOfst );
     304           0 :     inline void        ManipOfst ( const sal_Int32 nNewOfst ){ nOfst = nNewOfst; }
     305             :            SwTxtFrm   *GetFrmAtPos ( const SwPosition &rPos);
     306             :     inline const SwTxtFrm *GetFrmAtPos ( const SwPosition &rPos) const;
     307             :            // OD 07.10.2003 #110978# - return <reference> instead of <pointer>
     308             :     SwTxtFrm&   GetFrmAtOfst( const sal_Int32 nOfst );
     309             :     // Wenn es einen Follow gibt und wir selbst keinen Text enthalten:
     310           0 :     inline bool IsEmptyMaster() const
     311           0 :         { return GetFollow() && !GetFollow()->GetOfst(); }
     312             : 
     313             :     // Liefert den zu bearbeitenden Textausschnitt zurueck (inline, s.u.)
     314             :     const OUString& GetTxt() const;
     315           0 :     inline SwTxtNode *GetTxtNode()
     316           0 :         { return static_cast< SwTxtNode* >( SwCntntFrm::GetNode()); }
     317           0 :     inline const SwTxtNode *GetTxtNode() const
     318           0 :         { return static_cast< const SwTxtNode* >( SwCntntFrm::GetNode()); }
     319             : 
     320             :     SwTxtFrm(SwTxtNode * const, SwFrm* );
     321             :     virtual ~SwTxtFrm();
     322             : 
     323             :     // SwCntntFrm: der "kurze Dienstweg" fuer die Frames.
     324             :     // Wer den void* falsch casted ist selbst Schuld!
     325             :     // Auf jedenfall muss der void* auf 0 geprueft werden.
     326             :     virtual void Prepare( const PrepareHint ePrep = PREP_CLEAR,
     327             :                           const void *pVoid = 0, bool bNotify = true ) SAL_OVERRIDE;
     328             : 
     329             :     // nMaxHeight is the required height
     330             :     // bSplit indicates, that the paragraph has to be split
     331             :     // bTst indicates, that we are currently doing a test formatting
     332             :     virtual bool WouldFit( SwTwips &nMaxHeight, bool &bSplit, bool bTst ) SAL_OVERRIDE;
     333             : 
     334             :     // Hier das WouldFit-Aequivalent fuer mal kurz probeweise
     335             :     // umgehaengte TextFrames, auch hier liefert
     336             :     // nMaxHeight die benoetigte Hoehe,
     337             :     // und bSplit sagt, obj der Absatz gesplittet werden muss.
     338             :     // Uebergeben wird der potentielle Vorgaenger fuer die Abstandsberechnung
     339             :     bool TestFormat( const SwFrm* pPrv, SwTwips &nMaxHeight, bool &bSplit );
     340             : 
     341             :     // Wir formatieren eine Zeile fuer die interaktive Trennung
     342             :     // Return: found
     343             :     bool Hyphenate( SwInterHyphInfo &rInf );
     344             : 
     345             :     // Probegrow
     346             :     inline SwTwips GrowTst( const SwTwips nGrow );
     347             : 
     348             :     SwParaPortion *GetPara();
     349             :     inline const SwParaPortion *GetPara() const;
     350             :     inline bool HasPara() const;
     351             :     bool _HasPara() const;
     352             :     // If there are any hanging punctuation portions in the margin
     353             :     // the offset will be returned.
     354             :     SwTwips HangingMargin() const;
     355             : 
     356             :     // RTTI
     357             :     TYPEINFO_OVERRIDE();
     358           0 :     DECL_FIXEDMEMPOOL_NEWDEL(SwTxtFrm)
     359             : 
     360             :     // Locking
     361           0 :     inline bool IsLocked()      const { return bLocked;     }
     362             : 
     363           0 :     inline bool IsWidow()       const { return bWidow;      }
     364           0 :     inline bool IsJustWidow()   const { return bJustWidow;  }
     365           0 :     inline bool IsEmpty()       const { return bEmpty;      }
     366           0 :     inline bool HasFtn()        const { return bFtn;        }
     367           0 :     inline bool IsInFtnConnect()const { return bInFtnConnect;}
     368           0 :     inline bool IsFieldFollow() const { return bFieldFollow;}
     369             : 
     370             :     inline void SetRepaint() const;
     371             :     inline void ResetRepaint() const;
     372           0 :     inline bool HasRepaint() const { return bRepaint; }
     373             :     inline void SetBlinkPor() const;
     374             :     inline void ResetBlinkPor() const;
     375           0 :     inline bool HasBlinkPor() const { return bBlinkPor; }
     376           0 :     inline void SetAnimation() const
     377           0 :         { ( (SwTxtFrm*)this )->bHasAnimation = true; }
     378           0 :     inline bool HasAnimation() const { return bHasAnimation; }
     379             : 
     380           0 :     inline bool IsSwapped() const { return bIsSwapped; }
     381             : 
     382             :     // Hat der Frm eine lokale Fussnote (in diesem Frm bzw. Follow)?
     383             : #ifdef DBG_UTIL
     384             :     void CalcFtnFlag( sal_Int32 nStop = COMPLETE_STRING );//For testing SplitFrm
     385             : #else
     386             :     void CalcFtnFlag();
     387             : #endif
     388             : 
     389             :     // Hidden
     390             :     bool IsHiddenNow() const;       // bHidden && pOut == pPrt
     391             :     void HideHidden();              // Anhaengsel entfernen wenn Hidden
     392             :     void HideFootnotes( sal_Int32 nStart, sal_Int32 nEnd );
     393             : 
     394             :     /** method to hide/show objects
     395             : 
     396             :         OD 2004-01-15 #110582#
     397             :         method hides respectively shows objects, which are anchored at paragraph,
     398             :         at/as a character of the paragraph, corresponding to the paragraph and
     399             :         paragraph portion visibility.
     400             :     */
     401             :     void HideAndShowObjects();
     402             : 
     403             :     // Ftn
     404             :     void RemoveFtn( const sal_Int32 nStart = 0,
     405             :                     const sal_Int32 nLen = COMPLETE_STRING );
     406             :     inline SwTwips GetFtnFrmHeight() const;
     407             :     SwTxtFrm *FindFtnRef( const SwTxtFtn *pFtn );
     408             :     inline const SwTxtFrm *FindFtnRef( const SwTxtFtn *pFtn ) const
     409             :     { return FindFtnRef( pFtn ); }
     410             :     void ConnectFtn( SwTxtFtn *pFtn, const SwTwips nDeadLine );
     411             : 
     412             :     // Wenn wir eine Ftn sind, die auf ihre Referenz zu waechst...
     413             :     // public weil von SwCntntFrm::MakeAll benoetigt.
     414             :     SwTwips GetFtnLine( const SwTxtFtn *pFtn ) const;
     415             : 
     416             :     // Liefern den linken und den rechten Rand in
     417             :     // Dokumentkoordinaten (unter Beachtung der Absatzattribute).
     418             :     inline SwTwips GetLeftMargin() const;
     419             :     inline SwTwips GetRightMargin() const;
     420             : 
     421             :     virtual void Format( const SwBorderAttrs *pAttrs = 0 ) SAL_OVERRIDE;
     422             :     virtual void CheckDirection( bool bVert ) SAL_OVERRIDE;
     423             : 
     424             :     // Liefert die Summe der Zeilenhoehen in pLine zurueck.
     425             :     sal_uInt16 GetParHeight() const;
     426             : 
     427             :     // Liefert die Resthoehe zurueck
     428             :     inline SwTwips GetRstHeight() const;
     429             : 
     430             :     inline       SwTxtFrm *GetFollow();
     431             :     inline const SwTxtFrm *GetFollow() const;
     432             : 
     433             :     // Suche die Seitennummer von ErgoSum und QuoVadis
     434             :     SwTxtFrm *FindQuoVadisFrm();
     435             : 
     436             :     // holt die Formatierug nach, wenn der Idle-Handler zugeschlagen hat.
     437             :     // #i29062# GetFormatted() can trigger a full formatting
     438             :     // of the paragraph, causing other layout frames to become invalid. This
     439             :     // has to be avoided during painting. Therefore we need to pass the
     440             :     // information that we are currently in the paint process.
     441             :     SwTxtFrm* GetFormatted( bool bForceQuickFormat = false );
     442             : 
     443             :     // wird demnaechst uebertragen
     444           0 :     inline void SetFtn( const bool bNew ) { bFtn = bNew; }
     445             : 
     446             :     // Beruecksichtigung der Follows
     447             :     inline bool IsInside( const sal_Int32 nPos ) const;
     448             : 
     449             :     const SwBodyFrm   *FindBodyFrm()   const;
     450             : 
     451             :     // DropCaps und Selektionen
     452           0 :     inline bool GetDropRect( SwRect &rRect ) const
     453           0 :     { return HasPara() && _GetDropRect( rRect ); }
     454             : 
     455           0 :     static SwCache *GetTxtCache() { return pTxtCache; }
     456           0 :     static void     SetTxtCache( SwCache *pNew ) { pTxtCache = pNew; }
     457             : 
     458           0 :     static long GetMinPrtLine() { return nMinPrtLine; }
     459             :     static void SetMinPrtLine( long nNew ) { nMinPrtLine = nNew; }
     460             : 
     461           0 :     inline sal_uInt16 GetCacheIdx() const { return nCacheIdx; }
     462           0 :     inline void   SetCacheIdx( const sal_uInt16 nNew ) { nCacheIdx = nNew; }
     463             : 
     464             :     //Entfert die Line-Informationen aus dem Cache.
     465             :     void ClearPara();
     466             : 
     467             :     // Bin ich ein FtnFrm, der eine Nummer am Absatzanfang hat?
     468           0 :     inline bool IsFtnNumFrm() const
     469           0 :     { return IsInFtn() && !GetIndPrev() && _IsFtnNumFrm(); }
     470             : 
     471             :     // simuliert eine Formatierung, als wenn es keinen rechten Rand und
     472             :     // keine Flys oder andere Hindernisse gaebe und liefert die Breite.
     473             :     SwTwips CalcFitToContent();
     474             : 
     475             :     /** simulate format for a list item paragraph, whose list level attributes
     476             :         are in LABEL_ALIGNMENT mode, in order to determine additional first
     477             :         line offset for the real text formatting due to the value of label
     478             :         adjustment attribute of the list level.
     479             :     */
     480             :     void CalcAdditionalFirstLineOffset();
     481             : 
     482           0 :     inline SwTwips GetAdditionalFirstLineOffset() const
     483             :     {
     484           0 :         return mnAdditionalFirstLineOffset;
     485             :     }
     486             : 
     487             :     // liefert den zusaetzlichen Zeilenabstand fuer den naechsten Absatz
     488             :     // OD 07.01.2004 #i11859# - change return data type;
     489             :     //      add default parameter <_bNoPropLineSpacing> to control, if the
     490             :     //      value of a proportional line spacing is returned or not
     491             :     long GetLineSpace( const bool _bNoPropLineSpacing = false ) const;
     492             : 
     493             :     // liefert die erste Zeilenhoehe zurueck
     494             :     sal_uInt16 FirstLineHeight() const;
     495             : 
     496             :     // Haengt FlyInCntFrm um, wenn nEnd > Index >= nStart ist.
     497             :     void MoveFlyInCnt( SwTxtFrm *pNew, sal_Int32 nStart, sal_Int32 nEnd );
     498             : 
     499             :     // Berechnet die Position von FlyInCntFrms
     500             :     sal_Int32 CalcFlyPos( SwFrmFmt* pSearch );
     501             : 
     502             :     // Ermittelt die Startposition und Schrittweite des Registers
     503             :     bool FillRegister( SwTwips& rRegStart, sal_uInt16& rRegDiff );
     504             : 
     505             :     sal_uInt16 GetLineCount( sal_Int32 nPos );     //Ermittelt die Zeilenanzahl
     506             : 
     507             :     //Fuer die Anzeige der Zeilennummern.
     508           0 :     sal_uLong GetAllLines()  const { return nAllLines; }
     509           0 :     sal_uLong GetThisLines() const { return nThisLines;}
     510             :     void RecalcAllLines();
     511             : 
     512             :     // Stoppt Animationen innerhalb von Numerierungen
     513             :     void StopAnimation( OutputDevice *pOut );
     514             : 
     515             :     // visit all portions for Accessibility
     516             :     void VisitPortions( SwPortionHandler& rPH ) const;
     517             : 
     518             :     // returns the script info stored at the paraportion
     519             :     const SwScriptInfo* GetScriptInfo() const;
     520             : 
     521             :     // Swaps width and height of the text frame
     522             :     void SwapWidthAndHeight();
     523             :     // Calculates the coordinates of a rectangle when switching from
     524             :     // horizontal to vertical layout.
     525             :     void SwitchHorizontalToVertical( SwRect& rRect ) const;
     526             :     // Calculates the coordinates of a point when switching from
     527             :     // horizontal to vertical layout.
     528             :     void SwitchHorizontalToVertical( Point& rPoint ) const;
     529             :     // Calculates the a limit value when switching from
     530             :     // horizontal to vertical layout.
     531             :     long SwitchHorizontalToVertical( long nLimit ) const;
     532             :     // Calculates the coordinates of a rectangle when switching from
     533             :     // vertical to horizontal layout.
     534             :     void SwitchVerticalToHorizontal( SwRect& rRect ) const;
     535             :     // Calculates the coordinates of a point when switching from
     536             :     // vertical to horizontal layout.
     537             :     void SwitchVerticalToHorizontal( Point& rPoint ) const;
     538             :     // Calculates the a limit value when switching from
     539             :     // vertical to horizontal layout.
     540             :     long SwitchVerticalToHorizontal( long nLimit ) const;
     541             : 
     542             :     // Calculates the coordinates of a rectangle when switching from
     543             :     // LTR to RTL layout
     544             :     void SwitchLTRtoRTL( SwRect& rRect ) const;
     545             :     // Calculates the coordinates of a point when switching from
     546             :     // LTR to RTL layout.
     547             :     void SwitchLTRtoRTL( Point& rPoint ) const;
     548             :     // Calculates the coordinates of a rectangle when switching from
     549             :     // RTL to LTR layout
     550           0 :     inline void SwitchRTLtoLTR( SwRect& rRect ) const { SwitchLTRtoRTL( rRect ); }
     551             :     // Calculates the coordinates of a point when switching from
     552             :     // RTL to LTR layout.
     553           0 :     inline void SwitchRTLtoLTR( Point& rPoint ) const { SwitchLTRtoRTL( rPoint ); };
     554             : 
     555             :     // OD 14.03.2003 #i11760# - access to new member <mbNoFollowFormat>
     556           0 :     inline bool FollowFormatAllowed() const
     557             :     {
     558           0 :         return mbFollowFormatAllowed;
     559             :     }
     560           0 :     inline void AllowFollowFormat()
     561             :     {
     562           0 :         mbFollowFormatAllowed = true;
     563           0 :     }
     564           0 :     inline void ForbidFollowFormat()
     565             :     {
     566           0 :         mbFollowFormatAllowed = false;
     567           0 :     }
     568             : 
     569           0 :     SwTwips GetBaseOfstForFly( bool bIgnoreFlysAnchoredAtThisFrame ) const
     570             :     {
     571             :         return ( bIgnoreFlysAnchoredAtThisFrame ?
     572             :                  mnFlyAnchorOfst :
     573           0 :                  mnFlyAnchorOfstNoWrap );
     574             :     }
     575             : 
     576             :     // OD 2004-03-17 #i11860#
     577           0 :     inline SwTwips GetHeightOfLastLine() const
     578             :     {
     579           0 :         return mnHeightOfLastLine;
     580             :     }
     581             : 
     582             :     static void repaintTextFrames( const SwTxtNode& rNode );
     583             : 
     584             :     virtual void dumpAsXmlAttributes(xmlTextWriterPtr writer) SAL_OVERRIDE;
     585             : };
     586             : 
     587             : /*************************************************************************
     588             :  *                          class SwTxtFrmLocker
     589             :  *************************************************************************/
     590             : 
     591             : class SwTxtFrmLocker
     592             : {
     593             : private:
     594             :     SwTxtFrm * const pFrm;
     595             : public:
     596           0 :     inline SwTxtFrmLocker( SwTxtFrm *pTxtFrm )
     597           0 :         : pFrm( pTxtFrm->IsLocked() ? 0 : pTxtFrm )
     598           0 :     { if( pFrm ) pFrm->Lock(); }
     599           0 :     inline ~SwTxtFrmLocker() { if( pFrm ) pFrm->Unlock(); }
     600             : };
     601             : 
     602             : /*************************************************************************
     603             :  *                      Inline-Implementierung
     604             :  *************************************************************************/
     605             : 
     606           0 : inline const SwParaPortion *SwTxtFrm::GetPara() const
     607             : {
     608           0 :     return ((SwTxtFrm*)this)->GetPara();
     609             : }
     610             : 
     611           0 : inline bool SwTxtFrm::HasPara() const
     612             : {
     613           0 :     return nCacheIdx!=USHRT_MAX && _HasPara();
     614             : }
     615             : 
     616             : // 9104: Frm().Height() - Prt().Height(), siehe widorp.cxx und 7455, 6114, 7908
     617             : inline SwTwips SwTxtFrm::GetRstHeight() const
     618             : {
     619             :     return !GetUpper() ? 0 : ((const SwFrm*)GetUpper())->Frm().Top()
     620             :                            + ((const SwFrm*)GetUpper())->Prt().Top()
     621             :                            + ((const SwFrm*)GetUpper())->Prt().Height()
     622             :                            - Frm().Top() - (Frm().Height() - Prt().Height());
     623             : }
     624             : 
     625             : inline SwTwips SwTxtFrm::GetLeftMargin() const
     626             : {
     627             :     return Frm().Left() + Prt().Left();
     628             : }
     629             : inline SwTwips SwTxtFrm::GetRightMargin() const
     630             : {
     631             :     return Frm().Left() + Prt().Left() + Prt().Width();
     632             : }
     633           0 : inline SwTwips SwTxtFrm::GrowTst( const SwTwips nGrow )
     634             : {
     635           0 :     return Grow( nGrow, true );
     636             : }
     637             : 
     638           0 : inline bool SwTxtFrm::IsInside( const sal_Int32 nPos ) const
     639             : {
     640           0 :     bool bRet = true;
     641           0 :     if( nPos < GetOfst() )
     642           0 :         bRet = false;
     643             :     else
     644             :     {
     645           0 :         const SwTxtFrm *pFoll = GetFollow();
     646           0 :         if( pFoll && nPos >= pFoll->GetOfst() )
     647           0 :             bRet = false;
     648             :     }
     649           0 :     return bRet;
     650             : }
     651             : 
     652           0 : inline SwTwips SwTxtFrm::GetFtnFrmHeight() const
     653             : {
     654           0 :     if(  !IsFollow() && IsInFtn() && HasPara() )
     655           0 :         return _GetFtnFrmHeight();
     656             :     else
     657           0 :         return 0;
     658             : }
     659             : 
     660           0 : inline const SwTxtFrm *SwTxtFrm::GetFollow() const
     661             : {
     662           0 :     return (const SwTxtFrm*)SwCntntFrm::GetFollow();
     663             : }
     664           0 : inline SwTxtFrm *SwTxtFrm::GetFollow()
     665             : {
     666           0 :     return (SwTxtFrm*)SwCntntFrm::GetFollow();
     667             : }
     668             : 
     669             : inline const SwTxtFrm *SwTxtFrm::GetFrmAtPos( const SwPosition &rPos) const
     670             : {
     671             :     return ((SwTxtFrm*)this)->GetFrmAtPos( rPos );
     672             : }
     673             : 
     674             : inline void SwTxtFrm::AdjustFollow( SwTxtFormatter &rLine,
     675             :     const sal_Int32 nOffset, const sal_Int32 nStrEnd, const sal_uInt8 nMode )
     676             : {
     677             :     if ( HasFollow() )
     678             :         _AdjustFollow( rLine, nOffset, nStrEnd, nMode );
     679             : }
     680             : 
     681           0 : inline void SwTxtFrm::SetOfst( const sal_Int32 nNewOfst )
     682             : {
     683           0 :     if ( nOfst != nNewOfst )
     684           0 :         _SetOfst( nNewOfst );
     685           0 : }
     686             : 
     687           0 : inline void SwTxtFrm::SetRepaint() const
     688             : {
     689           0 :     ((SwTxtFrm*)this)->bRepaint = true;
     690           0 : }
     691           0 : inline void SwTxtFrm::ResetRepaint() const
     692             : {
     693           0 :     ((SwTxtFrm*)this)->bRepaint = false;
     694           0 : }
     695             : 
     696           0 : inline void SwTxtFrm::SetBlinkPor() const
     697             : {
     698           0 :     ((SwTxtFrm*)this)->bBlinkPor = true;
     699           0 : }
     700           0 : inline void SwTxtFrm::ResetBlinkPor() const
     701             : {
     702           0 :     ((SwTxtFrm*)this)->bBlinkPor = false;
     703           0 : }
     704             : 
     705             : #define SWAP_IF_SWAPPED( pFrm )\
     706             :     bool bUndoSwap = false;   \
     707             :     if ( pFrm->IsVertical() && pFrm->IsSwapped() )\
     708             :     {                                 \
     709             :         bUndoSwap = true;         \
     710             :         ((SwTxtFrm*)pFrm)->SwapWidthAndHeight();         \
     711             :     }
     712             : 
     713             : #define SWAP_IF_NOT_SWAPPED( pFrm )\
     714             :     bool bUndoSwap = false;     \
     715             :     if ( pFrm->IsVertical() && ! pFrm->IsSwapped() )\
     716             :     {                                   \
     717             :         bUndoSwap = true;           \
     718             :         ((SwTxtFrm*)pFrm)->SwapWidthAndHeight();         \
     719             :     }
     720             : 
     721             : #define UNDO_SWAP( pFrm )\
     722             :     if ( bUndoSwap )\
     723             :         ((SwTxtFrm*)pFrm)->SwapWidthAndHeight();
     724             : 
     725             : // Helper class which can be used instead of the macros if a function
     726             : // has too many returns
     727             : class SwFrmSwapper
     728             : {
     729             :     const SwTxtFrm* pFrm;
     730             :     bool bUndo;
     731             : public:
     732             :     SwFrmSwapper( const SwTxtFrm* pFrm, bool bSwapIfNotSwapped );
     733             :     ~SwFrmSwapper();
     734             : };
     735             : 
     736             : class SwLayoutModeModifier
     737             : {
     738             :     const OutputDevice& rOut;
     739             :     long nOldLayoutMode;
     740             : public:
     741             :     SwLayoutModeModifier( const OutputDevice& rOutp );
     742             :     ~SwLayoutModeModifier();
     743             :     void Modify( bool bChgToRTL );
     744             :     void SetAuto();
     745             : };
     746             : 
     747             : class SwDigitModeModifier
     748             : {
     749             :     const OutputDevice& rOut;
     750             :     LanguageType nOldLanguageType;
     751             : public:
     752             :     SwDigitModeModifier( const OutputDevice& rOutp, LanguageType eCurLang );
     753             :     ~SwDigitModeModifier();
     754             : };
     755             : 
     756             : #endif
     757             : 
     758             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10