xref: /aoo41x/main/sw/source/core/layout/laycache.cxx (revision 69a74367)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sw.hxx"
26 
27 
28 #include <hintids.hxx>
29 #include <editeng/brkitem.hxx>
30 #include <tools/stream.hxx>
31 #include <doc.hxx>
32 #include <docstat.hxx>
33 #include <docary.hxx>
34 #include <fmtpdsc.hxx>
35 #include <laycache.hxx>
36 #include <layhelp.hxx>
37 #include <pagefrm.hxx>
38 #include <rootfrm.hxx>
39 #include <txtfrm.hxx>
40 #include <ndtxt.hxx>
41 #include <swtable.hxx>
42 #include <tabfrm.hxx>
43 #include <rowfrm.hxx>
44 #include <colfrm.hxx>
45 #include <bodyfrm.hxx>
46 #include <ndindex.hxx>
47 #include <sectfrm.hxx>
48 #include <frmfmt.hxx>
49 #include <fmtcntnt.hxx>
50 #include <pagedesc.hxx>
51 #include <frmtool.hxx>
52 #include <dflyobj.hxx>
53 #include <dcontact.hxx>
54 #include "viewopt.hxx"
55 #include "viewsh.hxx"
56 #include <flyfrm.hxx>
57 // OD 2004-05-24 #i28701#
58 #include <sortedobjs.hxx>
59 // --> OD 2006-03-22 #b6375613#
60 #include <pam.hxx>
61 #include <docsh.hxx>
62 #include <com/sun/star/document/XDocumentInfoSupplier.hpp>
63 #include <com/sun/star/beans/XPropertySet.hpp>
64 
65 #include <set>
66 
67 
68 using namespace ::com::sun::star;
69 // <--
70 
SV_IMPL_PTRARR(SwPageFlyCache,SwFlyCachePtr)71 SV_IMPL_PTRARR( SwPageFlyCache, SwFlyCachePtr )
72 
73 /*-----------------28.5.2001 10:06------------------
74  *  Reading and writing of the layout cache.
75  *  The layout cache is not necessary, but it improves
76  *  the performance and reduces the text flow during
77  *  the formatting.
78  *  The layout cache contains the index of the paragraphs/tables
79  *  at the top of every page, so it's possible to create
80  *  the right count of pages and to distribute the document content
81  *  to this pages before the formatting starts.
82  *--------------------------------------------------*/
83 
84 void SwLayoutCache::Read( SvStream &rStream )
85 {
86     if( !pImpl )
87 	{
88         pImpl = new SwLayCacheImpl;
89 		if( !pImpl->Read( rStream ) )
90 		{
91 			delete pImpl;
92 			pImpl = 0;
93 		}
94 	}
95 }
96 
97 //-----------------------------------------------------------------------------
98 
Insert(sal_uInt16 nType,sal_uLong nIndex,xub_StrLen nOffset)99 void SwLayCacheImpl::Insert( sal_uInt16 nType, sal_uLong nIndex, xub_StrLen nOffset )
100 {
101 	aType.Insert( nType, aType.Count() );
102 	SvULongs::Insert( nIndex, SvULongs::Count() );
103 	aOffset.push_back( nOffset );
104 }
105 
Read(SvStream & rStream)106 sal_Bool SwLayCacheImpl::Read( SvStream& rStream )
107 {
108 	SwLayCacheIoImpl aIo( rStream, sal_False );
109 	if( aIo.GetMajorVersion() > SW_LAYCACHE_IO_VERSION_MAJOR )
110 		return sal_False;
111 
112     // Due to an evil bug in the layout cache (#102759#), we cannot trust the
113     // sizes of fly frames which have been written using the "old" layout cache.
114     // This flag should indicate that we do not want to trust the width and
115     // height of fly frames
116     bUseFlyCache = aIo.GetMinorVersion() >= 1;
117 
118 	sal_uInt8 cFlags;
119 	sal_uInt32 nIndex, nOffset;
120 
121 	aIo.OpenRec( SW_LAYCACHE_IO_REC_PAGES );
122 	aIo.OpenFlagRec();
123 	aIo.CloseFlagRec();
124 	while( aIo.BytesLeft() && !aIo.HasError() )
125 	{
126 		switch( aIo.Peek() )
127 		{
128 		case SW_LAYCACHE_IO_REC_PARA:
129 			aIo.OpenRec( SW_LAYCACHE_IO_REC_PARA );
130 			cFlags = aIo.OpenFlagRec();
131 			aIo.GetStream() >> nIndex;
132 			if( (cFlags & 0x01) != 0 )
133 				aIo.GetStream() >> nOffset;
134 			else
135 				nOffset = STRING_LEN;
136 			aIo.CloseFlagRec();
137 			Insert( SW_LAYCACHE_IO_REC_PARA, nIndex, (xub_StrLen)nOffset );
138 			aIo.CloseRec( SW_LAYCACHE_IO_REC_PARA );
139 			break;
140 		case SW_LAYCACHE_IO_REC_TABLE:
141 			aIo.OpenRec( SW_LAYCACHE_IO_REC_TABLE );
142 			aIo.OpenFlagRec();
143             aIo.GetStream() >> nIndex
144                             >> nOffset;
145 			Insert( SW_LAYCACHE_IO_REC_TABLE, nIndex, (xub_StrLen)nOffset );
146 			aIo.CloseFlagRec();
147 			aIo.CloseRec( SW_LAYCACHE_IO_REC_TABLE );
148 			break;
149         case SW_LAYCACHE_IO_REC_FLY:
150         {
151             aIo.OpenRec( SW_LAYCACHE_IO_REC_FLY );
152 			aIo.OpenFlagRec();
153 			aIo.CloseFlagRec();
154             long nX, nY, nW, nH;
155             sal_uInt16 nPgNum;
156             aIo.GetStream() >> nPgNum >> nIndex
157                     >> nX >> nY >> nW >> nH;
158             SwFlyCache* pFly = new SwFlyCache( nPgNum, nIndex, nX, nY, nW, nH );
159             aFlyCache.Insert( pFly, aFlyCache.Count() );
160             aIo.CloseRec( SW_LAYCACHE_IO_REC_FLY );
161 			break;
162         }
163 		default:
164 			aIo.SkipRec();
165 			break;
166 		}
167 	}
168 	aIo.CloseRec( SW_LAYCACHE_IO_REC_PAGES );
169 
170 	return !aIo.HasError();
171 }
172 
173 /*-----------------28.5.2001 10:19------------------
174  * SwLayoutCache::Write(..)
175  * writes the index (more precise: the difference between
176  * the index and the first index of the document content)
177  * of the first paragraph/table at the top of every page.
178  * If at the top of a page is the rest of a paragraph/table
179  * from the bottom of the previous page, the character/row
180  * number is stored, too.
181  * The position, size and page number of the text frames
182  * are stored, too
183  * --------------------------------------------------*/
184 
Write(SvStream & rStream,const SwDoc & rDoc)185 void SwLayoutCache::Write( SvStream &rStream, const SwDoc& rDoc )
186 {
187     if( rDoc.GetCurrentLayout() ) // the layout itself ..	//swmod 080218
188     {
189 		SwLayCacheIoImpl aIo( rStream, sal_True );
190         // We want to save the relative index, so we need the index
191         // of the first content
192         sal_uLong nStartOfContent = rDoc.GetNodes().GetEndOfContent().
193                                 StartOfSectionNode()->GetIndex();
194         // The first page..
195         SwPageFrm* pPage = (SwPageFrm*)rDoc.GetCurrentLayout()->Lower();	//swmod 080218
196 
197 		aIo.OpenRec( SW_LAYCACHE_IO_REC_PAGES );
198 		aIo.OpenFlagRec( 0, 0 );
199 		aIo.CloseFlagRec();
200         while( pPage )
201         {
202             if( pPage->GetPrev() )
203             {
204                 SwLayoutFrm* pLay = pPage->FindBodyCont();
205                 SwFrm* pTmp = pLay ? pLay->ContainsAny() : NULL;
206                 // We are only interested in paragraph or table frames,
207                 // a section frames contains paragraphs/tables.
208                 if( pTmp && pTmp->IsSctFrm() )
209                     pTmp = ((SwSectionFrm*)pTmp)->ContainsAny();
210 
211                 if( pTmp ) // any content
212                 {
213                     if( pTmp->IsTxtFrm() )
214                     {
215                         sal_uLong nNdIdx = ((SwTxtFrm*)pTmp)->GetNode()->GetIndex();
216                         if( nNdIdx > nStartOfContent )
217                         {
218                             /*  Open Paragraph Record */
219                             aIo.OpenRec( SW_LAYCACHE_IO_REC_PARA );
220                             sal_Bool bFollow = ((SwTxtFrm*)pTmp)->IsFollow();
221                             aIo.OpenFlagRec( bFollow ? 0x01 : 0x00,
222                                             bFollow ? 8 : 4 );
223                             nNdIdx -= nStartOfContent;
224                             aIo.GetStream() << static_cast<sal_uInt32>(nNdIdx);
225                             if( bFollow )
226                                 aIo.GetStream() << static_cast<sal_uInt32>(((SwTxtFrm*)pTmp)->GetOfst());
227                             aIo.CloseFlagRec();
228                             /*  Close Paragraph Record */
229                             aIo.CloseRec( SW_LAYCACHE_IO_REC_PARA );
230                         }
231                     }
232                     else if( pTmp->IsTabFrm() )
233                     {
234                         SwTabFrm* pTab = (SwTabFrm*)pTmp;
235                         sal_uLong nOfst = STRING_LEN;
236                         if( pTab->IsFollow() )
237                         {
238                             // If the table is a follow, we have to look for the
239                             // master and to count all rows to get the row number
240                             nOfst = 0;
241                             if( pTab->IsFollow() )
242                                 pTab = pTab->FindMaster( true );
243                             while( pTab != pTmp )
244                             {
245                                 SwFrm* pSub = pTab->Lower();
246                                 while( pSub )
247                                 {
248                                     ++nOfst;
249                                     pSub = pSub->GetNext();
250                                 }
251                                 pTab = pTab->GetFollow();
252                                 ASSERT( pTab, "Table follow without master" );
253                             }
254                         }
255                         do
256                         {
257                             sal_uLong nNdIdx =
258                                     pTab->GetTable()->GetTableNode()->GetIndex();
259                             if( nNdIdx > nStartOfContent )
260                             {
261                                 /* Open Table Record */
262                                 aIo.OpenRec( SW_LAYCACHE_IO_REC_TABLE );
263                                 aIo.OpenFlagRec( 0, 8 );
264                                 nNdIdx -= nStartOfContent;
265                                 aIo.GetStream() << static_cast<sal_uInt32>(nNdIdx)
266                                                 << static_cast<sal_uInt32>(nOfst);
267                                 aIo.CloseFlagRec();
268                                 /* Close Table Record  */
269                                 aIo.CloseRec( SW_LAYCACHE_IO_REC_TABLE );
270                             }
271                             // If the table has a follow on the next page,
272                             // we know already the row number and store this
273                             // immediately.
274                             if( pTab->GetFollow() )
275                             {
276                                 if( nOfst == STRING_LEN )
277                                     nOfst = 0;
278                                 do
279                                 {
280                                     SwFrm* pSub = pTab->Lower();
281                                     while( pSub )
282                                     {
283                                         ++nOfst;
284                                         pSub = pSub->GetNext();
285                                     }
286                                     pTab = pTab->GetFollow();
287                                     SwPageFrm *pTabPage = pTab->FindPageFrm();
288                                     if( pTabPage != pPage )
289                                     {
290                                         ASSERT( pPage->GetPhyPageNum() <
291                                                 pTabPage->GetPhyPageNum(),
292                                                 "Looping Tableframes" );
293                                         pPage = pTabPage;
294                                         break;
295                                     }
296                                 } while ( pTab->GetFollow() );
297                             }
298                             else
299                                 break;
300                         } while( pTab );
301                     }
302                 }
303             }
304             if( pPage->GetSortedObjs() )
305             {
306                 SwSortedObjs &rObjs = *pPage->GetSortedObjs();
307                 for ( sal_uInt16 i = 0; i < rObjs.Count(); ++i )
308                 {
309                     SwAnchoredObject* pAnchoredObj = rObjs[i];
310                     if ( pAnchoredObj->ISA(SwFlyFrm) )
311                     {
312                         SwFlyFrm *pFly = static_cast<SwFlyFrm*>(pAnchoredObj);
313                         if( pFly->Frm().Left() != WEIT_WECH &&
314                             !pFly->GetAnchorFrm()->FindFooterOrHeader() )
315                         {
316                             const SwContact *pC =
317                                     ::GetUserCall(pAnchoredObj->GetDrawObj());
318                             if( pC )
319                             {
320                                 sal_uInt32 nOrdNum = pAnchoredObj->GetDrawObj()->GetOrdNum();
321                                 sal_uInt16 nPageNum = pPage->GetPhyPageNum();
322                                 /* Open Fly Record */
323                                 aIo.OpenRec( SW_LAYCACHE_IO_REC_FLY );
324                                 aIo.OpenFlagRec( 0, 0 );
325                                 aIo.CloseFlagRec();
326                                 SwRect &rRct = pFly->Frm();
327                                 sal_Int32 nX = rRct.Left() - pPage->Frm().Left();
328                                 sal_Int32 nY = rRct.Top() - pPage->Frm().Top();
329                                 aIo.GetStream() << nPageNum << nOrdNum
330                                                 << nX << nY << rRct.Width()
331                                                 << rRct.Height();
332                                 /* Close Fly Record  */
333                                 aIo.CloseRec( SW_LAYCACHE_IO_REC_FLY );
334                             }
335                         }
336                     }
337                 }
338             }
339             pPage = (SwPageFrm*)pPage->GetNext();
340         }
341 		aIo.CloseRec( SW_LAYCACHE_IO_REC_PAGES );
342     }
343 }
344 
345 #ifdef DBG_UTIL
CompareLayout(const SwDoc & rDoc) const346 sal_Bool SwLayoutCache::CompareLayout( const SwDoc& rDoc ) const
347 {
348     if( !pImpl )
349         return sal_True;
350     const SwRootFrm *pRootFrm = rDoc.GetCurrentLayout();
351     sal_Bool bRet = sal_True;
352     if( pRootFrm )
353     {
354         sal_uInt16 nIndex = 0;
355         sal_uLong nStartOfContent = rDoc.GetNodes().GetEndOfContent().
356                                 StartOfSectionNode()->GetIndex();
357         SwPageFrm* pPage = (SwPageFrm*)pRootFrm->Lower();
358         if( pPage )
359             pPage = (SwPageFrm*)pPage->GetNext();
360         while( pPage )
361         {
362             if( nIndex >= pImpl->Count() )
363             {
364                 if( bRet )
365                     bRet = sal_False;
366                 break;
367             }
368             SwLayoutFrm* pLay = pPage->FindBodyCont();
369             SwFrm* pTmp = pLay ? pLay->ContainsAny() : NULL;
370             if( pTmp && pTmp->IsSctFrm() )
371                 pTmp = ((SwSectionFrm*)pTmp)->ContainsAny();
372             if( pTmp )
373             {
374                 if( pTmp->IsTxtFrm() )
375                 {
376                     sal_uLong nNdIdx = ((SwTxtFrm*)pTmp)->GetNode()->GetIndex();
377                     if( nNdIdx > nStartOfContent )
378                     {
379 						sal_Bool bFollow = ((SwTxtFrm*)pTmp)->IsFollow();
380                         nNdIdx -= nStartOfContent;
381                         if( pImpl->GetBreakIndex( nIndex ) != nNdIdx ||
382                             SW_LAYCACHE_IO_REC_PARA !=
383                             pImpl->GetBreakType( nIndex ) ||
384                             ( bFollow ? ((SwTxtFrm*)pTmp)->GetOfst()
385                               : STRING_LEN ) != pImpl->GetBreakOfst( nIndex ) )
386                         {
387                             if( bRet )
388                                 bRet = sal_False;
389                         }
390                         ++nIndex;
391                     }
392                 }
393                 else if( pTmp->IsTabFrm() )
394                 {
395                     SwTabFrm* pTab = (SwTabFrm*)pTmp;
396                     sal_uLong nOfst = STRING_LEN;
397                     if( pTab->IsFollow() )
398                     {
399                         nOfst = 0;
400                         if( pTab->IsFollow() )
401                             pTab = pTab->FindMaster( true );
402                         while( pTab != pTmp )
403                         {
404                             SwFrm* pSub = pTab->Lower();
405                             while( pSub )
406                             {
407                                 ++nOfst;
408                                 pSub = pSub->GetNext();
409                             }
410                             pTab = pTab->GetFollow();
411                         }
412                     }
413                     do
414                     {
415                         sal_uLong nNdIdx =
416                                 pTab->GetTable()->GetTableNode()->GetIndex();
417                         if( nNdIdx > nStartOfContent )
418                         {
419                             nNdIdx -= nStartOfContent;
420                             if( pImpl->GetBreakIndex( nIndex ) != nNdIdx ||
421                                 SW_LAYCACHE_IO_REC_TABLE !=
422                                 pImpl->GetBreakType( nIndex ) ||
423                                nOfst != pImpl->GetBreakOfst( nIndex ) )
424                             {
425                                 if( bRet )
426                                     bRet = sal_False;
427                             }
428                             ++nIndex;
429                         }
430                         if( pTab->GetFollow() )
431                         {
432                             if( nOfst == STRING_LEN )
433                                 nOfst = 0;
434                             do
435                             {
436                                 SwFrm* pSub = pTab->Lower();
437                                 while( pSub )
438                                 {
439                                     ++nOfst;
440                                     pSub = pSub->GetNext();
441                                 }
442                                 pTab = pTab->GetFollow();
443                                 SwPageFrm *pTabPage = pTab->FindPageFrm();
444                                 if( pTabPage != pPage )
445                                 {
446                                     pPage = pTabPage;
447                                     break;
448                                 }
449                             } while ( pTab->GetFollow() );
450                         }
451                         else
452                             break;
453                     } while( pTab );
454                 }
455             }
456             pPage = (SwPageFrm*)pPage->GetNext();
457         }
458     }
459     return bRet;
460 }
461 #endif
462 
ClearImpl()463 void SwLayoutCache::ClearImpl()
464 {
465     if( !IsLocked() )
466     {
467         delete pImpl;
468         pImpl = 0;
469     }
470 }
471 
472 
~SwLayoutCache()473 SwLayoutCache::~SwLayoutCache()
474 {
475     ASSERT( !nLockCount, "Deleting a locked SwLayoutCache!?" );
476     delete pImpl;
477 }
478 
479 /*-----------------28.5.2001 10:47------------------
480  * SwActualSection,
481  *  a help class to create not nested section frames
482  *  for nested sections.
483  * --------------------------------------------------*/
484 
SwActualSection(SwActualSection * pUp,SwSectionFrm * pSect,SwSectionNode * pNd)485 SwActualSection::SwActualSection( SwActualSection *pUp,
486 								  SwSectionFrm	  *pSect,
487 								  SwSectionNode	  *pNd ) :
488 	pUpper( pUp ),
489 	pSectFrm( pSect ),
490 	pSectNode( pNd )
491 {
492 	if ( !pSectNode )
493 	{
494 		const SwNodeIndex *pIndex = pSect->GetFmt()->GetCntnt().GetCntntIdx();
495         pSectNode = pIndex->GetNode().FindSectionNode();
496     }
497 }
498 
499 /*-----------------28.5.2001 11:09------------------
500  * SwLayHelper
501  *  is the helper class, which utilizes the layout cache information
502  *  to distribute the document content to the rigth pages.
503  * It's used by the _InsertCnt(..)-function.
504  * If there's no layout cache, the distibution to the pages is more
505  * a guess, but a guess with statistical background.
506  * --------------------------------------------------*/
507 
SwLayHelper(SwDoc * pD,SwFrm * & rpF,SwFrm * & rpP,SwPageFrm * & rpPg,SwLayoutFrm * & rpL,SwActualSection * & rpA,sal_Bool & rB,sal_uLong nNodeIndex,sal_Bool bCache)508 SwLayHelper::SwLayHelper( SwDoc *pD, SwFrm* &rpF, SwFrm* &rpP, SwPageFrm* &rpPg,
509             SwLayoutFrm* &rpL, SwActualSection* &rpA, sal_Bool &rB,
510             sal_uLong nNodeIndex, sal_Bool bCache )
511     : rpFrm( rpF ), rpPrv( rpP ), rpPage( rpPg ), rpLay( rpL ),
512       rpActualSection( rpA ), rbBreakAfter(rB), pDoc(pD), nMaxParaPerPage( 25 ),
513       nParagraphCnt( bCache ? 0 : USHRT_MAX ), bFirst( bCache )
514 {
515     pImpl = pDoc->GetLayoutCache() ? pDoc->GetLayoutCache()->LockImpl() : NULL;
516     if( pImpl )
517     {
518         nMaxParaPerPage = 1000;
519         nStartOfContent = pDoc->GetNodes().GetEndOfContent().StartOfSectionNode()
520                           ->GetIndex();
521         nNodeIndex -= nStartOfContent;
522         nIndex = 0;
523         nFlyIdx = 0;
524         while( nIndex < pImpl->Count() && (*pImpl)[ nIndex ] < nNodeIndex )
525             ++nIndex;
526         if( nIndex >= pImpl->Count() )
527         {
528             pDoc->GetLayoutCache()->UnlockImpl();
529             pImpl = NULL;
530         }
531     }
532     else
533     {
534         nIndex = USHRT_MAX;
535         nStartOfContent = ULONG_MAX;
536     }
537 }
538 
~SwLayHelper()539 SwLayHelper::~SwLayHelper()
540 {
541     if( pImpl )
542     {
543         ASSERT( pDoc && pDoc->GetLayoutCache(), "Missing layoutcache" );
544         pDoc->GetLayoutCache()->UnlockImpl();
545     }
546 }
547 
548 /*-----------------23.5.2001 16:40------------------
549  * SwLayHelper::CalcPageCount() does not really calculate the page count,
550  * it returns the page count value from the layout cache, if available,
551  * otherwise it estimates the page count.
552  * --------------------------------------------------*/
553 
CalcPageCount()554 sal_uLong SwLayHelper::CalcPageCount()
555 {
556     sal_uLong nPgCount;
557     SwLayCacheImpl *pCache = pDoc->GetLayoutCache() ?
558                              pDoc->GetLayoutCache()->LockImpl() : NULL;
559     if( pCache )
560     {
561         nPgCount = pCache->Count() + 1;
562         pDoc->GetLayoutCache()->UnlockImpl();
563     }
564     else
565     {
566 		nPgCount = pDoc->GetDocStat().nPage;
567         if ( nPgCount <= 10 ) // no page insertion for less than 10 pages
568 			nPgCount = 0;
569 		sal_uLong nNdCount = pDoc->GetDocStat().nPara;
570 		if ( nNdCount <= 1 )
571 		{
572             //Estimates the number of paragraphs.
573 			sal_uLong nTmp = pDoc->GetNodes().GetEndOfContent().GetIndex() -
574 						pDoc->GetNodes().GetEndOfExtras().GetIndex();
575             //Tables have a little overhead..
576 			nTmp -= pDoc->GetTblFrmFmts()->Count() * 25;
577             //Fly frames, too ..
578 			nTmp -= (pDoc->GetNodes().GetEndOfAutotext().GetIndex() -
579 					   pDoc->GetNodes().GetEndOfInserts().GetIndex()) / 3 * 5;
580 			if ( nTmp > 0 )
581 				nNdCount = nTmp;
582 		}
583         if ( nNdCount > 100 ) // no estimation below this value
584 		{
585 			if ( nPgCount > 0 )
586 				nMaxParaPerPage = nNdCount / nPgCount;
587 			else
588 			{
589 				nMaxParaPerPage = Max( sal_uLong(20),
590 									   sal_uLong(20 + nNdCount / 1000 * 3) );
591 #ifdef PM2
592 				const sal_uLong nMax = 49;
593 #else
594 				const sal_uLong nMax = 53;
595 #endif
596 				nMaxParaPerPage = Min( nMaxParaPerPage, nMax );
597 				nPgCount = nNdCount / nMaxParaPerPage;
598 			}
599             if ( nNdCount < 1000 )
600                 nPgCount = 0;// no progress bar for small documents
601             ViewShell *pSh = 0;
602             if( rpLay && rpLay->getRootFrm() )
603                 pSh = rpLay->getRootFrm()->GetCurrShell();
604             if( pSh && pSh->GetViewOptions()->getBrowseMode() )
605 				nMaxParaPerPage *= 6;
606 		}
607     }
608     return nPgCount;
609 }
610 
611 /*-----------------23.5.2001 16:44------------------
612  * SwLayHelper::CheckInsertPage()
613  * inserts a page and return sal_True, if
614  * - the break after flag is set
615  * - the actual content wants a break before
616  * - the maximum count of paragraph/rows is reached
617  *
618  * The break after flag is set, if the actual content
619  * wants a break after.
620  * --------------------------------------------------*/
621 
CheckInsertPage()622 sal_Bool SwLayHelper::CheckInsertPage()
623 {
624 	sal_Bool bEnd = 0 == rpPage->GetNext();
625     const SwAttrSet* pAttr = rpFrm->GetAttrSet();
626 	const SvxFmtBreakItem& rBrk = pAttr->GetBreak();
627 	const SwFmtPageDesc& rDesc = pAttr->GetPageDesc();
628     // --> FME 2004-10-26 #118195# Do not evaluate page description if frame
629     // is a follow frame!
630     const SwPageDesc* pDesc = rpFrm->IsFlowFrm() &&
631                               SwFlowFrm::CastFlowFrm( rpFrm )->IsFollow() ?
632                               0 :
633                               rDesc.GetPageDesc();
634     // <--
635 
636 	sal_Bool bBrk = nParagraphCnt > nMaxParaPerPage || rbBreakAfter;
637 	rbBreakAfter = rBrk.GetBreak() == SVX_BREAK_PAGE_AFTER ||
638 				   rBrk.GetBreak() == SVX_BREAK_PAGE_BOTH;
639 	if ( !bBrk )
640 		bBrk = rBrk.GetBreak() == SVX_BREAK_PAGE_BEFORE ||
641 			   rBrk.GetBreak() == SVX_BREAK_PAGE_BOTH;
642 
643 	if ( bBrk || pDesc )
644 	{
645 		sal_uInt16 nPgNum = 0;
646 		if ( !pDesc )
647 			pDesc = rpPage->GetPageDesc()->GetFollow();
648 		else
649 		{
650 			if ( 0 != (nPgNum = rDesc.GetNumOffset()) )
651 				((SwRootFrm*)rpPage->GetUpper())->SetVirtPageNum(sal_True);
652 		}
653 		sal_Bool bNextPageOdd = !rpPage->OnRightPage();
654 		sal_Bool bInsertEmpty = sal_False;
655 		if( nPgNum && bNextPageOdd != ( ( nPgNum % 2 ) != 0 ) )
656 		{
657 			bNextPageOdd = !bNextPageOdd;
658 			bInsertEmpty = sal_True;
659 		}
660 		::InsertNewPage( (SwPageDesc&)*pDesc, rpPage->GetUpper(),
661 						 bNextPageOdd, bInsertEmpty, sal_False, rpPage->GetNext() );
662 		if ( bEnd )
663 		{
664 			ASSERT( rpPage->GetNext(), "Keine neue Seite?" );
665 			do
666 			{	rpPage = (SwPageFrm*)rpPage->GetNext();
667 			} while ( rpPage->GetNext() );
668 		}
669 		else
670 		{
671 			ASSERT( rpPage->GetNext(), "Keine neue Seite?" );
672 			rpPage = (SwPageFrm*)rpPage->GetNext();
673 			if ( rpPage->IsEmptyPage() )
674 			{
675 				ASSERT( rpPage->GetNext(), "Keine neue Seite?" );
676 				rpPage = (SwPageFrm*)rpPage->GetNext();
677 			}
678 		}
679 		rpLay = rpPage->FindBodyCont();
680 		while( rpLay->Lower() )
681 			rpLay = (SwLayoutFrm*)rpLay->Lower();
682 		return sal_True;
683 	}
684 	return sal_False;
685 }
686 
687 // --> OD 2006-03-22 #b6375613#
lcl_HasTextFrmAnchoredObjs(SwTxtFrm * p_pTxtFrm)688 bool lcl_HasTextFrmAnchoredObjs( SwTxtFrm* p_pTxtFrm )
689 {
690     bool bHasTextFrmAnchoredObjs( false );
691 
692     const SwSpzFrmFmts* pSpzFrmFmts = p_pTxtFrm->GetTxtNode()->GetDoc()->GetSpzFrmFmts();
693     for ( sal_uInt16 i = 0; i < pSpzFrmFmts->Count(); ++i )
694     {
695         SwFrmFmt *pFmt = (SwFrmFmt*)(*pSpzFrmFmts)[i];
696         const SwFmtAnchor &rAnch = pFmt->GetAnchor();
697         if ( rAnch.GetCntntAnchor() &&
698              ((rAnch.GetAnchorId() == FLY_AT_PARA) ||
699               (rAnch.GetAnchorId() == FLY_AT_CHAR)) &&
700              rAnch.GetCntntAnchor()->nNode.GetIndex() ==
701                                         p_pTxtFrm->GetTxtNode()->GetIndex() )
702         {
703             bHasTextFrmAnchoredObjs = true;
704             break;
705         }
706     }
707 
708     return bHasTextFrmAnchoredObjs;
709 }
710 
lcl_ApplyWorkaroundForB6375613(SwFrm * p_pFirstFrmOnNewPage)711 void lcl_ApplyWorkaroundForB6375613( SwFrm* p_pFirstFrmOnNewPage )
712 {
713     SwTxtFrm* pFirstTextFrmOnNewPage = dynamic_cast<SwTxtFrm*>(p_pFirstFrmOnNewPage);
714     //
715     if ( pFirstTextFrmOnNewPage &&
716          !pFirstTextFrmOnNewPage->IsFollow() &&
717          pFirstTextFrmOnNewPage->GetTxt().Len() == 0 &&
718          lcl_HasTextFrmAnchoredObjs( pFirstTextFrmOnNewPage ) )
719     {
720         // apply page break before at this text frame to assure, that it doesn't flow backward.
721         const SvxBreak eBreak =
722                     pFirstTextFrmOnNewPage->GetAttrSet()->GetBreak().GetBreak();
723         if ( eBreak == SVX_BREAK_NONE )
724         {
725             pFirstTextFrmOnNewPage->GetTxtNode()->LockModify();
726             SwDoc* pDoc( pFirstTextFrmOnNewPage->GetTxtNode()->GetDoc() );
727             IDocumentContentOperations* pIDCO = pFirstTextFrmOnNewPage->GetTxtNode()->getIDocumentContentOperations();
728             const SwPaM aTmpPaM( *(pFirstTextFrmOnNewPage->GetTxtNode()) );
729             pIDCO->InsertPoolItem(
730                 aTmpPaM, SvxFmtBreakItem( SVX_BREAK_PAGE_BEFORE, RES_BREAK ), 0 );
731             pFirstTextFrmOnNewPage->GetTxtNode()->UnlockModify();
732 
733             uno::Reference< document::XDocumentInfoSupplier > xDoc(
734                                         pDoc->GetDocShell()->GetBaseModel(),
735                                         uno::UNO_QUERY);
736             uno::Reference< beans::XPropertySet > xDocInfo(
737                                         xDoc->getDocumentInfo(),
738                                         uno::UNO_QUERY );
739             try
740             {
741                 xDocInfo->setPropertyValue( rtl::OUString::createFromAscii("WorkaroundForB6375613Applied"), uno::makeAny( true ) );
742             }
743             catch( uno::Exception& )
744             {
745             }
746         }
747     }
748 }
749 // <--
750 
751 /*-----------------28.5.2001 11:31------------------
752  * SwLayHelper::CheckInsert
753  *  is the entry point for the _InsertCnt-function.
754  *  The document content index is checked either it is
755  *  in the layout cache either it's time to insert a page
756  *  cause the maximal estimation of content per page is reached.
757  *  A really big table or long paragraph may contains more than
758  *  one page, in this case the needed count of pages will inserted.
759  * --------------------------------------------------*/
760 
CheckInsert(sal_uLong nNodeIndex)761 sal_Bool SwLayHelper::CheckInsert( sal_uLong nNodeIndex )
762 {
763     sal_Bool bRet = sal_False;
764     sal_Bool bLongTab = sal_False;
765     sal_uLong nMaxRowPerPage( 0 );
766     nNodeIndex -= nStartOfContent;
767     sal_uInt16 nRows( 0 );
768     if( rpFrm->IsTabFrm() )
769     {
770         //Inside a table counts every row as a paragraph
771         SwFrm *pLow = ((SwTabFrm*)rpFrm)->Lower();
772         nRows = 0;
773         do
774         {
775             ++nRows;
776             pLow = pLow->GetNext();
777         } while ( pLow );
778         nParagraphCnt += nRows;
779         if( !pImpl && nParagraphCnt > nMaxParaPerPage + 10 )
780         {
781             // OD 09.04.2003 #108698# - improve heuristics:
782             // Assume that a table, which has more than three times the quantity
783             // of maximal paragraphs per page rows, consists of rows, which have
784             // the height of a normal paragraph. Thus, allow as much rows per page
785             // as much paragraphs are allowed.
786             if ( nRows > ( 3*nMaxParaPerPage ) )
787             {
788                 nMaxRowPerPage = nMaxParaPerPage;
789             }
790             else
791             {
792                 SwFrm *pTmp = ((SwTabFrm*)rpFrm)->Lower();
793                 if( pTmp->GetNext() )
794                     pTmp = pTmp->GetNext();
795                 pTmp = ((SwRowFrm*)pTmp)->Lower();
796                 sal_uInt16 nCnt = 0;
797                 do
798                 {
799                     ++nCnt;
800                     pTmp = pTmp->GetNext();
801                 } while( pTmp );
802                 nMaxRowPerPage = Max( sal_uLong(2), nMaxParaPerPage / nCnt );
803             }
804             bLongTab = sal_True;
805         }
806     }
807     else
808         ++nParagraphCnt;
809     if( bFirst && pImpl && nIndex < pImpl->Count() &&
810         pImpl->GetBreakIndex( nIndex ) == nNodeIndex &&
811         ( pImpl->GetBreakOfst( nIndex ) < STRING_LEN ||
812           ( ++nIndex < pImpl->Count() &&
813           pImpl->GetBreakIndex( nIndex ) == nNodeIndex ) ) )
814         bFirst = sal_False;
815 #if OSL_DEBUG_LEVEL > 1
816     sal_uLong nBreakIndex = ( pImpl && nIndex < pImpl->Count() ) ?
817                         pImpl->GetBreakIndex(nIndex) : 0xffff;
818     (void)nBreakIndex;
819 #endif
820     // OD 09.04.2003 #108698# - always split a big tables.
821     if ( !bFirst ||
822          ( rpFrm->IsTabFrm() && bLongTab )
823        )
824     {
825         sal_uLong nRowCount = 0;
826         do
827         {
828             if( pImpl || bLongTab )
829             {
830 #if OSL_DEBUG_LEVEL > 1
831                 sal_uLong nBrkIndex = ( pImpl && nIndex < pImpl->Count() ) ?
832                         pImpl->GetBreakIndex(nIndex) : 0xffff;
833                 (void)nBrkIndex;
834 #endif
835                 xub_StrLen nOfst = STRING_LEN;
836                 sal_uInt16 nType = SW_LAYCACHE_IO_REC_PAGES;
837                 if( bLongTab )
838                 {
839                     rbBreakAfter = sal_True;
840                     nOfst = static_cast<xub_StrLen>(nRowCount + nMaxRowPerPage);
841                 }
842                 else
843                 {
844                     while( nIndex < pImpl->Count() &&
845                            pImpl->GetBreakIndex(nIndex) < nNodeIndex)
846                         ++nIndex;
847                     if( nIndex < pImpl->Count() &&
848                         pImpl->GetBreakIndex(nIndex) == nNodeIndex )
849                     {
850                         nType = pImpl->GetBreakType( nIndex );
851                         nOfst = pImpl->GetBreakOfst( nIndex++ );
852                         rbBreakAfter = sal_True;
853                     }
854                 }
855 
856                 if( nOfst < STRING_LEN )
857                 {
858                     sal_Bool bSplit = sal_False;
859                     sal_uInt16 nRepeat( 0 );
860                     if( !bLongTab && rpFrm->IsTxtFrm() &&
861                         SW_LAYCACHE_IO_REC_PARA == nType &&
862                         nOfst<((SwTxtFrm*)rpFrm)->GetTxtNode()->GetTxt().Len() )
863                         bSplit = sal_True;
864                     else if( rpFrm->IsTabFrm() && nRowCount < nOfst &&
865                              ( bLongTab || SW_LAYCACHE_IO_REC_TABLE == nType ) )
866                     {
867                         nRepeat = ((SwTabFrm*)rpFrm)->
868                                   GetTable()->GetRowsToRepeat();
869                         bSplit = nOfst < nRows && nRowCount + nRepeat < nOfst;
870                         bLongTab = bLongTab && bSplit;
871                     }
872                     if( bSplit )
873                     {
874                         rpFrm->InsertBehind( rpLay, rpPrv );
875                         rpFrm->Frm().Pos() = rpLay->Frm().Pos();
876                         rpFrm->Frm().Pos().Y() += 1;
877                         rpPrv = rpFrm;
878                         if( rpFrm->IsTabFrm() )
879                         {
880                             SwTabFrm* pTab = (SwTabFrm*)rpFrm;
881                             // --> OD 2004-09-23 #i33629#, #i29955#
882                             ::RegistFlys( pTab->FindPageFrm(), pTab );
883                             // <--
884                             SwFrm *pRow = pTab->Lower();
885                             SwTabFrm *pFoll = new SwTabFrm( *pTab );
886 
887                             SwFrm *pPrv;
888                             if( nRepeat > 0 )
889                             {
890                                 bDontCreateObjects = sal_True; //frmtool
891 
892                                 // Insert new headlines:
893                                 sal_uInt16 nRowIdx = 0;
894                                 SwRowFrm* pHeadline = 0;
895                                 while( nRowIdx < nRepeat )
896                                 {
897                                     ASSERT( pTab->GetTable()->GetTabLines()[ nRowIdx ], "Table ohne Zeilen?" );
898                                     pHeadline =
899                                         new SwRowFrm( *pTab->GetTable()->GetTabLines()[ nRowIdx ], pTab );
900                                     pHeadline->SetRepeatedHeadline( true );
901                                     pHeadline->InsertBefore( pFoll, 0 );
902                                     pHeadline->RegistFlys();
903 
904                                     ++nRowIdx;
905                                 }
906 
907                                 bDontCreateObjects = sal_False;
908                                 pPrv = pHeadline;
909                                 nRows = nRows + nRepeat;
910                             }
911                             else
912                                 pPrv = 0;
913                             while( pRow && nRowCount < nOfst )
914                             {
915                                 pRow = pRow->GetNext();
916                                 ++nRowCount;
917                             }
918                             while ( pRow )
919                             {
920                                 SwFrm* pNxt = pRow->GetNext();
921                                 pRow->Remove();
922                                 pRow->InsertBehind( pFoll, pPrv );
923                                 pPrv = pRow;
924                                 pRow = pNxt;
925                             }
926                             rpFrm = pFoll;
927                         }
928                         else
929                         {
930                             SwTxtFrm *pNew = new SwTxtFrm( ((SwTxtFrm*)rpFrm)->
931                                                             GetTxtNode(), rpFrm );
932                             pNew->_SetIsFollow( sal_True );
933                             pNew->ManipOfst( nOfst );
934                             pNew->SetFollow( ((SwTxtFrm*)rpFrm)->GetFollow() );
935                             ((SwTxtFrm*)rpFrm)->SetFollow( pNew );
936                             rpFrm = pNew;
937                         }
938                     }
939                 }
940             }
941 
942             SwPageFrm* pLastPage = rpPage;
943             if( CheckInsertPage() )
944             {
945                 // --> OD 2006-03-21 #b6375613#
946                 if ( pDoc->ApplyWorkaroundForB6375613() )
947                 {
948                     lcl_ApplyWorkaroundForB6375613( rpFrm );
949                 }
950                 // <--
951                 _CheckFlyCache( pLastPage );
952                 if( rpPrv && rpPrv->IsTxtFrm() && !rpPrv->GetValidSizeFlag() )
953                     rpPrv->Frm().Height( rpPrv->GetUpper()->Prt().Height() );
954 
955                 bRet = sal_True;
956                 rpPrv = 0;
957                 nParagraphCnt = 0;
958 
959                 if ( rpActualSection )
960                 {
961                     //Hatte der SectionFrm ueberhaupt Inhalt? Wenn
962                     //nicht kann er gleich umgehaengt werden.
963                     SwSectionFrm *pSct;
964                     bool bInit = false;
965                     if ( !rpActualSection->GetSectionFrm()->ContainsCntnt())
966                     {
967                         pSct = rpActualSection->GetSectionFrm();
968                         pSct->Remove();
969                     }
970                     else
971                     {
972                         pSct = new SwSectionFrm(
973                             *rpActualSection->GetSectionFrm(), sal_False );
974                         rpActualSection->GetSectionFrm()->SimpleFormat();
975                         bInit = true;
976                     }
977                     rpActualSection->SetSectionFrm( pSct );
978                     pSct->InsertBehind( rpLay, 0 );
979                     if( bInit )
980                         pSct->Init();
981                     pSct->Frm().Pos() = rpLay->Frm().Pos();
982                     pSct->Frm().Pos().Y() += 1; //wg. Benachrichtigungen.
983 
984                     rpLay = pSct;
985                     if ( rpLay->Lower() && rpLay->Lower()->IsLayoutFrm() )
986                         rpLay = rpLay->GetNextLayoutLeaf();
987                 }
988             }
989         } while( bLongTab || ( pImpl && nIndex < pImpl->Count() &&
990                  (*pImpl)[ nIndex ] == nNodeIndex ) );
991     }
992     bFirst = sal_False;
993     return bRet;
994 }
995 
996 struct SdrObjectCompare
997 {
operator ()SdrObjectCompare998   bool operator()( const SdrObject* pF1, const SdrObject* pF2 ) const
999   {
1000     return pF1->GetOrdNum() < pF2->GetOrdNum();
1001   }
1002 };
1003 
1004 struct FlyCacheCompare
1005 {
operator ()FlyCacheCompare1006   bool operator()( const SwFlyCache* pC1, const SwFlyCache* pC2 ) const
1007   {
1008     return pC1->nOrdNum < pC2->nOrdNum;
1009   }
1010 };
1011 
1012  /*-----------------28.6.2001 14:40------------------
1013   * SwLayHelper::_CheckFlyCache(..)
1014   * If a new page is inserted, the last page is analysed.
1015   * If there are text frames with default position, the fly cache
1016   * is checked, if these frames are stored in the cache.
1017   * --------------------------------------------------*/
1018 
_CheckFlyCache(SwPageFrm * pPage)1019 void SwLayHelper::_CheckFlyCache( SwPageFrm* pPage )
1020 {
1021     if( !pImpl || !pPage )
1022         return;
1023     sal_uInt16 nFlyCount = pImpl->GetFlyCount();
1024     // Any text frames at the page, fly cache avaiable?
1025     if( pPage->GetSortedObjs() && nFlyIdx < nFlyCount )
1026     {
1027         SwSortedObjs &rObjs = *pPage->GetSortedObjs();
1028         sal_uInt16 nPgNum = pPage->GetPhyPageNum();
1029 
1030 /*
1031 
1032         //
1033         // NOTE: This code assumes that all objects have already been
1034         // inserted into the drawing layout, so that the cached objects
1035         // can be identified by their ordnum. Unfortunately this function
1036         // is called with page n if page n+1 has been inserted. Thus
1037         // not all the objects have been inserted and the ordnums cannot
1038         // be used to identify the objects.
1039         //
1040 
1041         for ( sal_uInt16 i = 0; i < rObjs.Count(); ++i )  // check objects
1042         {
1043             SdrObject *pO = rObjs[i];
1044             if ( pO->ISA(SwVirtFlyDrawObj) )  // a text frame?
1045             {
1046                 SwFlyFrm *pFly = ((SwVirtFlyDrawObj*)pO)->GetFlyFrm();
1047                 if( pFly->Frm().Left() == WEIT_WECH && pFly->GetAnchor() &&
1048                     !pFly->GetAnchor()->FindFooterOrHeader() )
1049                 {   // Only frame with default position and not in header/footer
1050                     const SwContact *pC = (SwContact*)GetUserCall(pO);
1051                     if( pC )
1052                     {
1053                         sal_uLong nOrdNum = pO->GetOrdNum(); // the Id
1054                         SwFlyCache* pFlyC;
1055                         while( nFlyIdx < nFlyCount && ( pFlyC = pImpl->
1056                                GetFlyCache(nFlyIdx) )->nPageNum < nPgNum)
1057                             ++nFlyIdx;
1058                         if( nFlyIdx < nFlyCount &&
1059                             pFlyC->nPageNum == nPgNum )
1060                         {
1061                             sal_uInt16 nIdx = nFlyIdx;
1062                             while( nIdx < nFlyCount && ( pFlyC = pImpl->
1063                                    GetFlyCache( nIdx ) )->nPageNum == nPgNum &&
1064                                    pFlyC->nOrdNum != nOrdNum )
1065                                 ++nIdx;
1066                             if( nIdx < nFlyCount && pFlyC->nPageNum == nPgNum &&
1067                                 pFlyC->nOrdNum == nOrdNum )
1068                             {   // we get the stored information
1069                                 pFly->Frm().Pos().X() = pFlyC->Left() +
1070                                                         pPage->Frm().Left();
1071                                 pFly->Frm().Pos().Y() = pFlyC->Top() +
1072                                                         pPage->Frm().Top();
1073                                 pFly->Frm().Width( pFlyC->Width() );
1074                                 pFly->Frm().Height( pFlyC->Height() );
1075                             }
1076                         }
1077                     }
1078                 }
1079             }
1080         }
1081  */
1082 
1083         //
1084         // NOTE: Here we do not use the absolute ordnums but
1085         // relative ordnums for the objects on this page.
1086 
1087         // skip fly frames from pages before the current page
1088         SwFlyCache* pFlyC;
1089         while( nFlyIdx < nFlyCount && ( pFlyC = pImpl->
1090                GetFlyCache(nFlyIdx) )->nPageNum < nPgNum)
1091             ++nFlyIdx;
1092 
1093         // sort cached objects on this page by ordnum
1094         std::set< const SwFlyCache*, FlyCacheCompare > aFlyCacheSet;
1095         sal_uInt16 nIdx = nFlyIdx;
1096 
1097         while( nIdx < nFlyCount && ( pFlyC = pImpl->
1098                GetFlyCache( nIdx ) )->nPageNum == nPgNum )
1099         {
1100             aFlyCacheSet.insert( pFlyC );
1101             ++nIdx;
1102         }
1103 
1104         // sort objects on this page by ordnum
1105         std::set< const SdrObject*, SdrObjectCompare > aFlySet;
1106         for ( sal_uInt16 i = 0; i < rObjs.Count(); ++i )
1107         {
1108             SwAnchoredObject* pAnchoredObj = rObjs[i];
1109             if ( pAnchoredObj->ISA(SwFlyFrm) )  // a text frame?
1110             {
1111                 SwFlyFrm *pFly = static_cast<SwFlyFrm*>(pAnchoredObj);
1112                 if( pFly->GetAnchorFrm() &&
1113                     !pFly->GetAnchorFrm()->FindFooterOrHeader() )
1114                 {
1115                     const SwContact *pC = ::GetUserCall( pAnchoredObj->GetDrawObj() );
1116                     if( pC )
1117                     {
1118                         aFlySet.insert( pAnchoredObj->GetDrawObj() );
1119                     }
1120                 }
1121             }
1122         }
1123 
1124         if ( aFlyCacheSet.size() == aFlySet.size() )
1125         {
1126             std::set< const SwFlyCache*, FlyCacheCompare >::iterator aFlyCacheSetIt =
1127                     aFlyCacheSet.begin();
1128             std::set< const SdrObject*, SdrObjectCompare >::iterator aFlySetIt =
1129                     aFlySet.begin();
1130 
1131             while ( aFlyCacheSetIt != aFlyCacheSet.end() )
1132             {
1133                 const SwFlyCache* pFlyCache = *aFlyCacheSetIt;
1134                 SwFlyFrm* pFly = ((SwVirtFlyDrawObj*)*aFlySetIt)->GetFlyFrm();
1135 
1136                 if ( pFly->Frm().Left() == WEIT_WECH )
1137                 {
1138                     // we get the stored information
1139                     pFly->Frm().Pos().X() = pFlyCache->Left() +
1140                                             pPage->Frm().Left();
1141                     pFly->Frm().Pos().Y() = pFlyCache->Top() +
1142                                             pPage->Frm().Top();
1143                     if ( pImpl->IsUseFlyCache() )
1144                     {
1145                         pFly->Frm().Width( pFlyCache->Width() );
1146                         pFly->Frm().Height( pFlyCache->Height() );
1147                     }
1148                 }
1149 
1150                 ++aFlyCacheSetIt;
1151                 ++aFlySetIt;
1152             }
1153         }
1154     }
1155 }
1156 
1157 /*-----------------28.6.2001 14:48------------------
1158  * SwLayHelper::CheckPageFlyCache(..)
1159  * looks for the given text frame in the fly cache and sets
1160  * the position and size, if possible.
1161  * The fly cache is sorted by pages and we start searching with the given page.
1162  * If we found the page number in the fly cache, we set
1163  * the rpPage parameter to the right page, if possible.
1164  * --------------------------------------------------*/
1165 
CheckPageFlyCache(SwPageFrm * & rpPage,SwFlyFrm * pFly)1166 sal_Bool SwLayHelper::CheckPageFlyCache( SwPageFrm* &rpPage, SwFlyFrm* pFly )
1167 {
1168     if( !pFly->GetAnchorFrm() || !pFly->GetVirtDrawObj() ||
1169         pFly->GetAnchorFrm()->FindFooterOrHeader() )
1170         return sal_False;
1171     sal_Bool bRet = sal_False;
1172     SwDoc* pDoc = rpPage->GetFmt()->GetDoc();
1173     SwLayCacheImpl *pCache = pDoc->GetLayoutCache() ?
1174                              pDoc->GetLayoutCache()->LockImpl() : NULL;
1175     if( pCache )
1176     {
1177         sal_uInt16 nPgNum = rpPage->GetPhyPageNum();
1178         sal_uInt16 nIdx = 0;
1179         sal_uInt16 nCnt = pCache->GetFlyCount();
1180         sal_uLong nOrdNum = pFly->GetVirtDrawObj()->GetOrdNum();
1181         SwFlyCache* pFlyC = 0;
1182 
1183         // skip fly frames from pages before the current page
1184         while( nIdx < nCnt &&
1185                nPgNum > (pFlyC = pCache->GetFlyCache( nIdx ))->nPageNum )
1186             ++nIdx;
1187 
1188         while( nIdx < nCnt &&
1189                nOrdNum != (pFlyC = pCache->GetFlyCache( nIdx ))->nOrdNum )
1190             ++nIdx;
1191         if( nIdx < nCnt )
1192         {
1193             SwPageFrm *pPage = rpPage;
1194             while( pPage && pPage->GetPhyPageNum() < pFlyC->nPageNum )
1195                 pPage = (SwPageFrm*)pPage->GetNext();
1196             // --> OD 2005-02-22 #i43266# - if the found page is an empty page,
1197             // take the previous one (take next one, if previous one doesn't exists)
1198             if ( pPage && pPage->IsEmptyPage() )
1199             {
1200                 pPage = static_cast<SwPageFrm*>( pPage->GetPrev()
1201                                                  ? pPage->GetPrev()
1202                                                  : pPage->GetNext() );
1203             }
1204             // <--
1205             if( pPage )
1206             {
1207                 rpPage = pPage;
1208                 pFly->Frm().Pos().X() = pFlyC->Left() + pPage->Frm().Left();
1209                 pFly->Frm().Pos().Y() = pFlyC->Top() + pPage->Frm().Top();
1210                 if ( pCache->IsUseFlyCache() )
1211                 {
1212                     pFly->Frm().Width( pFlyC->Width() );
1213                     pFly->Frm().Height( pFlyC->Height() );
1214                 }
1215                 bRet = sal_True;
1216             }
1217         }
1218         pDoc->GetLayoutCache()->UnlockImpl();
1219     }
1220     return bRet;
1221 }
1222 
1223 // -----------------------------------------------------------------------------
1224 
SwLayCacheIoImpl(SvStream & rStrm,sal_Bool bWrtMd)1225 SwLayCacheIoImpl::SwLayCacheIoImpl( SvStream& rStrm, sal_Bool bWrtMd ) :
1226 	pStream( &rStrm ),
1227 	nMajorVersion(SW_LAYCACHE_IO_VERSION_MAJOR),
1228 	nMinorVersion(SW_LAYCACHE_IO_VERSION_MINOR),
1229 	bWriteMode( bWrtMd ),
1230 	bError( sal_False  )
1231 {
1232 	if( bWriteMode )
1233 		*pStream << nMajorVersion
1234 				 <<	nMinorVersion;
1235 
1236 	else
1237 		*pStream >> nMajorVersion
1238 				 >>	nMinorVersion;
1239 }
1240 
OpenRec(sal_uInt8 cType)1241 sal_Bool SwLayCacheIoImpl::OpenRec( sal_uInt8 cType )
1242 {
1243 	sal_Bool bRes = sal_True;
1244 	size_t nLvl = aRecTypes.size();
1245 	ASSERT( nLvl == aRecSizes.Count(), "OpenRec: Level" );
1246 	sal_uInt32 nPos = pStream->Tell();
1247 	if( bWriteMode )
1248 	{
1249 		aRecTypes.push_back( cType );
1250 		aRecSizes.Insert( nPos, nLvl );
1251 		*pStream << (sal_uInt32) 0;
1252 	}
1253 	else
1254 	{
1255 		sal_uInt32 nVal;
1256 		*pStream >> nVal;
1257 		sal_uInt8 cRecTyp = (sal_uInt8)nVal;
1258 		aRecTypes.push_back( cRecTyp );
1259 		sal_uInt32 nSize = nVal >> 8;
1260 		aRecSizes.Insert( nPos + nSize, nLvl );
1261 		if( !nVal || cRecTyp != cType ||
1262 			pStream->GetErrorCode() != SVSTREAM_OK || pStream->IsEof() )
1263 		{
1264 			ASSERT( nVal, "OpenRec: Record-Header is 0" );
1265 			ASSERT( cRecTyp == cType,
1266 					"OpenRec: Wrong Record Type" );
1267 			aRecTypes.back() = 0;
1268 			aRecSizes[nLvl] = pStream->Tell();
1269 			bRes = sal_False;
1270 			bError = sal_True;
1271 		}
1272 	}
1273 	return bRes;
1274 }
1275 
1276 // Close record
1277 
CloseRec(sal_uInt8)1278 sal_Bool SwLayCacheIoImpl::CloseRec( sal_uInt8 )
1279 {
1280 	sal_Bool bRes = sal_True;
1281 	size_t nLvl = aRecTypes.size();
1282 	ASSERT( nLvl == aRecSizes.Count(), "CloseRec: wrong Level" );
1283 	ASSERT( nLvl, "CloseRec: no levels" );
1284 	if( nLvl )
1285 	{
1286 		nLvl--;
1287 		sal_uInt32 nPos = pStream->Tell();
1288 		if( bWriteMode )
1289 		{
1290 			sal_uInt32 nBgn = aRecSizes[nLvl];
1291 			pStream->Seek( nBgn );
1292 			sal_uInt32 nSize = nPos - nBgn;
1293 			sal_uInt32 nVal = ( nSize << 8 ) | aRecTypes.back();
1294 			*pStream << nVal;
1295 			pStream->Seek( nPos );
1296 			if( pStream->GetError() != SVSTREAM_OK )
1297 			 	bRes = sal_False;
1298 		}
1299 		else
1300 		{
1301 			sal_uInt32 n = aRecSizes[nLvl];
1302 			ASSERT( n >= nPos, "CloseRec: to much data read" );
1303 			if( n != nPos )
1304 			{
1305 				pStream->Seek( n );
1306 				if( n < nPos )
1307 				 	bRes = sal_False;
1308 			}
1309 			if( pStream->GetErrorCode() != SVSTREAM_OK )
1310 				bRes = sal_False;
1311 		}
1312 
1313 		aRecTypes.pop_back();
1314 		aRecSizes.Remove( nLvl, 1 );
1315 	}
1316 
1317 	if( !bRes )
1318 		bError = sal_True;
1319 
1320 	return bRes;
1321 }
1322 
BytesLeft()1323 sal_uInt32 SwLayCacheIoImpl::BytesLeft()
1324 {
1325 	sal_uInt16 nLvl = aRecSizes.Count();
1326 	sal_uInt32 n = 0;
1327 	if( !bError && nLvl )
1328 	{
1329 		sal_uInt32 nEndPos = aRecSizes[ nLvl-1 ];
1330 		sal_uInt32 nPos = pStream->Tell();
1331 		if( nEndPos > nPos )
1332 			n = nEndPos - nPos;
1333 	}
1334 
1335 	return n;
1336 }
1337 
Peek()1338 sal_uInt8 SwLayCacheIoImpl::Peek()
1339 {
1340 	sal_uInt8 c = 0;
1341 	if( !bError )
1342 	{
1343 		sal_uInt32 nPos = pStream->Tell();
1344 		*pStream >> c;
1345 		pStream->Seek( nPos );
1346 		if( pStream->GetErrorCode() != SVSTREAM_OK )
1347 		{
1348 			c = 0;
1349 			bError = sal_True;
1350 		}
1351 	}
1352 	return c;
1353 }
1354 
SkipRec()1355 void SwLayCacheIoImpl::SkipRec()
1356 {
1357 	sal_uInt8 c = Peek();
1358 	OpenRec( c );
1359 	pStream->Seek( aRecSizes[aRecSizes.Count()-1] );
1360 	CloseRec( c );
1361 }
1362 
OpenFlagRec()1363 sal_uInt8 SwLayCacheIoImpl::OpenFlagRec()
1364 {
1365 	ASSERT( !bWriteMode, "OpenFlagRec illegal in write  mode" );
1366 	sal_uInt8 cFlags;
1367 	*pStream >> cFlags;
1368 	nFlagRecEnd = pStream->Tell() + ( cFlags & 0x0F );
1369 	return (cFlags >> 4);
1370 }
1371 
OpenFlagRec(sal_uInt8 nFlags,sal_uInt8 nLen)1372 void SwLayCacheIoImpl::OpenFlagRec( sal_uInt8 nFlags, sal_uInt8 nLen )
1373 {
1374 	ASSERT( bWriteMode, "OpenFlagRec illegal in read  mode" );
1375 	ASSERT( (nFlags & 0xF0) == 0, "illegal flags set" );
1376 	ASSERT( nLen < 16, "wrong flag record length" );
1377 	sal_uInt8 cFlags = (nFlags << 4) + nLen;
1378 	*pStream << cFlags;
1379 	nFlagRecEnd = pStream->Tell() + nLen;
1380 }
1381 
CloseFlagRec()1382 void SwLayCacheIoImpl::CloseFlagRec()
1383 {
1384 	if( bWriteMode )
1385 	{
1386 		ASSERT( pStream->Tell() == nFlagRecEnd, "Wrong amount of data written" );
1387 	}
1388 	else
1389 	{
1390 		ASSERT( pStream->Tell() <= nFlagRecEnd, "To many data read" );
1391 		if( pStream->Tell() != nFlagRecEnd )
1392 			pStream->Seek( nFlagRecEnd );
1393 	}
1394 }
1395