| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| #ifndef _LAYHELP_HXX |
| #define _LAYHELP_HXX |
| #ifndef _SVSTDARR_HXX |
| #define _SVSTDARR_USHORTS |
| #define _SVSTDARR_ULONGS |
| #define _SVSTDARR_BYTES |
| #define _SVSTDARR_XUB_STRLEN |
| #include <svl/svstdarr.hxx> |
| #endif |
| #include <swrect.hxx> |
| |
| class SwDoc; |
| class SwFrm; |
| class SwLayoutFrm; |
| class SwPageFrm; |
| class SwFlyFrm; |
| class SwSectionFrm; |
| class SwSectionNode; |
| class SvStream; |
| |
| /************************************************************************* |
| * class SwLayCacheImpl |
| * contains the page break information and the text frame positions |
| * of the document (after loading) |
| * and is used inside the constructor of the layout rootframe to |
| * insert content and text frames at the right pages. |
| * For every page of the main text (body content, no footnotes, text frames etc.) |
| * we have the nodeindex of the first content at the page, |
| * the type of content ( table or paragraph ) |
| * and if it's not the first part of the table/paragraph, |
| * the row/character-offset inside the table/paragraph. |
| * The text frame positions are stored in the SwPageFlyCache array. |
| *************************************************************************/ |
| |
| class SwFlyCache; |
| typedef SwFlyCache* SwFlyCachePtr; |
| SV_DECL_PTRARR_DEL( SwPageFlyCache, SwFlyCachePtr, 0, 4 ) |
| |
| class SwLayCacheImpl : public SvULongs |
| { |
| SvXub_StrLens aOffset; |
| SvUShorts aType; |
| SwPageFlyCache aFlyCache; |
| sal_Bool bUseFlyCache; |
| void Insert( sal_uInt16 nType, sal_uLong nIndex, xub_StrLen nOffset ); |
| |
| public: |
| SwLayCacheImpl() : SvULongs( 20, 10 ), aType( 20, 10 ) {} |
| sal_Bool Read( SvStream& rStream ); |
| |
| sal_uLong GetBreakIndex( sal_uInt16 nIdx ) const { return GetObject( nIdx ); } |
| xub_StrLen GetBreakOfst( size_t nIdx ) const { return aOffset[ nIdx ]; } |
| sal_uInt16 GetBreakType( sal_uInt16 nIdx ) const { return aType[ nIdx ]; } |
| |
| sal_uInt16 GetFlyCount() const { return aFlyCache.Count(); } |
| SwFlyCache *GetFlyCache( sal_uInt16 nIdx ) const { return aFlyCache[ nIdx ]; } |
| |
| sal_Bool IsUseFlyCache() const { return bUseFlyCache; } |
| }; |
| |
| /************************************************************************* |
| * class SwActualSection |
| * helps to create the sectionframes during the _InsertCnt-function |
| * by controlling nested sections. |
| *************************************************************************/ |
| |
| class SwActualSection |
| { |
| SwActualSection *pUpper; |
| SwSectionFrm *pSectFrm; |
| SwSectionNode *pSectNode; |
| public: |
| SwActualSection( SwActualSection *pUpper, |
| SwSectionFrm *pSect, |
| SwSectionNode *pNd ); |
| |
| SwSectionFrm *GetSectionFrm() { return pSectFrm; } |
| void SetSectionFrm( SwSectionFrm *p ) { pSectFrm = p; } |
| SwSectionNode *GetSectionNode() { return pSectNode;} |
| SwActualSection *GetUpper() { return pUpper; } |
| }; |
| |
| /************************************************************************* |
| * class SwLayHelper |
| * helps during the _InsertCnt-function to create new pages. |
| * If there's a layoutcache available, this information is used. |
| *************************************************************************/ |
| |
| class SwLayHelper |
| { |
| SwFrm* &rpFrm; |
| SwFrm* &rpPrv; |
| SwPageFrm* &rpPage; |
| SwLayoutFrm* &rpLay; |
| SwActualSection* &rpActualSection; |
| sal_Bool &rbBreakAfter; |
| SwDoc* pDoc; |
| SwLayCacheImpl* pImpl; |
| sal_uLong nMaxParaPerPage; |
| sal_uLong nParagraphCnt; |
| sal_uLong nStartOfContent; |
| sal_uInt16 nIndex; // the index in the page break array |
| sal_uInt16 nFlyIdx; // the index in the fly cache array |
| sal_Bool bFirst : 1; |
| void _CheckFlyCache( SwPageFrm* pPage ); |
| public: |
| SwLayHelper( SwDoc *pD, SwFrm* &rpF, SwFrm* &rpP, SwPageFrm* &rpPg, |
| SwLayoutFrm* &rpL, SwActualSection* &rpA, sal_Bool &rBrk, |
| sal_uLong nNodeIndex, sal_Bool bCache ); |
| ~SwLayHelper(); |
| sal_uLong CalcPageCount(); |
| sal_Bool CheckInsert( sal_uLong nNodeIndex ); |
| |
| sal_Bool BreakPage( xub_StrLen& rOffs, sal_uLong nNodeIndex ); |
| sal_Bool CheckInsertPage(); |
| |
| // Look for fresh text frames at this (new) page and set them to the right |
| // position, if they are in the fly cache. |
| void CheckFlyCache( SwPageFrm* pPage ) |
| { if( pImpl && nFlyIdx < pImpl->GetFlyCount() ) _CheckFlyCache( pPage ); } |
| |
| // Look for this text frame and set it to the right position, |
| // if it's in the fly cache. |
| static sal_Bool CheckPageFlyCache( SwPageFrm* &rpPage, SwFlyFrm* pFly ); |
| }; |
| |
| /************************************************************************* |
| * class SwLayCacheIoImpl |
| * contains the data structures that are required to read and write a |
| * layout cache. |
| *************************************************************************/ |
| |
| #define SW_LAYCACHE_IO_REC_PAGES 'p' |
| #define SW_LAYCACHE_IO_REC_PARA 'P' |
| #define SW_LAYCACHE_IO_REC_TABLE 'T' |
| #define SW_LAYCACHE_IO_REC_FLY 'F' |
| |
| #define SW_LAYCACHE_IO_VERSION_MAJOR 1 |
| #define SW_LAYCACHE_IO_VERSION_MINOR 1 |
| |
| class SwLayCacheIoImpl |
| { |
| SvBytes aRecTypes; |
| SvULongs aRecSizes; |
| |
| SvStream *pStream; |
| |
| sal_uLong nFlagRecEnd; |
| |
| sal_uInt16 nMajorVersion; |
| sal_uInt16 nMinorVersion; |
| |
| sal_Bool bWriteMode : 1; |
| sal_Bool bError : 1; |
| |
| public: |
| SwLayCacheIoImpl( SvStream& rStrm, sal_Bool bWrtMd ); |
| |
| // Get input or output stream |
| SvStream& GetStream() const { return *pStream; } |
| |
| // Open a record of type "nType" |
| sal_Bool OpenRec( sal_uInt8 nType ); |
| |
| // Close a record of type "nType". This skips any unread data that |
| // remains in the record. |
| sal_Bool CloseRec( sal_uInt8 nType ); |
| |
| // Return the number of bytes contained in the current record that |
| // haven't been read by now. |
| sal_uInt32 BytesLeft(); |
| |
| // Return the current record's type |
| sal_uInt8 Peek(); |
| |
| // Skip the current record |
| void SkipRec(); |
| |
| // Open a flag record for reading. The uppermost four bits are flags, |
| // while the lowermost are the flag record's size. Flag records cannot |
| // be nested. |
| sal_uInt8 OpenFlagRec(); |
| |
| // Open flag record for writing; |
| void OpenFlagRec( sal_uInt8 nFlags, sal_uInt8 nLen ); |
| |
| // Close a flag record. Any bytes left are skipped. |
| void CloseFlagRec(); |
| |
| sal_Bool HasError() const { return bError; } |
| |
| sal_uInt16 GetMajorVersion() const { return nMajorVersion; } |
| sal_uInt16 GetMinorVersion() const { return nMinorVersion; } |
| }; |
| |
| // Stored information about text frames: |
| class SwFlyCache : public SwRect // position and size |
| { |
| public: |
| sal_uLong nOrdNum; // Id to recognize text frames |
| sal_uInt16 nPageNum; // page number |
| SwFlyCache( sal_uInt16 nP, sal_uLong nO, long nXL, long nYL, long nWL, long nHL ) : |
| SwRect( nXL, nYL, nWL, nHL ), nOrdNum( nO ), nPageNum( nP ){} |
| }; |
| |
| #endif |