LCOV - code coverage report
Current view: top level - sw/source/core/inc - frmtool.hxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 78 0.0 %
Date: 2014-04-14 Functions: 0 36 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             : #ifndef INCLUDED_SW_SOURCE_CORE_INC_FRMTOOL_HXX
      21             : #define INCLUDED_SW_SOURCE_CORE_INC_FRMTOOL_HXX
      22             : 
      23             : #include "swtypes.hxx"
      24             : #include "layfrm.hxx"
      25             : #include "frmatr.hxx"
      26             : #include "swcache.hxx"
      27             : // #i96772#
      28             : #include <editeng/lrspitem.hxx>
      29             : #include <swfont.hxx>
      30             : 
      31             : class SwPageFrm;
      32             : class SwFlyFrm;
      33             : class SwCntntFrm;
      34             : class SwRootFrm;
      35             : class SwDoc;
      36             : class SwAttrSet;
      37             : class SdrObject;
      38             : class SvxBrushItem;
      39             : class XFillStyleItem;
      40             : class XFillGradientItem;
      41             : class SdrMarkList;
      42             : class SwNodeIndex;
      43             : class OutputDevice;
      44             : class Graphic;
      45             : class GraphicAttr;
      46             : class SwPageDesc;
      47             : 
      48             : #define FAR_AWAY LONG_MAX - 20000  // initial position of a Fly
      49             : #define BROWSE_HEIGHT 56700L * 10L // 10 Meters
      50             : #define GRFNUM_NO 0
      51             : #define GRFNUM_YES 1
      52             : #define GRFNUM_REPLACE 2
      53             : 
      54             : // draw background with brush or graphics
      55             : // The 6th parameter indicates that the method should consider background
      56             : // transparency, saved in the color of the brush item.
      57             : void DrawGraphic(
      58             :     const SvxBrushItem *,
      59             :     OutputDevice *,
      60             :     const SwRect &rOrg,
      61             :     const SwRect &rOut,
      62             :     const sal_uInt8 nGrfNum = GRFNUM_NO,
      63             :     const sal_Bool bConsiderBackgroundTransparency = sal_False );
      64             : bool DrawFillAttributes(
      65             :     const boost::shared_ptr< FillAttributes >& rFillAttributes,
      66             :     const SwRect& rOriginalLayoutRect,
      67             :     const SwRect& rPaintRect,
      68             :     OutputDevice& rOut);
      69             : 
      70             : void paintGraphicUsingPrimitivesHelper(
      71             :         OutputDevice & rOutputDevice,
      72             :         Graphic const& rGraphic, GraphicAttr const& rGraphicAttr,
      73             :         SwRect const& rAlignedGrfArea);
      74             : 
      75             : // method to align rectangle.
      76             : // Created declaration here to avoid <extern> declarations
      77             : void SwAlignRect( SwRect &rRect, const SwViewShell *pSh );
      78             : 
      79             : // method to align graphic rectangle
      80             : // Created declaration here to avoid <extern> declarations
      81             : void SwAlignGrfRect( SwRect *pGrfRect, const OutputDevice &rOut );
      82             : 
      83             : /**
      84             :  * Paint border around a run of characters using frame painting code.
      85             :  *
      86             :  * @param[in]   rFont            font object of actual text, which specify the border
      87             :  * @param[in]   rPaintArea       rectangle area in which line portion takes place
      88             :  * @param[in]   bVerticalLayout  corresponding text frame verticality
      89             :  * @param[in]   bJoinWithPrev    leave border with which actual border joins to the previous portion
      90             :  * @param[in]   bJoinWithNext    leave border with which actual border joins to the next portion
      91             : **/
      92             : void PaintCharacterBorder(
      93             :     const SwFont& rFont, const SwRect& rPaintArea, const bool bVerticalLayout,
      94             :     const bool bJoinWithPrev, const bool bJoinWithNext );
      95             : 
      96             : // get Fly, if no List is given use the current shell
      97             : // Implementation in feshview.cxx
      98             : SwFlyFrm *GetFlyFromMarked( const SdrMarkList *pLst, SwViewShell *pSh );
      99             : 
     100             : SwFrm *SaveCntnt( SwLayoutFrm *pLay, SwFrm *pStart = NULL );
     101             : void RestoreCntnt( SwFrm *pSav, SwLayoutFrm *pParent, SwFrm *pSibling, bool bGrow );
     102             : 
     103             : // Get CntntNodes, create CntntFrms, and add them to LayFrm.
     104             : void _InsertCnt( SwLayoutFrm *pLay, SwDoc *pDoc, sal_uLong nIndex,
     105             :                  sal_Bool bPages = sal_False, sal_uLong nEndIndex = 0,
     106             :                  SwFrm *pPrv = 0 );
     107             : 
     108             : // Creation of frames for a specific section (uses _InsertCnt)
     109             : void MakeFrms( SwDoc *pDoc, const SwNodeIndex &rSttIdx,
     110             :                             const SwNodeIndex &rEndIdx );
     111             : 
     112             : // prevent creation of Flys in _InsertCnt, e.g. for table headlines
     113             : extern bool bDontCreateObjects;
     114             : 
     115             : // for FlyCnts, see SwFlyAtCntFrm::MakeAll()
     116             : extern bool bSetCompletePaintOnInvalidate;
     117             : 
     118             : // for table settings via keyboard
     119             : long CalcRowRstHeight( SwLayoutFrm *pRow );
     120             : long CalcHeightWidthFlys( const SwFrm *pFrm );
     121             : 
     122             : SwPageFrm *InsertNewPage( SwPageDesc &rDesc, SwFrm *pUpper,
     123             :                           bool bOdd, bool bFirst, bool bInsertEmpty, sal_Bool bFtn,
     124             :                           SwFrm *pSibling );
     125             : 
     126             : // connect Flys with page
     127             : void RegistFlys( SwPageFrm*, const SwLayoutFrm* );
     128             : 
     129             : // notification of Fly's background if needed
     130             : void Notify( SwFlyFrm *pFly, SwPageFrm *pOld, const SwRect &rOld,
     131             :              const SwRect* pOldRect = 0 );
     132             : 
     133             : void Notify_Background( const SdrObject* pObj,
     134             :                         SwPageFrm* pPage,
     135             :                         const SwRect& rRect,
     136             :                         const PrepareHint eHint,
     137             :                         const sal_Bool bInva );
     138             : 
     139             : const SwFrm* GetVirtualUpper( const SwFrm* pFrm, const Point& rPos );
     140             : 
     141             : bool Is_Lower_Of( const SwFrm *pCurrFrm, const SdrObject* pObj );
     142             : 
     143             : // FIXME: EasyHack (refactoring): rename method and parameter name in all files
     144             : const SwFrm *FindKontext( const SwFrm *pFrm, sal_uInt16 nAdditionalKontextTyp );
     145             : 
     146             : bool IsFrmInSameKontext( const SwFrm *pInnerFrm, const SwFrm *pFrm );
     147             : 
     148             : const SwFrm * FindPage( const SwRect &rRect, const SwFrm *pPage );
     149             : 
     150             : // used by SwCntntNode::GetFrm and SwFlyFrm::GetFrm
     151             : SwFrm* GetFrmOfModify( const SwRootFrm* pLayout,
     152             :                        SwModify const&,
     153             :                        sal_uInt16 const nFrmType,
     154             :                        const Point* = 0,
     155             :                        const SwPosition *pPos = 0,
     156             :                        const sal_Bool bCalcFrm = sal_False );
     157             : 
     158             : // Should extra data (reline stroke, line numbers) be painted?
     159             : bool IsExtraData( const SwDoc *pDoc );
     160             : 
     161             : // #i11760# - method declaration <CalcCntnt(..)>
     162             : void CalcCntnt( SwLayoutFrm *pLay,
     163             :                 bool bNoColl = false,
     164             :                 bool bNoCalcFollow = false );
     165             : 
     166             : // Notify classes memorize the current sizes in their constructor and do
     167             : // the necessary notifications in their destructor if needed
     168             : class SwFrmNotify
     169             : {
     170             : protected:
     171             :     SwFrm *pFrm;
     172             :     const SwRect aFrm;
     173             :     const SwRect aPrt;
     174             :     SwTwips mnFlyAnchorOfst;
     175             :     SwTwips mnFlyAnchorOfstNoWrap;
     176             :     sal_Bool     bHadFollow;
     177             :     sal_Bool     bInvaKeep;
     178             :     sal_Bool     bValidSize;
     179             :     // #i49383#
     180             :     bool mbFrmDeleted;
     181             : 
     182             : public:
     183             :     SwFrmNotify( SwFrm *pFrm );
     184             :     ~SwFrmNotify();
     185             : 
     186           0 :     const SwRect &Frm() const { return aFrm; }
     187             :     const SwRect &Prt() const { return aPrt; }
     188           0 :     void SetInvaKeep() { bInvaKeep = sal_True; }
     189             :     // #i49383#
     190             :     void FrmDeleted()
     191             :     {
     192             :         mbFrmDeleted = true;
     193             :     }
     194             : };
     195             : 
     196             : class SwLayNotify : public SwFrmNotify
     197             : {
     198             :     sal_Bool bLowersComplete;
     199             : 
     200           0 :     SwLayoutFrm *GetLay() { return (SwLayoutFrm*)pFrm; }
     201             : 
     202             : public:
     203             :     SwLayNotify( SwLayoutFrm *pLayFrm );
     204             :     ~SwLayNotify();
     205             : 
     206           0 :     void SetLowersComplete( sal_Bool b ) { bLowersComplete = b; }
     207           0 :     sal_Bool IsLowersComplete()          { return bLowersComplete; }
     208             : };
     209             : 
     210             : class SwFlyNotify : public SwLayNotify
     211             : {
     212             :     SwPageFrm *pOldPage;
     213             :     const SwRect aFrmAndSpace;
     214           0 :     SwFlyFrm *GetFly() { return (SwFlyFrm*)pFrm; }
     215             : 
     216             : public:
     217             :     SwFlyNotify( SwFlyFrm *pFlyFrm );
     218             :     ~SwFlyNotify();
     219             : 
     220             :     SwPageFrm *GetOldPage() const { return pOldPage; }
     221             : };
     222             : 
     223             : class SwCntntNotify : public SwFrmNotify
     224             : {
     225             : private:
     226             :     // #i11859#
     227             :     bool    mbChkHeightOfLastLine;
     228             :     SwTwips mnHeightOfLastLine;
     229             : 
     230             :     // #i25029#
     231             :     bool        mbInvalidatePrevPrtArea;
     232             :     bool        mbBordersJoinedWithPrev;
     233             : 
     234           0 :     SwCntntFrm *GetCnt() { return (SwCntntFrm*)pFrm; }
     235             : 
     236             : public:
     237             :     SwCntntNotify( SwCntntFrm *pCntFrm );
     238             :     ~SwCntntNotify();
     239             : 
     240             :     // #i25029#
     241           0 :     void SetInvalidatePrevPrtArea()
     242             :     {
     243           0 :         mbInvalidatePrevPrtArea = true;
     244           0 :     }
     245             : 
     246           0 :     void SetBordersJoinedWithPrev()
     247             :     {
     248           0 :         mbBordersJoinedWithPrev = true;
     249           0 :     }
     250             : };
     251             : 
     252             : // SwBorderAttrs encapsulates the calculation for margin attributes including
     253             : // border. The whole class is cached.
     254             : 
     255             : // WARNING! If more attributes should be cached also adjust the method
     256             : //          Modify::Modify!
     257             : class SwBorderAttrs : public SwCacheObj
     258             : {
     259             :     const SwAttrSet      &rAttrSet;
     260             :     const SvxULSpaceItem &rUL;
     261             :     // #i96772#
     262             :     SvxLRSpaceItem rLR;
     263             :     const SvxBoxItem     &rBox;
     264             :     const SvxShadowItem  &rShadow;
     265             :     const Size            aFrmSize;
     266             : 
     267             :     // Is it a frame that can have a margin without a border?
     268             :     sal_Bool bBorderDist  : 1;
     269             : 
     270             :     // the following bool values set the cached values to INVALID - until they
     271             :     // are calculated for the first time
     272             :     sal_Bool bTopLine     : 1;
     273             :     sal_Bool bBottomLine  : 1;
     274             :     sal_Bool bLeftLine    : 1;
     275             :     sal_Bool bRightLine   : 1;
     276             :     sal_Bool bTop         : 1;
     277             :     sal_Bool bBottom      : 1;
     278             :     sal_Bool bLine        : 1;
     279             : 
     280             :     sal_Bool bIsLine      : 1; // border on at least one side?
     281             : 
     282             :     sal_Bool bCacheGetLine        : 1; // cache GetTopLine(), GetBottomLine()?
     283             :     sal_Bool bCachedGetTopLine    : 1; // is GetTopLine() cached?
     284             :     sal_Bool bCachedGetBottomLine : 1; // is GetBottomLine() cached?
     285             :     // Booleans indicate that <bJoinedWithPrev> and <bJoinedWithNext> are
     286             :     // cached and valid.
     287             :     // Caching depends on value of <bCacheGetLine>.
     288             :     mutable sal_Bool bCachedJoinedWithPrev : 1;
     289             :     mutable sal_Bool bCachedJoinedWithNext : 1;
     290             :     // Booleans indicate that borders are joined with previous/next frame.
     291             :     sal_Bool bJoinedWithPrev :1;
     292             :     sal_Bool bJoinedWithNext :1;
     293             : 
     294             :     // The cached values (un-defined until calculated for the first time)
     295             :     sal_uInt16 nTopLine,
     296             :            nBottomLine,
     297             :            nLeftLine,
     298             :            nRightLine,
     299             :            nTop,
     300             :            nBottom,
     301             :            nGetTopLine,
     302             :            nGetBottomLine;
     303             : 
     304             :     // only calculate lines and shadow
     305             :     void _CalcTopLine();
     306             :     void _CalcBottomLine();
     307             :     void _CalcLeftLine();
     308             :     void _CalcRightLine();
     309             : 
     310             :     // lines + shadow + margin
     311             :     void _CalcTop();
     312             :     void _CalcBottom();
     313             : 
     314             :     void _IsLine();
     315             : 
     316             :     // #i25029# - If <_pPrevFrm> is set, its value is taken for testing, if
     317             :     // borders/shadow have to be joined with previous frame.
     318             :     void _GetTopLine   ( const SwFrm& _rFrm,
     319             :                          const SwFrm* _pPrevFrm = 0L );
     320             :     void _GetBottomLine( const SwFrm& _rFrm );
     321             : 
     322             :     // calculate cached values <bJoinedWithPrev> and <bJoinedWithNext>
     323             :     // #i25029# - If <_pPrevFrm> is set, its value is taken for testing, if
     324             :     // borders/shadow have to be joined with previous frame.
     325             :     void _CalcJoinedWithPrev( const SwFrm& _rFrm,
     326             :                               const SwFrm* _pPrevFrm = 0L );
     327             :     void _CalcJoinedWithNext( const SwFrm& _rFrm );
     328             : 
     329             :     // internal helper method for _CalcJoinedWithPrev and _CalcJoinedWithNext
     330             :     sal_Bool _JoinWithCmp( const SwFrm& _rCallerFrm,
     331             :                        const SwFrm& _rCmpFrm ) const;
     332             : 
     333             :     // Are the left and right line and the LRSpace equal?
     334             :     sal_Bool CmpLeftRight( const SwBorderAttrs &rCmpAttrs,
     335             :                        const SwFrm *pCaller,
     336             :                        const SwFrm *pCmp ) const;
     337             : 
     338             : public:
     339           0 :     DECL_FIXEDMEMPOOL_NEWDEL(SwBorderAttrs)
     340             : 
     341             :     SwBorderAttrs( const SwModify *pOwner, const SwFrm *pConstructor );
     342             :     virtual ~SwBorderAttrs();
     343             : 
     344           0 :     inline const SwAttrSet      &GetAttrSet() const { return rAttrSet;  }
     345           0 :     inline const SvxULSpaceItem &GetULSpace() const { return rUL;       }
     346             :     inline const SvxLRSpaceItem &GetLRSpace() const { return rLR;       }
     347           0 :     inline const SvxBoxItem     &GetBox()     const { return rBox;      }
     348           0 :     inline const SvxShadowItem  &GetShadow()  const { return rShadow;   }
     349             : 
     350             :     inline sal_uInt16 CalcTopLine() const;
     351             :     inline sal_uInt16 CalcBottomLine() const;
     352             :     inline sal_uInt16 CalcLeftLine() const;
     353             :     inline sal_uInt16 CalcRightLine() const;
     354             :     inline sal_uInt16 CalcTop() const;
     355             :     inline sal_uInt16 CalcBottom() const;
     356             :            long CalcLeft( const SwFrm *pCaller ) const;
     357             :            long CalcRight( const SwFrm *pCaller ) const;
     358             : 
     359             :     inline sal_Bool IsLine() const;
     360             : 
     361           0 :     inline const Size &GetSize()     const { return aFrmSize; }
     362             : 
     363           0 :     inline sal_Bool IsBorderDist() const { return bBorderDist; }
     364             : 
     365             :     // Should upper (or lower) border be evaluated for this frame?
     366             :     // #i25029# - If <_pPrevFrm> is set, its value is taken for testing, if
     367             :     // borders/shadow have to be joined with previous frame.
     368             :     inline sal_uInt16 GetTopLine   ( const SwFrm& _rFrm,
     369             :                                  const SwFrm* _pPrevFrm = 0L ) const;
     370             :     inline sal_uInt16 GetBottomLine( const SwFrm& _rFrm ) const;
     371             :     inline void   SetGetCacheLine( sal_Bool bNew ) const;
     372             : 
     373             :     // Accessors for cached values <bJoinedWithPrev> and <bJoinedWithPrev>
     374             :     // #i25029# - If <_pPrevFrm> is set, its value is taken for testing, if
     375             :     // borders/shadow have to be joined with previous frame.
     376             :     sal_Bool JoinedWithPrev( const SwFrm& _rFrm,
     377             :                          const SwFrm* _pPrevFrm = 0L ) const;
     378             :     sal_Bool JoinedWithNext( const SwFrm& _rFrm ) const;
     379             : };
     380             : 
     381           0 : class SwBorderAttrAccess : public SwCacheAccess
     382             : {
     383             :     const SwFrm *pConstructor;      //opt: for passing on to SwBorderAttrs
     384             : 
     385             : protected:
     386             :     virtual SwCacheObj *NewObj() SAL_OVERRIDE;
     387             : 
     388             : public:
     389             :     SwBorderAttrAccess( SwCache &rCache, const SwFrm *pOwner );
     390             : 
     391             :     SwBorderAttrs *Get();
     392             : };
     393             : 
     394             : // Iterator for draw objects of a page. The objects will be iterated sorted by
     395             : // their Z-order. Iterating is not cheap since for each operation the _whole_
     396             : // SortArray needs to be traversed.
     397             : class SwOrderIter
     398             : {
     399             :     const SwPageFrm *pPage;
     400             :     const SdrObject *pCurrent;
     401             :     const sal_Bool bFlysOnly;
     402             : 
     403             : public:
     404             :     SwOrderIter( const SwPageFrm *pPage, sal_Bool bFlysOnly = sal_True );
     405             : 
     406           0 :     void             Current( const SdrObject *pNew ) { pCurrent = pNew; }
     407             :     const SdrObject *Current()    const { return pCurrent; }
     408           0 :     const SdrObject *operator()() const { return pCurrent; }
     409             :     const SdrObject *Top();
     410             :     const SdrObject *Bottom();
     411             :     const SdrObject *Next();
     412             :     const SdrObject *Prev();
     413             : };
     414             : 
     415             : class StackHack
     416             : {
     417             :     static sal_uInt8 nCnt;
     418             :     static sal_Bool bLocked;
     419             : 
     420             : public:
     421           0 :     StackHack()
     422             :     {
     423           0 :         if ( ++StackHack::nCnt > 50 )
     424           0 :             StackHack::bLocked = sal_True;
     425           0 :     }
     426           0 :     ~StackHack()
     427             :     {
     428           0 :         if ( --StackHack::nCnt < 5 )
     429           0 :             StackHack::bLocked = sal_False;
     430           0 :     }
     431             : 
     432           0 :     static sal_Bool IsLocked()  { return StackHack::bLocked; }
     433           0 :     static sal_uInt8 Count()        { return StackHack::nCnt; }
     434             : };
     435             : 
     436             : // Should upper (or lower) border be evaluated for this frame?
     437             : // #i25029# - If <_pPrevFrm> is set, its value is taken for testing, if
     438             : // borders/shadow have to be joined with previous frame.
     439           0 : inline sal_uInt16 SwBorderAttrs::GetTopLine ( const SwFrm& _rFrm,
     440             :                                           const SwFrm* _pPrevFrm ) const
     441             : {
     442           0 :     if ( !bCachedGetTopLine || _pPrevFrm )
     443             :     {
     444           0 :         const_cast<SwBorderAttrs*>(this)->_GetTopLine( _rFrm, _pPrevFrm );
     445             :     }
     446           0 :     return nGetTopLine;
     447             : }
     448           0 : inline sal_uInt16 SwBorderAttrs::GetBottomLine( const SwFrm& _rFrm ) const
     449             : {
     450           0 :     if ( !bCachedGetBottomLine )
     451           0 :         const_cast<SwBorderAttrs*>(this)->_GetBottomLine( _rFrm );
     452           0 :     return nGetBottomLine;
     453             : }
     454           0 : inline void SwBorderAttrs::SetGetCacheLine( sal_Bool bNew ) const
     455             : {
     456           0 :     ((SwBorderAttrs*)this)->bCacheGetLine = bNew;
     457             :     ((SwBorderAttrs*)this)->bCachedGetBottomLine =
     458           0 :     ((SwBorderAttrs*)this)->bCachedGetTopLine = sal_False;
     459             :     // invalidate cache for values <bJoinedWithPrev> and <bJoinedWithNext>
     460           0 :     bCachedJoinedWithPrev = sal_False;
     461           0 :     bCachedJoinedWithNext = sal_False;
     462           0 : }
     463             : 
     464           0 : inline sal_uInt16 SwBorderAttrs::CalcTopLine() const
     465             : {
     466           0 :     if ( bTopLine )
     467           0 :         ((SwBorderAttrs*)this)->_CalcTopLine();
     468           0 :     return nTopLine;
     469             : }
     470           0 : inline sal_uInt16 SwBorderAttrs::CalcBottomLine() const
     471             : {
     472           0 :     if ( bBottomLine )
     473           0 :         ((SwBorderAttrs*)this)->_CalcBottomLine();
     474           0 :     return nBottomLine;
     475             : }
     476           0 : inline sal_uInt16 SwBorderAttrs::CalcLeftLine() const
     477             : {
     478           0 :     if ( bLeftLine )
     479           0 :         ((SwBorderAttrs*)this)->_CalcLeftLine();
     480           0 :     return nLeftLine;
     481             : }
     482           0 : inline sal_uInt16 SwBorderAttrs::CalcRightLine() const
     483             : {
     484           0 :     if ( bRightLine )
     485           0 :         ((SwBorderAttrs*)this)->_CalcRightLine();
     486           0 :     return nRightLine;
     487             : }
     488           0 : inline sal_uInt16 SwBorderAttrs::CalcTop() const
     489             : {
     490           0 :     if ( bTop )
     491           0 :         ((SwBorderAttrs*)this)->_CalcTop();
     492           0 :     return nTop;
     493             : }
     494           0 : inline sal_uInt16 SwBorderAttrs::CalcBottom() const
     495             : {
     496           0 :     if ( bBottom )
     497           0 :         ((SwBorderAttrs*)this)->_CalcBottom();
     498           0 :     return nBottom;
     499             : }
     500           0 : inline sal_Bool SwBorderAttrs::IsLine() const
     501             : {
     502           0 :     if ( bLine )
     503           0 :         ((SwBorderAttrs*)this)->_IsLine();
     504           0 :     return bIsLine;
     505             : }
     506             : 
     507             : /** method to determine the spacing values of a frame
     508             : 
     509             :     #i28701#
     510             :     Values only provided for flow frames (table, section or text frames)
     511             :     Note: line spacing value is only determined for text frames
     512             :     #i102458#
     513             :     Add output parameter <obIsLineSpacingProportional>
     514             : 
     515             :     @param rFrm
     516             :     input parameter - frame, for which the spacing values are determined.
     517             : 
     518             :     @param onPrevLowerSpacing
     519             :     output parameter - lower spacing of the frame in SwTwips
     520             : 
     521             :     @param onPrevLineSpacing
     522             :     output parameter - line spacing of the frame in SwTwips
     523             : 
     524             :     @param obIsLineSpacingProportional
     525             : */
     526             : void GetSpacingValuesOfFrm( const SwFrm& rFrm,
     527             :                             SwTwips& onLowerSpacing,
     528             :                             SwTwips& onLineSpacing,
     529             :                             bool& obIsLineSpacingProportional );
     530             : 
     531             : /** method to get the content of the table cell
     532             : 
     533             :     Content from any nested tables will be omitted.
     534             :     Note: line spacing value is only determined for text frames
     535             : 
     536             :     @param rCell_
     537             :     input parameter - the cell which should be searched for content.
     538             : 
     539             :     return
     540             :         pointer to the found content frame or 0
     541             : */
     542             : 
     543             : const SwCntntFrm* GetCellCntnt( const SwLayoutFrm& rCell_ );
     544             : 
     545             : /** helper class to check if a frame has been deleted during an operation
     546             :  *  WARNING! This should only be used as a last and desperate means to make the
     547             :  *  code robust.
     548             :  */
     549             : 
     550             : class SwDeletionChecker
     551             : {
     552             : private:
     553             :     const SwFrm* mpFrm;
     554             :     const SwModify* mpRegIn;
     555             : 
     556             : public:
     557           0 :     SwDeletionChecker( const SwFrm* pFrm )
     558             :             : mpFrm( pFrm ),
     559           0 :               mpRegIn( pFrm ? const_cast<SwFrm*>(pFrm)->GetRegisteredIn() : 0 )
     560             :     {
     561           0 :     }
     562             : 
     563             :     /**
     564             :      *  return
     565             :      *    true if mpFrm != 0 and mpFrm is not client of pRegIn
     566             :      *    false otherwise
     567             :      */
     568             :     bool HasBeenDeleted();
     569             : };
     570             : 
     571             : #endif
     572             : 
     573             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10