?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / sw / source / core / layout / ftnfrm.cxx
blobbe92d50f6a8c9d8281d75e8332c2377ff27bdab4
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: ftnfrm.cxx,v $
10 * $Revision: 1.36 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sw.hxx"
33
34
35 #include <txtftn.hxx>
36 #include <fmtftn.hxx>
37 #include <ftnidx.hxx>
38 #include <pagefrm.hxx>
39 #include <colfrm.hxx>
40 #include <rootfrm.hxx>
41 #include <cntfrm.hxx>
42 #include <doc.hxx>
43 #include <ndtxt.hxx>
44 #include <frmtool.hxx>
45 #include <swtable.hxx>
46 #include <ftnfrm.hxx>
47 #include <txtfrm.hxx>
48 #include <tabfrm.hxx>
49 #include <pagedesc.hxx>
50 #include <ftninfo.hxx>
51 #include <ndindex.hxx>
52 #include <sectfrm.hxx>
53 #include <pam.hxx>
54 // --> OD 2005-05-17 #i49383#
55 #include <objectformatter.hxx>
56 // <--
57
58 /*************************************************************************
59 |*
60 |* lcl_FindFtnPos() Sucht die Position des Attributes im FtnArray am
61 |* Dokument, dort stehen die Fussnoten gluecklicherweise nach ihrem
62 |* Index sortiert.
63 |*
64 |* Ersterstellung MA 29. Jun. 93
65 |* Letzte Aenderung MA 13. Dec. 93
66 |*
67 |*************************************************************************/
68
69 #define ENDNOTE 0x80000000
70
71 ULONG MA_FASTCALL lcl_FindFtnPos( const SwDoc *pDoc, const SwTxtFtn *pAttr )
72 {
73 const SwFtnIdxs &rFtnIdxs = pDoc->GetFtnIdxs();
74
75 #ifdef MA_DEBUG
76 //Wenn das Array nicht stimmt haben wir ein Problem, denn viele
77 //Ftn-Functions bauen auf dem Array auf.
78 for ( USHORT k = 0; k+1 < rFtnIdxs.Count(); ++k )
79 {
80 SwIndex aIdx1(&pDoc->GetNodes());
81 SwIndex aIdx2(&pDoc->GetNodes());
82 rFtnIdxs[k]->pFtn-> GetTxtNode().GetIndex(aIdx1);
83 rFtnIdxs[k+1]->pFtn->GetTxtNode().GetIndex(aIdx2);
84 if ( aIdx1.GetIndex() > aIdx2.GetIndex() )
85 {
86 ASSERT( !rFtnIdxs.Count(), "FtnIdxs not up to date" );
87 }
88 else if ( aIdx1.GetIndex() == aIdx2.GetIndex() )
89 {
90 SwTxtFtn *p1 = rFtnIdxs[k];
91 SwTxtFtn *p2 = rFtnIdxs[k+1];
92 ASSERT( *p1->GetStart() < *p2->GetStart(),
93 "FtnIdxs not up to date" );
94 }
95 }
96 #endif
97
98 USHORT nRet;
99 SwTxtFtnPtr pBla = (SwTxtFtn*)pAttr;
100 if ( rFtnIdxs.Seek_Entry( pBla, &nRet ) )
101 {
102 if( pAttr->GetFtn().IsEndNote() )
103 return ULONG(nRet) + ENDNOTE;
104 return nRet;
105 }
106 ASSERT( !pDoc, "FtnPos not found." );
107 return 0;
108 }
109
110 BOOL SwFtnFrm::operator<( const SwTxtFtn* pTxtFtn ) const
111 {
112 const SwDoc* pDoc = GetFmt()->GetDoc();
113 ASSERT( pDoc, "SwFtnFrm: Missing doc!" );
114 return lcl_FindFtnPos( pDoc, GetAttr() ) <
115 lcl_FindFtnPos( pDoc, pTxtFtn );
116 }
117
118 /*************************************************************************
119 |*
120 |* BOOL lcl_NextFtnBoss( SwFtnBossFrm* pBoss, SwPageFrm* pPage)
121 |* setzt pBoss auf den naechsten SwFtnBossFrm, das kann entweder eine Spalte
122 |* oder eine Seite (ohne Spalten) sein. Wenn die Seite dabei gewechselt wird
123 |* enthaelt pPage die neue Seite und die Funktion liefert TRUE.
124 |*
125 |* Ersterstellung AMA 06. Nov. 98
126 |* Letzte Aenderung AMA 06. Nov. 98
127 |*
128 |*************************************************************************/
129
130 BOOL lcl_NextFtnBoss( SwFtnBossFrm* &rpBoss, SwPageFrm* &rpPage,
131 BOOL bDontLeave )
132 {
133 if( rpBoss->IsColumnFrm() )
134 {
135 if( rpBoss->GetNext() )
136 {
137 rpBoss = (SwFtnBossFrm*)rpBoss->GetNext(); //naechste Spalte
138 return FALSE;
139 }
140 if( rpBoss->IsInSct() )
141 {
142 SwSectionFrm* pSct = rpBoss->FindSctFrm()->GetFollow();
143 if( pSct )
144 {
145 ASSERT( pSct->Lower() && pSct->Lower()->IsColumnFrm(),
146 "Where's the column?" );
147 rpBoss = (SwColumnFrm*)pSct->Lower();
148 SwPageFrm* pOld = rpPage;
149 rpPage = pSct->FindPageFrm();
150 return pOld != rpPage;
151 }
152 else if( bDontLeave )
153 {
154 rpPage = NULL;
155 rpBoss = NULL;
156 return FALSE;
157 }
158 }
159 }
160 rpPage = (SwPageFrm*)rpPage->GetNext(); // naechste Seite
161 rpBoss = rpPage;
162 if( rpPage )
163 {
164 SwLayoutFrm* pBody = rpPage->FindBodyCont();
165 if( pBody && pBody->Lower() && pBody->Lower()->IsColumnFrm() )
166 rpBoss = (SwFtnBossFrm*)pBody->Lower(); // erste Spalte
167 }
168 return TRUE;
169 }
170
171 /*************************************************************************
172 |*
173 |* USHORT lcl_ColumnNum( SwFrm* pBoss )
174 |* liefert die Spaltennummer, wenn pBoss eine Spalte ist,
175 |* sonst eine Null (bei Seiten).
176 |*
177 |* Ersterstellung AMA 06. Nov. 98
178 |* Letzte Aenderung AMA 06. Nov. 98
179 |*
180 |*************************************************************************/
181
182 USHORT lcl_ColumnNum( const SwFrm* pBoss )
183 {
184 USHORT nRet = 0;
185 if( !pBoss->IsColumnFrm() )
186 return 0;
187 const SwFrm* pCol;
188 if( pBoss->IsInSct() )
189 {
190 pCol = pBoss->GetUpper()->FindColFrm();
191 if( pBoss->GetNext() || pBoss->GetPrev() )
192 {
193 while( pBoss )
194 {
195 ++nRet; // Section columns
196 pBoss = pBoss->GetPrev();
197 }
198 }
199 }
200 else
201 pCol = pBoss;
202 while( pCol )
203 {
204 nRet += 256; // Page columns
205 pCol = pCol->GetPrev();
206 }
207 return nRet;
208 }
209
210 /*************************************************************************
211 |*
212 |* SwFtnContFrm::SwFtnContFrm()
213 |*
214 |* Ersterstellung MA 24. Feb. 93
215 |* Letzte Aenderung MA 02. Mar. 93
216 |*
217 |*************************************************************************/
218
219
220 SwFtnContFrm::SwFtnContFrm( SwFrmFmt *pFmt ):
221 SwLayoutFrm( pFmt )
222 {
223 nType = FRMC_FTNCONT;
224 }
225
226
227 // lcl_Undersize(..) klappert einen SwFrm und dessen Inneres ab
228 // und liefert die Summe aller TxtFrm-Vergroesserungswuensche
229
230 long lcl_Undersize( const SwFrm* pFrm )
231 {
232 long nRet = 0;
233 SWRECTFN( pFrm )
234 if( pFrm->IsTxtFrm() )
235 {
236 if( ((SwTxtFrm*)pFrm)->IsUndersized() )
237 {
238 // Dieser TxtFrm waere gern ein bisschen groesser
239 nRet = ((SwTxtFrm*)pFrm)->GetParHeight() -
240 (pFrm->Prt().*fnRect->fnGetHeight)();
241 if( nRet < 0 )
242 nRet = 0;
243 }
244 }
245 else if( pFrm->IsLayoutFrm() )
246 {
247 const SwFrm* pNxt = ((SwLayoutFrm*)pFrm)->Lower();
248 while( pNxt )
249 {
250 nRet += lcl_Undersize( pNxt );
251 pNxt = pNxt->GetNext();
252 }
253 }
254 return nRet;
255 }
256
257 /*************************************************************************
258 |*
259 |* SwFtnContFrm::Format()
260 |*
261 |* Beschreibung: "Formatiert" den Frame;
262 |* Die Fixsize wird hier nicht eingestellt.
263 |* Ersterstellung MA 01. Mar. 93
264 |* Letzte Aenderung MA 17. Nov. 98
265 |*
266 |*************************************************************************/
267
268
269 void SwFtnContFrm::Format( const SwBorderAttrs * )
270 {
271 //GesamtBorder ermitteln, es gibt nur einen Abstand nach oben.
272 const SwPageFrm* pPage = FindPageFrm();
273 const SwPageFtnInfo &rInf = pPage->GetPageDesc()->GetFtnInfo();
274 const SwTwips nBorder = rInf.GetTopDist() + rInf.GetBottomDist() +
275 rInf.GetLineWidth();
276 SWRECTFN( this )
277 if ( !bValidPrtArea )
278 {
279 bValidPrtArea = TRUE;
280 (Prt().*fnRect->fnSetTop)( nBorder );
281 (Prt().*fnRect->fnSetWidth)( (Frm().*fnRect->fnGetWidth)() );
282 (Prt().*fnRect->fnSetHeight)((Frm().*fnRect->fnGetHeight)() - nBorder );
283 if( (Prt().*fnRect->fnGetHeight)() < 0 && !pPage->IsFtnPage() )
284 bValidSize = FALSE;
285 }
286
287 if ( !bValidSize )
288 {
289 if ( pPage->IsFtnPage() && !GetFmt()->getIDocumentSettingAccess()->get(IDocumentSettingAccess::BROWSE_MODE) )
290 Grow( LONG_MAX, FALSE );
291 else
292 {
293 //Die Groesse in der VarSize wird durch den Inhalt plus den
294 //Raendern bestimmt.
295 SwTwips nRemaining = 0;
296 SwFrm *pFrm = pLower;
297 while ( pFrm )
298 { // lcl_Undersize(..) beruecksichtigt (rekursiv) TxtFrms, die gerne
299 // groesser waeren. Diese entstehen insbesondere in spaltigen Rahmen,
300 // wenn diese noch nicht ihre maximale Groesse haben.
301 nRemaining += (pFrm->Frm().*fnRect->fnGetHeight)()
302 + lcl_Undersize( pFrm );
303 pFrm = pFrm->GetNext();
304 }
305 //Jetzt noch den Rand addieren
306 nRemaining += nBorder;
307
308 SwTwips nDiff;
309 if( IsInSct() )
310 {
311 nDiff = -(Frm().*fnRect->fnBottomDist)(
312 (GetUpper()->*fnRect->fnGetPrtBottom)() );
313 if( nDiff > 0 )
314 {
315 if( nDiff > (Frm().*fnRect->fnGetHeight)() )
316 nDiff = (Frm().*fnRect->fnGetHeight)();
317 (Frm().*fnRect->fnAddBottom)( -nDiff );
318 (Prt().*fnRect->fnAddHeight)( -nDiff );
319 }
320 }
321 nDiff = (Frm().*fnRect->fnGetHeight)() - nRemaining;
322 if ( nDiff > 0 )
323 Shrink( nDiff );
324 else if ( nDiff < 0 )
325 {
326 Grow( -nDiff );
327 //Es kann passieren, dass weniger Platz zur Verfuegung steht,
328 //als der bereits der Border benoetigt - die Groesse der
329 //PrtArea wird dann negativ.
330 SwTwips nPrtHeight = (Prt().*fnRect->fnGetHeight)();
331 if( nPrtHeight < 0 )
332 {
333 const SwTwips nTmpDiff = Max( (Prt().*fnRect->fnGetTop)(),
334 -nPrtHeight );
335 (Prt().*fnRect->fnSubTop)( nTmpDiff );
336 }
337 }
338 }
339 bValidSize = TRUE;
340 }
341 }
342 /*************************************************************************
343 |*
344 |* SwFtnContFrm::GrowFrm(), ShrinkFrm()
345 |*
346 |* Ersterstellung MA 24. Feb. 93
347 |* Letzte Aenderung AMA 05. Nov. 98
348 |*
349 |*************************************************************************/
350
351 SwTwips SwFtnContFrm::GrowFrm( SwTwips nDist, BOOL bTst, BOOL )
352 {
353 //Keine Pruefung ob FixSize oder nicht, die FtnContainer sind immer bis
354 //zur Maximalhoehe variabel.
355 //Wenn die Maximalhoehe LONG_MAX ist, so nehmen wir uns soviel Platz wie eben
356 //moeglich.
357 //Wenn die Seite eine spezielle Fussnotenseite ist, so nehmen wir uns auch
358 //soviel Platz wie eben moeglich.
359 #ifndef PRODUCT
360 if ( !GetUpper() || !GetUpper()->IsFtnBossFrm() )
361 { ASSERT( !this, "Keine FtnBoss." );
362 return 0;
363 }
364 #endif
365
366 SWRECTFN( this )
367 if( (Frm().*fnRect->fnGetHeight)() > 0 &&
368 nDist > ( LONG_MAX - (Frm().*fnRect->fnGetHeight)() ) )
369 nDist = LONG_MAX - (Frm().*fnRect->fnGetHeight)();
370
371 SwFtnBossFrm *pBoss = (SwFtnBossFrm*)GetUpper();
372 if( IsInSct() )
373 {
374 SwSectionFrm* pSect = FindSctFrm();
375 ASSERT( pSect, "GrowFrm: Missing SectFrm" );
376 // In a section, which has to maximize, a footnotecontainer is allowed
377 // to grow, when the section can't grow anymore.
378 if( !bTst && !pSect->IsColLocked() &&
379 pSect->ToMaximize( FALSE ) && pSect->Growable() )
380 {
381 pSect->InvalidateSize();
382 return 0;
383 }
384 }
385 const bool bBrowseMode = GetFmt()->getIDocumentSettingAccess()->get(IDocumentSettingAccess::BROWSE_MODE);
386 SwPageFrm *pPage = pBoss->FindPageFrm();
387 if ( bBrowseMode || !pPage->IsFtnPage() )
388 {
389 if ( pBoss->GetMaxFtnHeight() != LONG_MAX )
390 {
391 nDist = Min( nDist, pBoss->GetMaxFtnHeight()
392 - (Frm().*fnRect->fnGetHeight)() );
393 if ( nDist <= 0 )
394 return 0L;
395 }
396 //Der FtnBoss will bezueglich des MaxWerts auch noch mitreden.
397 if( !IsInSct() )
398 {
399 const SwTwips nMax = pBoss->GetVarSpace();
400 if ( nDist > nMax )
401 nDist = nMax;
402 if ( nDist <= 0 )
403 return 0L;
404 }
405 }
406 else if( nDist > (GetPrev()->Frm().*fnRect->fnGetHeight)() )
407 //aber mehr als der Body kann koennen und wollen wir nun auch wieder
408 //nicht herausruecken.
409 nDist = (GetPrev()->Frm().*fnRect->fnGetHeight)();
410
411 long nAvail = 0;
412 if ( bBrowseMode )
413 {
414 nAvail = GetUpper()->Prt().Height();
415 const SwFrm *pAvail = GetUpper()->Lower();
416 do
417 { nAvail -= pAvail->Frm().Height();
418 pAvail = pAvail->GetNext();
419 } while ( pAvail );
420 if ( nAvail > nDist )
421 nAvail = nDist;
422 }
423
424 if ( !bTst )
425 {
426 (Frm().*fnRect->fnSetHeight)( (Frm().*fnRect->fnGetHeight)() + nDist );
427 if( IsVertical() && !IsReverse() )
428 Frm().Pos().X() -= nDist;
429 }
430 long nGrow = nDist - nAvail,
431 nReal = 0;
432 if ( nGrow > 0 )
433 {
434 BYTE nAdjust = pBoss->NeighbourhoodAdjustment( this );
435 if( NA_ONLY_ADJUST == nAdjust )
436 nReal = AdjustNeighbourhood( nGrow, bTst );
437 else
438 {
439 if( NA_GROW_ADJUST == nAdjust )
440 {
441 SwFrm* pFtn = Lower();
442 if( pFtn )
443 {
444 while( pFtn->GetNext() )
445 pFtn = pFtn->GetNext();
446 if( ((SwFtnFrm*)pFtn)->GetAttr()->GetFtn().IsEndNote() )
447 {
448 nReal = AdjustNeighbourhood( nGrow, bTst );
449 nAdjust = NA_GROW_SHRINK; // no more AdjustNeighbourhood
450 }
451 }
452 }
453 nReal += pBoss->Grow( nGrow - nReal, bTst );
454 if( ( NA_GROW_ADJUST == nAdjust || NA_ADJUST_GROW == nAdjust )
455 && nReal < nGrow )
456 nReal += AdjustNeighbourhood( nGrow - nReal, bTst );
457 }
458 }
459
460 nReal += nAvail;
461
462 if ( !bTst )
463 {
464 if ( nReal != nDist )
465 {
466 nDist -= nReal;
467 //Den masslosen Wunsch koennen wir leider nur in Grenzen erfuellen.
468 Frm().SSize().Height() -= nDist;
469 if( IsVertical() && !IsReverse() )
470 Frm().Pos().X() += nDist;
471 }
472
473 //Nachfolger braucht nicht invalidiert werden, denn wir wachsen
474 //immer nach oben.
475 if( nReal )
476 {
477 _InvalidateSize();
478 _InvalidatePos();
479 InvalidatePage( pPage );
480 }
481 }
482 return nReal;
483 }
484
485
486 SwTwips SwFtnContFrm::ShrinkFrm( SwTwips nDiff, BOOL bTst, BOOL bInfo )
487 {
488 SwPageFrm *pPage = FindPageFrm();
489 if ( pPage &&
490 ( !pPage->IsFtnPage() ||
491 GetFmt()->getIDocumentSettingAccess()->get(IDocumentSettingAccess::BROWSE_MODE) ) )
492 {
493 SwTwips nRet = SwLayoutFrm::ShrinkFrm( nDiff, bTst, bInfo );
494 if( IsInSct() && !bTst )
495 FindSctFrm()->InvalidateNextPos();
496 if ( !bTst && nRet )
497 {
498 _InvalidatePos();
499 InvalidatePage( pPage );
500 }
501 return nRet;
502 }
503 return 0;
504 }
505
506
507 /*************************************************************************
508 |*
509 |* SwFtnFrm::SwFtnFrm()
510 |*
511 |* Ersterstellung MA 24. Feb. 93
512 |* Letzte Aenderung MA 11. Oct. 93
513 |*
514 |*************************************************************************/
515
516
517 SwFtnFrm::SwFtnFrm( SwFrmFmt *pFmt, SwCntntFrm *pCnt, SwTxtFtn *pAt ):
518 SwLayoutFrm( pFmt ),
519 pFollow( 0 ),
520 pMaster( 0 ),
521 pRef( pCnt ),
522 pAttr( pAt ),
523 bBackMoveLocked( FALSE ),
524 // --> OD 2005-08-11 #i49383#
525 mbUnlockPosOfLowerObjs( true )
526 // <--
527 {
528 nType = FRMC_FTN;
529 }
530
531 /*************************************************************************
532 |*
533 |* SwFtnFrm::InvalidateNxtFtnCnts()
534 |*
535 |* Ersterstellung MA 29. Jun. 93
536 |* Letzte Aenderung MA 29. Jun. 93
537 |*
538 |*************************************************************************/
539
540
541 void SwFtnFrm::InvalidateNxtFtnCnts( SwPageFrm *pPage )
542 {
543 if ( GetNext() )
544 {
545 SwFrm *pCnt = ((SwLayoutFrm*)GetNext())->ContainsAny();
546 if( pCnt )
547 {
548 pCnt->InvalidatePage( pPage );
549 pCnt->_InvalidatePrt();
550 do
551 { pCnt->_InvalidatePos();
552 if( pCnt->IsSctFrm() )
553 {
554 SwFrm* pTmp = ((SwSectionFrm*)pCnt)->ContainsAny();
555 if( pTmp )
556 pTmp->_InvalidatePos();
557 }
558 pCnt->GetUpper()->_InvalidateSize();
559 pCnt = pCnt->FindNext();
560 } while ( pCnt && GetUpper()->IsAnLower( pCnt ) );
561 }
562 }
563 }
564
565 #ifndef PRODUCT
566
567 SwTwips SwFtnFrm::GrowFrm( SwTwips nDist, BOOL bTst, BOOL bInfo )
568 {
569 #if OSL_DEBUG_LEVEL > 1
570 static USHORT nNum = USHRT_MAX;
571 SwTxtFtn* pTxtFtn = GetAttr();
572 if ( pTxtFtn->GetFtn().GetNumber() == nNum )
573 {
574 int bla = 5;
575 (void)bla;
576
577 }
578 #endif
579 return SwLayoutFrm::GrowFrm( nDist, bTst, bInfo );
580 }
581
582
583 SwTwips SwFtnFrm::ShrinkFrm( SwTwips nDist, BOOL bTst, BOOL bInfo )
584 {
585 #if OSL_DEBUG_LEVEL > 1
586 static USHORT nNum = USHRT_MAX;
587 if( nNum != USHRT_MAX )
588 {
589 SwTxtFtn* pTxtFtn = GetAttr();
590 if( &pTxtFtn->GetAttr() && pTxtFtn->GetFtn().GetNumber() == nNum )
591 {
592 int bla = 5;
593 (void)bla;
594 }
595 }
596 #endif
597 return SwLayoutFrm::ShrinkFrm( nDist, bTst, bInfo );
598 }
599 #endif
600
601 /*************************************************************************
602 |*
603 |* SwFtnFrm::Cut()
604 |*
605 |* Ersterstellung MA 23. Feb. 94
606 |* Letzte Aenderung MA 24. Jul. 95
607 |*
608 |*************************************************************************/
609
610
611 void SwFtnFrm::Cut()
612 {
613 if ( GetNext() )
614 GetNext()->InvalidatePos();
615 else if ( GetPrev() )
616 GetPrev()->SetRetouche();
617
618 //Erst removen, dann Upper Shrinken.
619 SwLayoutFrm *pUp = GetUpper();
620
621 //Verkettung korrigieren.
622 SwFtnFrm *pFtn = (SwFtnFrm*)this;
623 if ( pFtn->GetFollow() )
624 pFtn->GetFollow()->SetMaster( pFtn->GetMaster() );
625 if ( pFtn->GetMaster() )
626 pFtn->GetMaster()->SetFollow( pFtn->GetFollow() );
627 pFtn->SetFollow( 0 );
628 pFtn->SetMaster( 0 );
629
630 // Alle Verbindungen kappen.
631 Remove();
632
633 if ( pUp )
634 {
635 //Die letzte Fussnote nimmt ihren Container mit.
636 if ( !pUp->Lower() )
637 {
638 SwPageFrm *pPage = pUp->FindPageFrm();
639 if ( pPage )
640 {
641 SwLayoutFrm *pBody = pPage->FindBodyCont();
642 if ( !pBody->ContainsCntnt() )
643 pPage->FindRootFrm()->SetSuperfluous();
644 }
645 SwSectionFrm* pSect = pUp->FindSctFrm();
646 pUp->Cut();
647 delete pUp;
648 // Wenn der letzte Fussnotencontainer aus einem spaltigen Bereich verschwindet,
649 // so kann dieser, falls er keinen Follow besitzt, zusammenschrumpfen.
650 if( pSect && !pSect->ToMaximize( FALSE ) && !pSect->IsColLocked() )
651 pSect->_InvalidateSize();
652 }
653 else
654 { if ( Frm().Height() )
655 pUp->Shrink( Frm().Height() );
656 pUp->SetCompletePaint();
657 pUp->InvalidatePage();
658 }
659 }
660 }
661
662 /*************************************************************************
663 |*
664 |* SwFtnFrm::Paste()
665 |*
666 |* Ersterstellung MA 23. Feb. 94
667 |* Letzte Aenderung MA 23. Feb. 94
668 |*
669 |*************************************************************************/
670
671
672 void SwFtnFrm::Paste( SwFrm* pParent, SwFrm* pSibling )
673 {
674 ASSERT( pParent, "Kein Parent fuer Paste." );
675 ASSERT( pParent->IsLayoutFrm(), "Parent ist CntntFrm." );
676 ASSERT( pParent != this, "Bin selbst der Parent." );
677 ASSERT( pSibling != this, "Bin mein eigener Nachbar." );
678 ASSERT( !GetPrev() && !GetNext() && !GetUpper(),
679 "Bin noch irgendwo angemeldet." );
680
681 //In den Baum einhaengen.
682 InsertBefore( (SwLayoutFrm*)pParent, pSibling );
683
684 SWRECTFN( this )
685 if( (Frm().*fnRect->fnGetWidth)()!=(pParent->Prt().*fnRect->fnGetWidth)() )
686 _InvalidateSize();
687 _InvalidatePos();
688 SwPageFrm *pPage = FindPageFrm();
689 InvalidatePage( pPage );
690 if ( GetNext() )
691 GetNext()->_InvalidatePos();
692 if( (Frm().*fnRect->fnGetHeight)() )
693 pParent->Grow( (Frm().*fnRect->fnGetHeight)() );
694
695 //Wenn mein Vorgaenger mein Master ist und/oder wenn mein Nachfolger mein
696 //Follow ist so kann ich deren Inhalt uebernehmen und sie vernichten.
697 if ( GetPrev() && GetPrev() == GetMaster() )
698 { ASSERT( SwFlowFrm::CastFlowFrm( GetPrev()->GetLower() ),
699 "Fussnote ohne Inhalt?" );
700 (SwFlowFrm::CastFlowFrm( GetPrev()->GetLower()))->
701 MoveSubTree( this, GetLower() );
702 SwFrm *pDel = GetPrev();
703 pDel->Cut();
704 delete pDel;
705 }
706 if ( GetNext() && GetNext() == GetFollow() )
707 { ASSERT( SwFlowFrm::CastFlowFrm( GetNext()->GetLower() ),
708 "Fussnote ohne Inhalt?" );
709 (SwFlowFrm::CastFlowFrm( GetNext()->GetLower()))->MoveSubTree( this );
710 SwFrm *pDel = GetNext();
711 pDel->Cut();
712 delete pDel;
713 }
714 #ifndef PRODUCT
715 SwDoc *pDoc = GetFmt()->GetDoc();
716 if ( GetPrev() )
717 {
718 ASSERT( lcl_FindFtnPos( pDoc, ((SwFtnFrm*)GetPrev())->GetAttr() ) <=
719 lcl_FindFtnPos( pDoc, GetAttr() ), "Prev ist not FtnPrev" );
720 }
721 if ( GetNext() )
722 {
723 ASSERT( lcl_FindFtnPos( pDoc, GetAttr() ) <=
724 lcl_FindFtnPos( pDoc, ((SwFtnFrm*)GetNext())->GetAttr() ),
725 "Next is not FtnNext" );
726 }
727 #endif
728 InvalidateNxtFtnCnts( pPage );
729 }
730
731 /*************************************************************************
732 |*
733 |* SwFrm::GetNextFtnLeaf()
734 |*
735 |* Beschreibung Liefert das naechste LayoutBlatt in den das
736 |* Frame gemoved werden kann.
737 |* Neue Seiten werden nur dann erzeugt, wenn der Parameter TRUE ist.
738 |* Ersterstellung MA 16. Nov. 92
739 |* Letzte Aenderung AMA 09. Nov. 98
740 |*
741 |*************************************************************************/
742
743
744 SwLayoutFrm *SwFrm::GetNextFtnLeaf( MakePageType eMakePage )
745 {
746 SwFtnBossFrm *pOldBoss = FindFtnBossFrm();
747 SwPageFrm* pOldPage = pOldBoss->FindPageFrm();
748 SwPageFrm* pPage;
749 SwFtnBossFrm *pBoss = pOldBoss->IsColumnFrm() ?
750 (SwFtnBossFrm*)pOldBoss->GetNext() : 0; // naechste Spalte, wenn vorhanden
751 if( pBoss )
752 pPage = NULL;
753 else
754 {
755 if( pOldBoss->GetUpper()->IsSctFrm() )
756 { // Das kann nur in einem spaltigen Bereich sein
757 SwLayoutFrm* pNxt = pOldBoss->GetNextSctLeaf( eMakePage );
758 if( pNxt )
759 {
760 ASSERT( pNxt->IsColBodyFrm(), "GetNextFtnLeaf: Funny Leaf" );
761 pBoss = (SwFtnBossFrm*)pNxt->GetUpper();
762 pPage = pBoss->FindPageFrm();
763 }
764 else
765 return 0;
766 }
767 else
768 {
769 // naechste Seite
770 pPage = (SwPageFrm*)pOldPage->GetNext();
771 // Leerseiten ueberspringen
772 if( pPage && pPage->IsEmptyPage() )
773 pPage = (SwPageFrm*)pPage->GetNext();
774 pBoss = pPage;
775 }
776 }
777 // Was haben wir jetzt?
778 // pBoss != NULL, pPage==NULL => pBoss ist die auf der gleichen Seite folgende Spalte
779 // pBoss != NULL, pPage!=NULL => pBoss und pPage sind die folgende Seite (Empty uebersprungen)
780 // pBoss == NULL => pPage == NULL, es gibt keine folgende Seite
781
782 //Wenn die Fussnote bereits einen Follow hat brauchen wir nicht zu suchen.
783 //Wenn allerdings zwischen Ftn und Follow unerwuenschte Leerseiten/spalten
784 //herumlungern, so legen wir auf der naechstbesten Seite/Spalte einen weiteren
785 //Follow an, der Rest wird sich schon finden.
786 SwFtnFrm *pFtn = FindFtnFrm();
787 if ( pFtn && pFtn->GetFollow() )
788 {
789 SwFtnBossFrm* pTmpBoss = pFtn->GetFollow()->FindFtnBossFrm();
790 // Folgende Faelle werden hier erkannt und akzeptiert
791 // 1. Die FtnBosse sind benachbarte Seiten oder benachbarte Spalten
792 // 2. Der neue ist die erste Spalte der benachbarten Seite
793 // 3. Der neue ist die erste Spalte in einem Bereich in der naechsten Spalte/Seite
794 while( pTmpBoss != pBoss && pTmpBoss && !pTmpBoss->GetPrev() )
795 pTmpBoss = pTmpBoss->GetUpper()->FindFtnBossFrm();
796 if( pTmpBoss == pBoss )
797 return pFtn->GetFollow();
798 }
799
800 // Wenn wir keinen pBoss gefunden haben oder es sich um eine "falsche" Seite handelt,
801 // muss eine neue Seite her
802 if ( !pBoss || ( pPage && pPage->IsEndNotePage() && !pOldPage->IsEndNotePage() ) )
803 {
804 if ( eMakePage == MAKEPAGE_APPEND || eMakePage == MAKEPAGE_INSERT )
805 {
806 pBoss = InsertPage( pOldPage, pOldPage->IsFtnPage() );
807 ((SwPageFrm*)pBoss)->SetEndNotePage( pOldPage->IsEndNotePage() );
808 }
809 else
810 return 0;
811 }
812 if( pBoss->IsPageFrm() )
813 { // Wenn wir auf einer spaltigen Seite gelandet sind,
814 // gehen wir in die erste Spalte
815 SwLayoutFrm* pLay = pBoss->FindBodyCont();
816 if( pLay && pLay->Lower() && pLay->Lower()->IsColumnFrm() )
817 pBoss = (SwFtnBossFrm*)pLay->Lower();
818 }
819 //Seite/Spalte gefunden, da schummeln wir uns doch gleich mal 'rein
820 SwFtnContFrm *pCont = pBoss->FindFtnCont();
821 if ( !pCont && pBoss->GetMaxFtnHeight() &&
822 ( eMakePage == MAKEPAGE_APPEND || eMakePage == MAKEPAGE_INSERT ) )
823 pCont = pBoss->MakeFtnCont();
824 return pCont;
825 }
826
827 /*************************************************************************
828 |*
829 |* SwFrm::GetPrevFtnLeaf()
830 |*
831 |* Beschreibung Liefert das vorhergehende LayoutBlatt in das der
832 |* Frame gemoved werden kann.
833 |* Ersterstellung MA 16. Nov. 92
834 |* Letzte Aenderung AMA 06. Nov. 98
835 |*
836 |*************************************************************************/
837
838
839 SwLayoutFrm *SwFrm::GetPrevFtnLeaf( MakePageType eMakeFtn )
840 {
841 //Der Vorgaenger fuer eine Fussnote ist falls moeglich der Master
842 //in der Fussnoteneigenen Verkettung.
843 SwLayoutFrm *pRet = 0;
844 SwFtnFrm *pFtn = FindFtnFrm();
845 pRet = pFtn->GetMaster();
846
847 SwFtnBossFrm* pOldBoss = FindFtnBossFrm();
848 SwPageFrm *pOldPage = pOldBoss->FindPageFrm();
849
850 if ( !pOldBoss->GetPrev() && !pOldPage->GetPrev() )
851 return pRet; // es gibt weder eine Spalte noch eine Seite vor uns
852
853 if ( !pRet )
854 {
855 bool bEndn = pFtn->GetAttr()->GetFtn().IsEndNote();
856 SwFrm* pTmpRef = NULL;
857 if( bEndn && pFtn->IsInSct() )
858 {
859 SwSectionFrm* pSect = pFtn->FindSctFrm();
860 if( pSect->IsEndnAtEnd() )
861 pTmpRef = pSect->FindLastCntnt( FINDMODE_LASTCNT );
862 }
863 if( !pTmpRef )
864 pTmpRef = pFtn->GetRef();
865 SwFtnBossFrm* pStop = pTmpRef->FindFtnBossFrm( !bEndn );
866
867 const USHORT nNum = pStop->GetPhyPageNum();
868
869 //Wenn die Fussnoten am Dokumentende angezeigt werden, so verlassen wir
870 //die Entsprechenden Seiten nicht.
871 //Selbiges gilt analog fuer die Endnotenseiten.
872 const BOOL bEndNote = pOldPage->IsEndNotePage();
873 const BOOL bFtnEndDoc = pOldPage->IsFtnPage();
874 SwFtnBossFrm* pNxtBoss = pOldBoss;
875 SwSectionFrm *pSect = pNxtBoss->GetUpper()->IsSctFrm() ?
876 (SwSectionFrm*)pNxtBoss->GetUpper() : 0;
877
878 do
879 {
880 if( pNxtBoss->IsColumnFrm() && pNxtBoss->GetPrev() )
881 pNxtBoss = (SwFtnBossFrm*)pNxtBoss->GetPrev(); // eine Spalte zurueck
882 else // oder eine Seite zurueck
883 {
884 SwLayoutFrm* pBody = 0;
885 if( pSect )
886 {
887 if( pSect->IsFtnLock() )
888 {
889 if( pNxtBoss == pOldBoss )
890 return 0;
891 pStop = pNxtBoss;
892 }
893 else
894 {
895 pSect = (SwSectionFrm*)pSect->FindMaster();
896 if( !pSect || !pSect->Lower() )
897 return 0;
898 ASSERT( pSect->Lower()->IsColumnFrm(),
899 "GetPrevFtnLeaf: Where's the column?" );
900 pNxtBoss = (SwFtnBossFrm*)pSect->Lower();
901 pBody = pSect;
902 }
903 }
904 else
905 {
906 SwPageFrm* pPage = (SwPageFrm*)pNxtBoss->FindPageFrm()->GetPrev();
907 if( !pPage || pPage->GetPhyPageNum() < nNum ||
908 bEndNote != pPage->IsEndNotePage() || bFtnEndDoc != pPage->IsFtnPage() )
909 return NULL; // Keine in Frage kommende Seite mehr gefunden
910 pNxtBoss = pPage;
911 pBody = pPage->FindBodyCont();
912 }
913 // Die vorherige Seite haben wir nun, ggf. sollten wir in die letzte Spalte
914 // der Seite wechseln
915 if( pBody )
916 {
917 if ( pBody->Lower() && pBody->Lower()->IsColumnFrm() )
918 {
919 pNxtBoss = static_cast<SwFtnBossFrm*>(pBody->GetLastLower());
920 }
921 }
922 }
923 SwFtnContFrm *pCont = pNxtBoss->FindFtnCont();
924 if ( pCont )
925 {
926 pRet = pCont;
927 break;
928 }
929 if ( pStop == pNxtBoss )
930 { //Die Seite/Spalte auf der sich auch die Referenz tummelt, ist erreicht.
931 //Wir koennen jetzt probehalber mal einen Container erzeugen und
932 //uns hineinpasten.
933 if ( eMakeFtn == MAKEPAGE_FTN && pNxtBoss->GetMaxFtnHeight() )
934 pRet = pNxtBoss->MakeFtnCont();
935 break;
936 }
937 } while( !pRet );
938 }
939 if ( pRet )
940 {
941 const SwFtnBossFrm* pNewBoss = pRet->FindFtnBossFrm();
942 BOOL bJump = FALSE;
943 if( pOldBoss->IsColumnFrm() && pOldBoss->GetPrev() ) // es gibt eine vorherige Spalte
944 bJump = pOldBoss->GetPrev() != (SwFrm*)pNewBoss; // sind wir darin gelandet?
945 else if( pNewBoss->IsColumnFrm() && pNewBoss->GetNext() )
946 bJump = TRUE; // es gibt hinter dem neuen Boss noch eine Spalte, die aber nicht
947 // der alte Boss sein kann, das haben wir ja bereits geprueft.
948 else // hier landen wir nur, wenn neuer und alter Boss entweder Seiten oder letzte (neu)
949 { // bzw. erste (alt) Spalten einer Seite sind. In diesem Fall muss noch geprueft
950 // werden, ob Seiten ueberspringen wurden.
951 USHORT nDiff = pOldPage->GetPhyPageNum() - pRet->FindPageFrm()->GetPhyPageNum();
952 if ( nDiff > 2 ||
953 (nDiff > 1 && !((SwPageFrm*)pOldPage->GetPrev())->IsEmptyPage()) )
954 bJump = TRUE;
955 }
956 if( bJump )
957 SwFlowFrm::SetMoveBwdJump( TRUE );
958 }
959 return pRet;
960 }
961
962 /*************************************************************************
963 |*
964 |* SwFrm::IsFtnAllowed()
965 |*
966 |* Ersterstellung MA 22. Mar. 94
967 |* Letzte Aenderung MA 01. Dec. 94
968 |*
969 |*************************************************************************/
970
971
972 BOOL SwFrm::IsFtnAllowed() const
973 {
974 if ( !IsInDocBody() )
975 return FALSE;
976
977 if ( IsInTab() )
978 {
979 //Keine Ftns in wiederholten Headlines.
980 const SwTabFrm *pTab = ((SwFrm*)this)->ImplFindTabFrm();
981 if ( pTab->IsFollow() )
982 return !pTab->IsInHeadline( *this );
983 }
984 return TRUE;
985 }
986
987 /*************************************************************************
988 |*
989 |* SwRootFrm::UpdateFtnNums()
990 |*
991 |* Ersterstellung MA 02. Mar. 93
992 |* Letzte Aenderung MA 09. Dec. 97
993 |*
994 |*************************************************************************/
995
996
997 void SwRootFrm::UpdateFtnNums()
998 {
999 //Seitenweise Numerierung nur wenn es am Dokument so eingestellt ist.
1000 if ( GetFmt()->GetDoc()->GetFtnInfo().eNum == FTNNUM_PAGE )
1001 {
1002 SwPageFrm *pPage = (SwPageFrm*)Lower();
1003 while ( pPage && !pPage->IsFtnPage() )
1004 {
1005 pPage->UpdateFtnNum();
1006 pPage = (SwPageFrm*)pPage->GetNext();
1007 }
1008 }
1009 }
1010
1011 /*************************************************************************
1012 |*
1013 |* RemoveFtns() Entfernen aller Fussnoten (nicht etwa die Referenzen)
1014 |* und Entfernen aller Fussnotenseiten.
1015 |*
1016 |* Ersterstellung MA 05. Dec. 97
1017 |* Letzte Aenderung AMA 06. Nov. 98
1018 |*
1019 |*************************************************************************/
1020
1021 void lcl_RemoveFtns( SwFtnBossFrm* pBoss, BOOL bPageOnly, BOOL bEndNotes )
1022 {
1023 do
1024 {
1025 SwFtnContFrm *pCont = pBoss->FindFtnCont();
1026 if ( pCont )
1027 {
1028 SwFtnFrm *pFtn = (SwFtnFrm*)pCont->Lower();
1029 ASSERT( pFtn, "FtnCont ohne Ftn." );
1030 if ( bPageOnly )
1031 while ( pFtn->GetMaster() )
1032 pFtn = pFtn->GetMaster();
1033 do
1034 {
1035 SwFtnFrm *pNxt = (SwFtnFrm*)pFtn->GetNext();
1036 if ( !pFtn->GetAttr()->GetFtn().IsEndNote() ||
1037 bEndNotes )
1038 {
1039 pFtn->GetRef()->Prepare( PREP_FTN, (void*)pFtn->GetAttr() );
1040 if ( bPageOnly && !pNxt )
1041 pNxt = pFtn->GetFollow();
1042 pFtn->Cut();
1043 delete pFtn;
1044 }
1045 pFtn = pNxt;
1046
1047 } while ( pFtn );
1048 }
1049 if( !pBoss->IsInSct() )
1050 {
1051 // A sectionframe with the Ftn/EndnAtEnd-flags may contain
1052 // foot/endnotes. If the last lower frame of the bodyframe is
1053 // a multicolumned sectionframe, it may contain footnotes, too.
1054 SwLayoutFrm* pBody = pBoss->FindBodyCont();
1055 if( pBody && pBody->Lower() )
1056 {
1057 SwFrm* pLow = pBody->Lower();
1058 while( pLow->GetNext() )
1059 {
1060 if( pLow->IsSctFrm() && ( !pLow->GetNext() ||
1061 ((SwSectionFrm*)pLow)->IsAnyNoteAtEnd() ) &&
1062 ((SwSectionFrm*)pLow)->Lower() &&
1063 ((SwSectionFrm*)pLow)->Lower()->IsColumnFrm() )
1064 lcl_RemoveFtns( (SwColumnFrm*)((SwSectionFrm*)pLow)->Lower(),
1065 bPageOnly, bEndNotes );
1066 pLow = pLow->GetNext();
1067 }
1068 }
1069 }
1070 // noch 'ne Spalte?
1071 pBoss = pBoss->IsColumnFrm() ? (SwColumnFrm*)pBoss->GetNext() : NULL;
1072 } while( pBoss );
1073 }
1074
1075 void SwRootFrm::RemoveFtns( SwPageFrm *pPage, BOOL bPageOnly, BOOL bEndNotes )
1076 {
1077 if ( !pPage )
1078 pPage = (SwPageFrm*)Lower();
1079
1080 do
1081 { // Bei spaltigen Seiten muessen wir in allen Spalten aufraeumen
1082 SwFtnBossFrm* pBoss;
1083 SwLayoutFrm* pBody = pPage->FindBodyCont();
1084 if( pBody && pBody->Lower() && pBody->Lower()->IsColumnFrm() )
1085 pBoss = (SwFtnBossFrm*)pBody->Lower(); // die erste Spalte
1086 else
1087 pBoss = pPage; // keine Spalten
1088 lcl_RemoveFtns( pBoss, bPageOnly, bEndNotes );
1089 if ( !bPageOnly )
1090 {
1091 if ( pPage->IsFtnPage() &&
1092 (!pPage->IsEndNotePage() || bEndNotes) )
1093 {
1094 SwFrm *pDel = pPage;
1095 pPage = (SwPageFrm*)pPage->GetNext();
1096 pDel->Cut();
1097 delete pDel;
1098 }
1099 else
1100 pPage = (SwPageFrm*)pPage->GetNext();
1101 }
1102 else
1103 break;
1104
1105 } while ( pPage );
1106 }
1107
1108 /*************************************************************************
1109 |*
1110 |* SetFtnPageDescs() Seitenvorlagen der Fussnotenseiten aendern
1111 |*
1112 |* Ersterstellung MA 11. Dec. 97
1113 |* Letzte Aenderung MA 11. Dec. 97
1114 |*
1115 |*************************************************************************/
1116
1117 void SwRootFrm::CheckFtnPageDescs( BOOL bEndNote )
1118 {
1119 SwPageFrm *pPage = (SwPageFrm*)Lower();
1120 while ( pPage && !pPage->IsFtnPage() )
1121 pPage = (SwPageFrm*)pPage->GetNext();
1122 while ( pPage && pPage->IsEndNotePage() != bEndNote )
1123 pPage = (SwPageFrm*)pPage->GetNext();
1124 if ( pPage )
1125 SwFrm::CheckPageDescs( pPage, FALSE );
1126 }
1127
1128
1129 /*************************************************************************
1130 |*
1131 |* SwFtnBossFrm::MakeFtnCont()
1132 |*
1133 |* Ersterstellung MA 25. Feb. 93
1134 |* Letzte Aenderung AMA 29. Oct. 98
1135 |*
1136 |*************************************************************************/
1137
1138
1139 SwFtnContFrm *SwFtnBossFrm::MakeFtnCont()
1140 {
1141 //Einfuegen eines Fussnotencontainers. Der Fussnotencontainer sitzt
1142 //immer direkt hinter dem Bodytext.
1143 //Sein FrmFmt ist immer das DefaultFrmFmt.
1144
1145 #ifndef PRODUCT
1146 if ( FindFtnCont() )
1147 { ASSERT( !this, "Fussnotencontainer bereits vorhanden." );
1148 return 0;
1149 }
1150 #endif
1151
1152 SwFtnContFrm *pNew = new SwFtnContFrm( GetFmt()->GetDoc()->GetDfltFrmFmt());
1153 SwLayoutFrm *pLay = FindBodyCont();
1154 pNew->Paste( this, pLay->GetNext() );
1155 return pNew;
1156 }
1157
1158 /*************************************************************************
1159 |*
1160 |* SwFtnBossFrm::FindFtnCont()
1161 |*
1162 |* Ersterstellung MA 25. Feb. 93
1163 |* Letzte Aenderung AMA 29. Oct. 98
1164 |*
1165 |*************************************************************************/
1166
1167
1168 SwFtnContFrm *SwFtnBossFrm::FindFtnCont()
1169 {
1170 SwFrm *pFrm = Lower();
1171 while( pFrm && !pFrm->IsFtnContFrm() )
1172 pFrm = pFrm->GetNext();
1173
1174 #ifndef PRODUCT
1175 if ( pFrm )
1176 {
1177 SwFrm *pFtn = pFrm->GetLower();
1178 ASSERT( pFtn, "Cont ohne Fussnote." );
1179 while ( pFtn )
1180 {
1181 ASSERT( pFtn->IsFtnFrm(), "Nachbar von Fussnote keine Fussnote." );
1182 pFtn = pFtn->GetNext();
1183 }
1184 }
1185 #endif
1186
1187 return (SwFtnContFrm*)pFrm;
1188 }
1189
1190 /*************************************************************************
1191 |*
1192 |* SwFtnBossFrm::FindNearestFtnCont() Sucht den naechst greifbaren Fussnotencontainer.
1193 |*
1194 |* Ersterstellung MA 02. Aug. 93
1195 |* Letzte Aenderung AMA 29. Oct. 98
1196 |*
1197 |*************************************************************************/
1198
1199 SwFtnContFrm *SwFtnBossFrm::FindNearestFtnCont( BOOL bDontLeave )
1200 {
1201 SwFtnContFrm *pCont = 0;
1202 if ( GetFmt()->GetDoc()->GetFtnIdxs().Count() )
1203 {
1204 pCont = FindFtnCont();
1205 if ( !pCont )
1206 {
1207 SwPageFrm *pPage = FindPageFrm();
1208 SwFtnBossFrm* pBoss = this;
1209 BOOL bEndNote = pPage->IsEndNotePage();
1210 do
1211 {
1212 BOOL bChgPage = lcl_NextFtnBoss( pBoss, pPage, bDontLeave );
1213 // Haben wir noch einen Boss gefunden? Bei einem Seitenwechsel muss
1214 // zudem noch das EndNotenFlag uebereinstimmen
1215 if( pBoss && ( !bChgPage || pPage->IsEndNotePage() == bEndNote ) )
1216 pCont = pBoss->FindFtnCont();
1217 } while ( !pCont && pPage );
1218 }
1219 }
1220 return pCont;
1221 }
1222
1223
1224 /*************************************************************************
1225 |*
1226 |* SwFtnBossFrm::FindFirstFtn()
1227 |*
1228 |* Beschreibung Erste Fussnote des Fussnotenbosses suchen.
1229 |* Ersterstellung MA 26. Feb. 93
1230 |* Letzte Aenderung AMA 29. Oct. 99
1231 |*
1232 |*************************************************************************/
1233
1234
1235 SwFtnFrm *SwFtnBossFrm::FindFirstFtn()
1236 {
1237 //Erstmal den naechsten FussnotenContainer suchen.
1238 SwFtnContFrm *pCont = FindNearestFtnCont();
1239 if ( !pCont )
1240 return 0;
1241
1242 //Ab der ersten Fussnote im Container die erste suchen, die
1243 //von der aktuellen Spalte (bzw. einspaltigen Seite) referenziert wird.
1244
1245 SwFtnFrm *pRet = (SwFtnFrm*)pCont->Lower();
1246 const USHORT nRefNum = FindPageFrm()->GetPhyPageNum();
1247 const USHORT nRefCol = lcl_ColumnNum( this );
1248 USHORT nPgNum, nColNum; //Seitennummer, Spaltennummer
1249 SwFtnBossFrm* pBoss;
1250 SwPageFrm* pPage;
1251 if( pRet )
1252 {
1253 pBoss = pRet->GetRef()->FindFtnBossFrm();
1254 ASSERT( pBoss, "FindFirstFtn: No boss found" );
1255 if( !pBoss )
1256 return FALSE; // ?There must be a bug, but no GPF
1257 pPage = pBoss->FindPageFrm();
1258 nPgNum = pPage->GetPhyPageNum();
1259 if ( nPgNum == nRefNum )
1260 {
1261 nColNum = lcl_ColumnNum( pBoss );
1262 if( nColNum == nRefCol )
1263 return pRet; //hat ihn.
1264 else if( nColNum > nRefCol )
1265 return NULL; //mind. eine Spalte zu weit.
1266 }
1267 else if ( nPgNum > nRefNum )
1268 return NULL; //mind. eine Seite zu weit.
1269 }
1270 else
1271 return NULL;
1272 // Ende, wenn Ref auf einer spaeteren Seite oder auf der gleichen Seite in einer
1273 // spaeteren Spalte liegt
1274
1275 do
1276 {
1277 while ( pRet->GetFollow() )
1278 pRet = pRet->GetFollow();
1279
1280 SwFtnFrm *pNxt = (SwFtnFrm*)pRet->GetNext();
1281 if ( !pNxt )
1282 {
1283 pBoss = pRet->FindFtnBossFrm();
1284 pPage = pBoss->FindPageFrm();
1285 lcl_NextFtnBoss( pBoss, pPage, FALSE ); // naechster FtnBoss
1286 pCont = pBoss ? pBoss->FindNearestFtnCont() : 0;
1287 if ( pCont )
1288 pNxt = (SwFtnFrm*)pCont->Lower();
1289 }
1290 if ( pNxt )
1291 {
1292 pRet = pNxt;
1293 pBoss = pRet->GetRef()->FindFtnBossFrm();
1294 pPage = pBoss->FindPageFrm();
1295 nPgNum = pPage->GetPhyPageNum();
1296 if ( nPgNum == nRefNum )
1297 {
1298 nColNum = lcl_ColumnNum( pBoss );
1299 if( nColNum == nRefCol )
1300 break; //hat ihn.
1301 else if( nColNum > nRefCol )
1302 pRet = 0; //mind. eine Spalte zu weit.
1303 }
1304 else if ( nPgNum > nRefNum )
1305 pRet = 0; //mind. eine Seite zu weit.
1306 }
1307 else
1308 pRet = 0; //Gibt eben keinen.
1309 } while( pRet );
1310 return pRet;
1311 }
1312
1313 /*************************************************************************
1314 |*
1315 |* SwFtnBossFrm::FindFirstFtn()
1316 |*
1317 |* Beschreibunt Erste Fussnote zum Cnt suchen.
1318 |* Ersterstellung MA 04. Mar. 93
1319 |* Letzte Aenderung AMA 28. Oct. 98
1320 |*
1321 |*************************************************************************/
1322
1323
1324 const SwFtnFrm *SwFtnBossFrm::FindFirstFtn( SwCntntFrm *pCnt ) const
1325 {
1326 const SwFtnFrm *pRet = ((SwFtnBossFrm*)this)->FindFirstFtn();
1327 if ( pRet )
1328 {
1329 const USHORT nColNum = lcl_ColumnNum( this ); //Spaltennummer
1330 const USHORT nPageNum = GetPhyPageNum();
1331 while ( pRet && (pRet->GetRef() != pCnt) )
1332 {
1333 while ( pRet->GetFollow() )
1334 pRet = pRet->GetFollow();
1335
1336 if ( pRet->GetNext() )
1337 pRet = (const SwFtnFrm*)pRet->GetNext();
1338 else
1339 { SwFtnBossFrm *pBoss = (SwFtnBossFrm*)pRet->FindFtnBossFrm();
1340 SwPageFrm *pPage = pBoss->FindPageFrm();
1341 lcl_NextFtnBoss( pBoss, pPage, FALSE ); // naechster FtnBoss
1342 SwFtnContFrm *pCont = pBoss ? pBoss->FindNearestFtnCont() : 0;
1343 pRet = pCont ? (SwFtnFrm*)pCont->Lower() : 0;
1344 }
1345 if ( pRet )
1346 {
1347 const SwFtnBossFrm* pBoss = pRet->GetRef()->FindFtnBossFrm();
1348 if( pBoss->GetPhyPageNum() != nPageNum ||
1349 nColNum != lcl_ColumnNum( pBoss ) )
1350 pRet = 0;
1351 }
1352 }
1353 }
1354 return pRet;
1355 }
1356
1357 /*************************************************************************
1358 |*
1359 |* SwFtnBossFrm::ResetFtn()
1360 |*
1361 |* Ersterstellung MA 11. May. 95
1362 |* Letzte Aenderung AMA 29. Oct. 98
1363 |*
1364 |*************************************************************************/
1365
1366
1367 void SwFtnBossFrm::ResetFtn( const SwFtnFrm *pCheck )
1368 {
1369 //Vernichten der Inkarnationen von Fussnoten zum Attribut, wenn sie nicht
1370 //zu pAssumed gehoeren.
1371 ASSERT( !pCheck->GetMaster(), "Master not an Master." );
1372
1373 SwNodeIndex aIdx( *pCheck->GetAttr()->GetStartNode(), 1 );
1374 SwCntntNode *pNd = aIdx.GetNode().GetCntntNode();
1375 if ( !pNd )
1376 pNd = pCheck->GetFmt()->GetDoc()->
1377 GetNodes().GoNextSection( &aIdx, TRUE, FALSE );
1378 SwClientIter aIter( *pNd );
1379 SwClient* pLast = aIter.GoStart();
1380 while( pLast )
1381 {
1382 if ( pLast->ISA(SwFrm) )
1383 {
1384 SwFrm *pFrm = (SwFrm*)pLast;
1385 SwFrm *pTmp = pFrm->GetUpper();
1386 while ( pTmp && !pTmp->IsFtnFrm() )
1387 pTmp = pTmp->GetUpper();
1388
1389 SwFtnFrm *pFtn = (SwFtnFrm*)pTmp;
1390 while ( pFtn && pFtn->GetMaster() )
1391 pFtn = pFtn->GetMaster();
1392 if ( pFtn != pCheck )
1393 {
1394 while ( pFtn )
1395 {
1396 SwFtnFrm *pNxt = pFtn->GetFollow();
1397 pFtn->Cut();
1398 delete pFtn;
1399 pFtn = pNxt;
1400 }
1401 }
1402 }
1403 pLast = ++aIter;
1404 }
1405 }
1406
1407 /*************************************************************************
1408 |*
1409 |* SwFtnBossFrm::InsertFtn()
1410 |*
1411 |* Ersterstellung MA 26. Feb. 93
1412 |* Letzte Aenderung AMA 29. Oct. 98
1413 |*
1414 |*************************************************************************/
1415
1416
1417 void SwFtnBossFrm::InsertFtn( SwFtnFrm* pNew )
1418 {
1419 #if (OSL_DEBUG_LEVEL > 1) && !defined(PRODUCT)
1420 static USHORT nStop = 0;
1421 if ( nStop == pNew->GetFrmId() )
1422 {
1423 int bla = 5;
1424 (void)bla;
1425 }
1426 #endif
1427 //Die Fussnote haben wir, sie muss jetzt nur noch irgendwo
1428 //hin und zwar vor die Fussnote, deren Attribut vor das
1429 //der neuen zeigt (Position wird ueber das Doc ermittelt)
1430 //Gibt es in diesem Fussnotenboss noch keine Fussnoten, so muss eben ein
1431 //Container erzeugt werden.
1432 //Gibt es bereits einen Container aber noch keine Fussnote zu diesem
1433 //Fussnotenboss, so muss die Fussnote hinter die letzte Fussnote der dichtesten
1434 //Vorseite/spalte.
1435
1436 ResetFtn( pNew );
1437 SwFtnFrm *pSibling = FindFirstFtn();
1438 BOOL bDontLeave = FALSE;
1439
1440 // Ok, a sibling has been found, but is the sibling in an acceptable
1441 // environment?
1442 if( IsInSct() )
1443 {
1444 SwSectionFrm* pMySect = ImplFindSctFrm();
1445 bool bEndnt = pNew->GetAttr()->GetFtn().IsEndNote();
1446 if( bEndnt )
1447 {
1448 const SwSectionFmt* pEndFmt = pMySect->GetEndSectFmt();
1449 bDontLeave = 0 != pEndFmt;
1450 if( pSibling )
1451 {
1452 if( pEndFmt )
1453 {
1454 if( !pSibling->IsInSct() ||
1455 !pSibling->ImplFindSctFrm()->IsDescendantFrom( pEndFmt ) )
1456 pSibling = NULL;
1457 }
1458 else if( pSibling->IsInSct() )
1459 pSibling = NULL;
1460 }
1461 }
1462 else
1463 {
1464 bDontLeave = pMySect->IsFtnAtEnd();
1465 if( pSibling )
1466 {
1467 if( pMySect->IsFtnAtEnd() )
1468 {
1469 if( !pSibling->IsInSct() ||
1470 !pMySect->IsAnFollow( pSibling->ImplFindSctFrm() ) )
1471 pSibling = NULL;
1472 }
1473 else if( pSibling->IsInSct() )
1474 pSibling = NULL;
1475 }
1476 }
1477 }
1478
1479 if( pSibling && pSibling->FindPageFrm()->IsEndNotePage() !=
1480 FindPageFrm()->IsEndNotePage() )
1481 pSibling = NULL;
1482
1483 //Damit die Position herausgefunden werden kann.
1484 SwDoc *pDoc = GetFmt()->GetDoc();
1485 const ULONG nStPos = ::lcl_FindFtnPos( pDoc, pNew->GetAttr() );
1486
1487 ULONG nCmpPos = 0;
1488 ULONG nLastPos = 0;
1489 SwFtnContFrm *pParent = 0;
1490 if( pSibling )
1491 {
1492 nCmpPos = ::lcl_FindFtnPos( pDoc, pSibling->GetAttr() );
1493 if( nCmpPos > nStPos )
1494 pSibling = NULL;
1495 }
1496
1497 if ( !pSibling )
1498 { pParent = FindFtnCont();
1499 if ( !pParent )
1500 {
1501 //Es gibt noch keinen FussnotenContainer, also machen wir einen.
1502 //HAAAAAAAALT! So einfach ist das leider mal wieder nicht: Es kann
1503 //sein, dass irgendeine naechste Fussnote existiert die vor der
1504 //einzufuegenden zu stehen hat, weil z.B. eine Fussnote ueber zig
1505 //Seiten aufgespalten ist usw.
1506 pParent = FindNearestFtnCont( bDontLeave );
1507 if ( pParent )
1508 {
1509 SwFtnFrm *pFtn = (SwFtnFrm*)pParent->Lower();
1510 if ( pFtn )
1511 {
1512
1513 nCmpPos = ::lcl_FindFtnPos( pDoc, pFtn->GetAttr() );
1514 if ( nCmpPos > nStPos )
1515 pParent = 0;
1516 }
1517 else
1518 pParent = 0;
1519 }
1520 }
1521 if ( !pParent )
1522 //Jetzt kann aber ein Fussnotencontainer gebaut werden.
1523 pParent = MakeFtnCont();
1524 else
1525 {
1526 //Ausgehend von der ersten Fussnote unterhalb des Parents wird die
1527 //erste Fussnote gesucht deren Index hinter dem Index der
1528 //einzufuegenden liegt; vor dieser kann der neue dann gepastet
1529 //werden.
1530 pSibling = (SwFtnFrm*)pParent->Lower();
1531 if ( !pSibling )
1532 { ASSERT( !this, "Keinen Platz fuer Fussnote gefunden.");
1533 return;
1534 }
1535 nCmpPos = ::lcl_FindFtnPos( pDoc, pSibling->GetAttr() );
1536
1537 SwFtnBossFrm *pNxtB = this; //Immer den letzten merken, damit wir nicht
1538 SwFtnFrm *pLastSib = 0; //ueber das Ziel hinausschiessen.
1539
1540 while ( pSibling && nCmpPos <= nStPos )
1541 {
1542 pLastSib = pSibling; // der kommt schon mal in Frage
1543 nLastPos = nCmpPos;
1544
1545 while ( pSibling->GetFollow() )
1546 pSibling = pSibling->GetFollow();
1547
1548 if ( pSibling->GetNext() )
1549 {
1550 pSibling = (SwFtnFrm*)pSibling->GetNext();
1551 ASSERT( !pSibling->GetMaster() || ( ENDNOTE > nStPos &&
1552 pSibling->GetAttr()->GetFtn().IsEndNote() ),
1553 "InsertFtn: Master expected I" );
1554 }
1555 else
1556 {
1557 pNxtB = pSibling->FindFtnBossFrm();
1558 SwPageFrm *pSibPage = pNxtB->FindPageFrm();
1559 BOOL bEndNote = pSibPage->IsEndNotePage();
1560 BOOL bChgPage = lcl_NextFtnBoss( pNxtB, pSibPage, bDontLeave );
1561 // Bei Seitenwechsel muss das EndNoteFlag ueberprueft werden.
1562 SwFtnContFrm *pCont = pNxtB && ( !bChgPage ||
1563 pSibPage->IsEndNotePage() == bEndNote )
1564 ? pNxtB->FindNearestFtnCont( bDontLeave ) : 0;
1565 if( pCont )
1566 pSibling = (SwFtnFrm*)pCont->Lower();
1567 else // kein weiterer FtnContainer, dann werden wir uns wohl hinter
1568 break; // pSibling haengen
1569 }
1570 if ( pSibling )
1571 {
1572 nCmpPos = ::lcl_FindFtnPos( pDoc, pSibling->GetAttr() );
1573 ASSERT( nCmpPos > nLastPos, "InsertFtn: Order of FtnFrm's buggy" );
1574 }
1575 }
1576 // pLastSib ist jetzt die letzte Fussnote vor uns,
1577 // pSibling leer oder die erste nach uns.
1578 if ( pSibling && pLastSib && (pSibling != pLastSib) )
1579 { //Sind wir vielleicht bereits ueber das Ziel hinausgeschossen?
1580 if ( nCmpPos > nStPos )
1581 pSibling = pLastSib;
1582 }
1583 else if ( !pSibling )
1584 { //Eine Chance haben wir noch: wir nehmen einfach die letzte
1585 //Fussnote im Parent. Ein Sonderfall, der z.B. beim
1586 //zurueckfliessen von Absaetzen mit mehreren Fussnoten
1587 //vorkommt.
1588 //Damit wir nicht die Reihenfolge verwuerfeln muessen wir den
1589 //Parent der letzten Fussnote, die wir an der Hand hatten benutzen.
1590 pSibling = pLastSib;
1591 while( pSibling->GetFollow() )
1592 pSibling = pSibling->GetFollow();
1593 ASSERT( !pSibling->GetNext(), "InsertFtn: Who's that guy?" );
1594 }
1595 }
1596 }
1597 else
1598 { //Die erste Fussnote der Spalte/Seite haben wir an der Hand, jetzt ausgehend
1599 //von dieser die erste zur selben Spalte/Seite suchen deren Index hinter
1600 //den uebergebenen zeigt, die letzte, die wir an der Hand hatten, ist
1601 //dann der Vorgaenger.
1602 SwFtnBossFrm* pBoss = pNew->GetRef()->FindFtnBossFrm(
1603 !pNew->GetAttr()->GetFtn().IsEndNote() );
1604 USHORT nRefNum = pBoss->GetPhyPageNum(); // Die Seiten- und
1605 USHORT nRefCol = lcl_ColumnNum( pBoss ); // Spaltennummer der neuen Fussnote
1606 BOOL bEnd = FALSE;
1607 SwFtnFrm *pLastSib = 0;
1608 while ( pSibling && !bEnd && (nCmpPos <= nStPos) )
1609 {
1610 pLastSib = pSibling;
1611 nLastPos = nCmpPos;
1612
1613 while ( pSibling->GetFollow() )
1614 pSibling = pSibling->GetFollow();
1615
1616 SwFtnFrm *pFoll = (SwFtnFrm*)pSibling->GetNext();
1617 if ( pFoll )
1618 {
1619 pBoss = pSibling->GetRef()->FindFtnBossFrm( !pSibling->
1620 GetAttr()->GetFtn().IsEndNote() );
1621 USHORT nTmpRef;
1622 if( nStPos >= ENDNOTE ||
1623 (nTmpRef = pBoss->GetPhyPageNum()) < nRefNum ||
1624 ( nTmpRef == nRefNum && lcl_ColumnNum( pBoss ) <= nRefCol ))
1625 pSibling = pFoll;
1626 else
1627 bEnd = TRUE;
1628 }
1629 else
1630 {
1631 SwFtnBossFrm* pNxtB = pSibling->FindFtnBossFrm();
1632 SwPageFrm *pSibPage = pNxtB->FindPageFrm();
1633 BOOL bEndNote = pSibPage->IsEndNotePage();
1634 BOOL bChgPage = lcl_NextFtnBoss( pNxtB, pSibPage, bDontLeave );
1635 // Bei Seitenwechsel muss das EndNoteFlag ueberprueft werden.
1636 SwFtnContFrm *pCont = pNxtB && ( !bChgPage ||
1637 pSibPage->IsEndNotePage() == bEndNote )
1638 ? pNxtB->FindNearestFtnCont( bDontLeave ) : 0;
1639 if ( pCont )
1640 pSibling = (SwFtnFrm*)pCont->Lower();
1641 else
1642 bEnd = TRUE;
1643 }
1644 if ( !bEnd && pSibling )
1645 nCmpPos = ::lcl_FindFtnPos( pDoc, pSibling->GetAttr() );
1646 if ( pSibling && pLastSib && (pSibling != pLastSib) )
1647 { //Sind wir vielleicht bereits ueber das Ziel hinausgeschossen?
1648 if ( (nLastPos < nCmpPos) && (nCmpPos > nStPos) )
1649 {
1650 pSibling = pLastSib;
1651 bEnd = TRUE;
1652 }
1653 }
1654 }
1655 }
1656 if ( pSibling )
1657 {
1658 nCmpPos = ::lcl_FindFtnPos( pDoc, pSibling->GetAttr() );
1659 if ( nCmpPos < nStPos )
1660 {
1661 while ( pSibling->GetFollow() )
1662 pSibling = pSibling->GetFollow();
1663 pParent = (SwFtnContFrm*)pSibling->GetUpper();
1664 pSibling = (SwFtnFrm*)pSibling->GetNext();
1665 }
1666 else
1667 {
1668 if( pSibling->GetMaster() )
1669 {
1670 if( ENDNOTE > nCmpPos || nStPos >= ENDNOTE )
1671 {
1672 ASSERT( FALSE, "InsertFtn: Master expected II" );
1673 do
1674 pSibling = pSibling->GetMaster();
1675 while ( pSibling->GetMaster() );
1676 }
1677 }
1678 pParent = (SwFtnContFrm*)pSibling->GetUpper();
1679 }
1680 }
1681 ASSERT( pParent, "paste in space?" );
1682 pNew->Paste( pParent, pSibling );
1683 }
1684
1685 /*************************************************************************
1686 |*
1687 |* SwFtnBossFrm::AppendFtn()
1688 |*
1689 |* Ersterstellung MA 25. Feb. 93
1690 |* Letzte Aenderung AMA 29. Oct. 98
1691 |*
1692 |*************************************************************************/
1693
1694
1695 void SwFtnBossFrm::AppendFtn( SwCntntFrm *pRef, SwTxtFtn *pAttr )
1696 {
1697 //Wenn es die Fussnote schon gibt tun wir nix.
1698 if ( FindFtn( pRef, pAttr ) )
1699 return;
1700
1701 //Wenn Fussnoten am Dokumentende eingestellt sind, so brauchen wir 'eh erst
1702 //ab der entsprechenden Seite zu suchen.
1703 //Wenn es noch keine gibt, muss eben eine erzeugt werden.
1704 //Wenn es sich um eine Endnote handelt, muss eine Endnotenseite gesucht
1705 //bzw. erzeugt werden.
1706 SwDoc *pDoc = GetFmt()->GetDoc();
1707 SwFtnBossFrm *pBoss = this;
1708 SwPageFrm *pPage = FindPageFrm();
1709 SwPageFrm *pMyPage = pPage;
1710 BOOL bChgPage = FALSE;
1711 BOOL bEnd = FALSE;
1712 if ( pAttr->GetFtn().IsEndNote() )
1713 {
1714 bEnd = TRUE;
1715 if( GetUpper()->IsSctFrm() &&
1716 ((SwSectionFrm*)GetUpper())->IsEndnAtEnd() )
1717 {
1718 SwFrm* pLast =
1719 ((SwSectionFrm*)GetUpper())->FindLastCntnt( FINDMODE_ENDNOTE );
1720 if( pLast )
1721 {
1722 pBoss = pLast->FindFtnBossFrm();
1723 pPage = pBoss->FindPageFrm();
1724 }
1725 }
1726 else
1727 {
1728 while ( pPage->GetNext() && !pPage->IsEndNotePage() )
1729 {
1730 pPage = (SwPageFrm*)pPage->GetNext();
1731 bChgPage = TRUE;
1732 }
1733 if ( !pPage->IsEndNotePage() )
1734 {
1735 SwPageDesc *pDesc = pDoc->GetEndNoteInfo().GetPageDesc( *pDoc );
1736 pPage = ::InsertNewPage( *pDesc, pPage->GetUpper(),
1737 !pPage->OnRightPage(), FALSE, TRUE, 0 );
1738 pPage->SetEndNotePage( TRUE );
1739 bChgPage = TRUE;
1740 }
1741 else
1742 {
1743 //Wir koennen wenigstens schon mal ungefaehr die richtige Seite
1744 //suchen. Damit stellen wir sicher das wir auch bei hunderten
1745 //Fussnoten noch in endlicher Zeit fertig werden.
1746 SwPageFrm *pNxt = (SwPageFrm*)pPage->GetNext();
1747 const ULONG nStPos = ::lcl_FindFtnPos( pDoc, pAttr );
1748 while ( pNxt && pNxt->IsEndNotePage() )
1749 {
1750 SwFtnContFrm *pCont = pNxt->FindFtnCont();
1751 if ( pCont && pCont->Lower() )
1752 {
1753 ASSERT( pCont->Lower()->IsFtnFrm(), "Keine Ftn im Container" );
1754 if ( nStPos > ::lcl_FindFtnPos( pDoc,
1755 ((SwFtnFrm*)pCont->Lower())->GetAttr()))
1756 {
1757 pPage = pNxt;
1758 pNxt = (SwPageFrm*)pPage->GetNext();
1759 continue;
1760 }
1761 }
1762 break;
1763 }
1764 }
1765 }
1766 }
1767 else if( FTNPOS_CHAPTER == pDoc->GetFtnInfo().ePos && ( !GetUpper()->
1768 IsSctFrm() || !((SwSectionFrm*)GetUpper())->IsFtnAtEnd() ) )
1769 {
1770 while ( pPage->GetNext() && !pPage->IsFtnPage() &&
1771 !((SwPageFrm*)pPage->GetNext())->IsEndNotePage() )
1772 {
1773 pPage = (SwPageFrm*)pPage->GetNext();
1774 bChgPage = TRUE;
1775 }
1776
1777 if ( !pPage->IsFtnPage() )
1778 {
1779 SwPageDesc *pDesc = pDoc->GetFtnInfo().GetPageDesc( *pDoc );
1780 pPage = ::InsertNewPage( *pDesc, pPage->GetUpper(),
1781 !pPage->OnRightPage(), FALSE, TRUE, pPage->GetNext() );
1782 bChgPage = TRUE;
1783 }
1784 else
1785 {
1786 //Wir koennen wenigstens schon mal ungefaehr die richtige Seite
1787 //suchen. Damit stellen wir sicher das wir auch bei hunderten
1788 //Fussnoten noch in endlicher Zeit fertig werden.
1789 SwPageFrm *pNxt = (SwPageFrm*)pPage->GetNext();
1790 const ULONG nStPos = ::lcl_FindFtnPos( pDoc, pAttr );
1791 while ( pNxt && pNxt->IsFtnPage() && !pNxt->IsEndNotePage() )
1792 {
1793 SwFtnContFrm *pCont = pNxt->FindFtnCont();
1794 if ( pCont && pCont->Lower() )
1795 {
1796 ASSERT( pCont->Lower()->IsFtnFrm(), "Keine Ftn im Container" );
1797 if ( nStPos > ::lcl_FindFtnPos( pDoc,
1798 ((SwFtnFrm*)pCont->Lower())->GetAttr()))
1799 {
1800 pPage = pNxt;
1801 pNxt = (SwPageFrm*)pPage->GetNext();
1802 continue;
1803 }
1804 }
1805 break;
1806 }
1807 }
1808 }
1809
1810 //Erstmal eine Fussnote und die benoetigten CntntFrms anlegen.
1811 if ( !pAttr->GetStartNode() )
1812 { ASSERT( !this, "Kein Fussnoteninhalt." );
1813 return;
1814 }
1815
1816 // Wenn es auf der Seite/Spalte bereits einen FtnCont gibt,
1817 // kann in einen spaltigen Bereich keiner erzeugt werden.
1818 if( pBoss->IsInSct() && pBoss->IsColumnFrm() && !pPage->IsFtnPage() )
1819 {
1820 SwSectionFrm* pSct = pBoss->FindSctFrm();
1821 if( bEnd ? !pSct->IsEndnAtEnd() : !pSct->IsFtnAtEnd() )
1822 {
1823 SwFtnContFrm* pFtnCont = pSct->FindFtnBossFrm(!bEnd)->FindFtnCont();
1824 if( pFtnCont )
1825 {
1826 SwFtnFrm* pTmp = (SwFtnFrm*)pFtnCont->Lower();
1827 if( bEnd )
1828 while( pTmp && !pTmp->GetAttr()->GetFtn().IsEndNote() )
1829 pTmp = (SwFtnFrm*)pTmp->GetNext();
1830 if( pTmp && *pTmp < pAttr )
1831 return;
1832 }
1833 }
1834 }
1835
1836 SwFtnFrm *pNew = new SwFtnFrm( pDoc->GetDfltFrmFmt(), pRef, pAttr );
1837 {
1838 SwNodeIndex aIdx( *pAttr->GetStartNode(), 1 );
1839 ::_InsertCnt( pNew, pDoc, aIdx.GetIndex() );
1840 }
1841 // Wenn die Seite gewechselt (oder gar neu angelegt) wurde,
1842 // muessen wir uns dort in die erste Spalte setzen
1843 if( bChgPage )
1844 {
1845 SwLayoutFrm* pBody = pPage->FindBodyCont();
1846 ASSERT( pBody, "AppendFtn: NoPageBody?" );
1847 if( pBody->Lower() && pBody->Lower()->IsColumnFrm() )
1848 pBoss = (SwFtnBossFrm*)pBody->Lower();
1849 else
1850 pBoss = pPage; // bei nichtspaltigen Seiten auf die Seite selbst
1851 }
1852 pBoss->InsertFtn( pNew );
1853 if ( pNew->GetUpper() ) //Eingesetzt oder nicht?
1854 {
1855 ::RegistFlys( pNew->FindPageFrm(), pNew );
1856 SwSectionFrm* pSect = FindSctFrm();
1857 // Der Inhalt des FtnContainers in einem (spaltigen) Bereich
1858 // braucht nur kalkuliert zu werden,
1859 // wenn der Bereich bereits bis zur Unterkante seines Uppers geht.
1860 if( pSect && !pSect->IsJoinLocked() && ( bEnd ? !pSect->IsEndnAtEnd() :
1861 !pSect->IsFtnAtEnd() ) && pSect->Growable() )
1862 pSect->InvalidateSize();
1863 else
1864 {
1865 // --> OD 2005-05-18 #i49383# - disable unlock of position of
1866 // lower objects during format of footnote content.
1867 const bool bOldFtnFrmLocked( pNew->IsColLocked() );
1868 pNew->ColLock();
1869 pNew->KeepLockPosOfLowerObjs();
1870 // --> OD 2006-02-02 #i57914# - adjust fix #i49383#
1871 // no extra notify for footnote frame
1872 // SwLayNotify* pFtnFrmNotitfy = new SwLayNotify( pNew );
1873 // <--
1874 SwCntntFrm *pCnt = pNew->ContainsCntnt();
1875 while ( pCnt && pCnt->FindFtnFrm()->GetAttr() == pAttr )
1876 {
1877 pCnt->Calc();
1878 // --> OD 2005-05-17 #i49383# - format anchored objects
1879 if ( pCnt->IsTxtFrm() && pCnt->IsValid() )
1880 {
1881 if ( !SwObjectFormatter::FormatObjsAtFrm( *pCnt,
1882 *(pCnt->FindPageFrm()) ) )
1883 {
1884 // restart format with first content
1885 pCnt = pNew->ContainsCntnt();
1886 continue;
1887 }
1888 }
1889 // <--
1890 pCnt = (SwCntntFrm*)pCnt->FindNextCnt();
1891 }
1892 // --> OD 2005-05-18 #i49383#
1893 if ( !bOldFtnFrmLocked )
1894 {
1895 pNew->ColUnlock();
1896 }
1897 // --> OD 2006-02-02 #i57914# - adjust fix #i49383#
1898 // enable lock of lower object position before format of footnote frame.
1899 pNew->UnlockPosOfLowerObjs();
1900 // <--
1901 pNew->Calc();
1902 // --> OD 2006-02-02 #i57914# - adjust fix #i49383#
1903 // no extra notify for footnote frame
1904 // pNew->UnlockPosOfLowerObjs();
1905 // delete pFtnFrmNotitfy;
1906 // <--
1907 if ( !bOldFtnFrmLocked && !pNew->GetLower() &&
1908 !pNew->IsColLocked() && !pNew->IsBackMoveLocked() )
1909 {
1910 pNew->Cut();
1911 delete pNew;
1912 }
1913 // <--
1914 }
1915 pMyPage->UpdateFtnNum();
1916 }
1917 else
1918 delete pNew;
1919 }
1920 /*************************************************************************
1921 |*
1922 |* SwFtnBossFrm::FindFtn()
1923 |*
1924 |* Ersterstellung MA 25. Feb. 93
1925 |* Letzte Aenderung AMA 29. Oct. 98
1926 |*
1927 |*************************************************************************/
1928
1929
1930 SwFtnFrm *SwFtnBossFrm::FindFtn( const SwCntntFrm *pRef, const SwTxtFtn *pAttr )
1931 {
1932 //Der einfachste und sicherste Weg geht ueber das Attribut.
1933 ASSERT( pAttr->GetStartNode(), "FtnAtr ohne StartNode." );
1934 SwNodeIndex aIdx( *pAttr->GetStartNode(), 1 );
1935 SwCntntNode *pNd = aIdx.GetNode().GetCntntNode();
1936 if ( !pNd )
1937 pNd = pRef->GetAttrSet()->GetDoc()->
1938 GetNodes().GoNextSection( &aIdx, TRUE, FALSE );
1939 if ( !pNd )
1940 return 0;
1941 SwClientIter aIter( *pNd );
1942 SwClient *pClient;
1943 if ( 0 != (pClient = aIter.GoStart()) )
1944 do
1945 {
1946 if ( pClient->IsA( TYPE(SwFrm) ) )
1947 {
1948 SwFrm *pFrm = ((SwFrm*)pClient)->GetUpper();
1949 // #i28500#, #i27243# Due to the endnode collector, there are
1950 // SwFtnFrms, which are not in the layout. Therefore the
1951 // bInfFtn flags are not set correctly, and a cell of FindFtnFrm
1952 // would return 0. Therefore we better call ImplFindFtnFrm().
1953 SwFtnFrm *pFtn = pFrm->ImplFindFtnFrm();
1954 if ( pFtn && pFtn->GetRef() == pRef )
1955 {
1956 // The following condition becomes true, if the whole
1957 // footnotecontent is a section. While no frames exist,
1958 // the HiddenFlag of the section is set, this causes
1959 // the GoNextSection-function leaves the footnote.
1960 if( pFtn->GetAttr() != pAttr )
1961 return 0;
1962 while ( pFtn && pFtn->GetMaster() )
1963 pFtn = pFtn->GetMaster();
1964 return pFtn;
1965 }
1966 }
1967 } while ( 0 != (pClient = aIter++) );
1968
1969 return 0;
1970 }
1971 /*************************************************************************
1972 |*
1973 |* SwFtnBossFrm::RemoveFtn()
1974 |*
1975 |* Ersterstellung MA 25. Feb. 93
1976 |* Letzte Aenderung AMA 29. Oct. 98
1977 |*
1978 |*************************************************************************/
1979
1980
1981 void SwFtnBossFrm::RemoveFtn( const SwCntntFrm *pRef, const SwTxtFtn *pAttr,
1982 BOOL bPrep )
1983 {
1984 SwFtnFrm *pFtn = FindFtn( pRef, pAttr );
1985 if( pFtn )
1986 {
1987 do
1988 {
1989 SwFtnFrm *pFoll = pFtn->GetFollow();
1990 pFtn->Cut();
1991 delete pFtn;
1992 pFtn = pFoll;
1993 } while ( pFtn );
1994 if( bPrep && pRef->IsFollow() )
1995 {
1996 ASSERT( pRef->IsTxtFrm(), "NoTxtFrm has Footnote?" );
1997 SwTxtFrm* pMaster = (SwTxtFrm*)pRef->FindMaster();
1998 if( !pMaster->IsLocked() )
1999 pMaster->Prepare( PREP_FTN_GONE );
2000 }
2001 }
2002 FindPageFrm()->UpdateFtnNum();
2003 }
2004
2005 /*************************************************************************
2006 |*
2007 |* SwFtnBossFrm::ChangeFtnRef()
2008 |*
2009 |* Ersterstellung MA 25. Feb. 93
2010 |* Letzte Aenderung AMA 29. Oct. 98
2011 |*
2012 |*************************************************************************/
2013
2014
2015 void SwFtnBossFrm::ChangeFtnRef( const SwCntntFrm *pOld, const SwTxtFtn *pAttr,
2016 SwCntntFrm *pNew )
2017 {
2018 SwFtnFrm *pFtn = FindFtn( pOld, pAttr );
2019 while ( pFtn )
2020 {
2021 pFtn->SetRef( pNew );
2022 pFtn = pFtn->GetFollow();
2023 }
2024 }
2025
2026 /*************************************************************************
2027 |*
2028 |* SwFtnBossFrm::CollectFtns()
2029 |*
2030 |* Ersterstellung MA 24. Jul. 95
2031 |* Letzte Aenderung AMA 29. Oct. 98
2032 |*
2033 |*************************************************************************/
2034
2035
2036 /// OD 03.04.2003 #108446# - add parameter <_bCollectOnlyPreviousFtns> in
2037 /// order to control, if only footnotes, which are positioned before the
2038 /// footnote boss frame <this> have to be collected.
2039 void SwFtnBossFrm::CollectFtns( const SwCntntFrm* _pRef,
2040 SwFtnBossFrm* _pOld,
2041 SvPtrarr& _rFtnArr,
2042 const sal_Bool _bCollectOnlyPreviousFtns )
2043 {
2044 SwFtnFrm *pFtn = _pOld->FindFirstFtn();
2045 while( !pFtn )
2046 {
2047 if( _pOld->IsColumnFrm() )
2048 { // Spalten abklappern
2049 while ( !pFtn && _pOld->GetPrev() )
2050 {
2051 //Wenn wir keine Fussnote gefunden haben, ist noch nicht alles zu
2052 //spaet. Die Schleife wird beim Aufnehmen von Follow-Zeilen durch
2053 //Tabellen benoetigt. Fuer alle anderen Faelle ist sie in der Lage
2054 //'krumme' Verhaeltnisse zu korrigieren.
2055 _pOld = (SwFtnBossFrm*)_pOld->GetPrev();
2056 pFtn = _pOld->FindFirstFtn();
2057 }
2058 }
2059 if( !pFtn )
2060 {
2061 // vorherige Seite
2062 SwPageFrm* pPg;
2063 for ( SwFrm* pTmp = _pOld;
2064 0 != ( pPg = (SwPageFrm*)pTmp->FindPageFrm()->GetPrev())
2065 && pPg->IsEmptyPage() ;
2066 )
2067 {
2068 pTmp = pPg;
2069 }
2070 if( !pPg )
2071 return;
2072
2073 SwLayoutFrm* pBody = pPg->FindBodyCont();
2074 if( pBody->Lower() && pBody->Lower()->IsColumnFrm() )
2075 {
2076 // mehrspaltige Seite => letzte Spalte suchen
2077 _pOld = static_cast<SwFtnBossFrm*>(pBody->GetLastLower());
2078 }
2079 else
2080 _pOld = pPg; // einspaltige Seite
2081 pFtn = _pOld->FindFirstFtn();
2082 }
2083 }
2084 // OD 03.04.2003 #108446# - consider new parameter <_bCollectOnlyPreviousFtns>
2085 SwFtnBossFrm* pRefBossFrm = NULL;
2086 if ( _bCollectOnlyPreviousFtns )
2087 {
2088 pRefBossFrm = this;
2089 }
2090 _CollectFtns( _pRef, pFtn, _rFtnArr, _bCollectOnlyPreviousFtns, pRefBossFrm );
2091 }
2092
2093
2094 /*************************************************************************
2095 |*
2096 |* SwFtnBossFrm::_CollectFtns()
2097 |*
2098 |* Ersterstellung MA 24. Jul. 95
2099 |* Letzte Aenderung AMA 29. Oct. 98
2100 |*
2101 |*************************************************************************/
2102 inline void FtnInArr( SvPtrarr& rFtnArr, SwFtnFrm* pFtn )
2103 {
2104 if ( USHRT_MAX == rFtnArr.GetPos( (VoidPtr)pFtn ) )
2105 rFtnArr.Insert( (VoidPtr)pFtn, rFtnArr.Count() );
2106 }
2107
2108 /// OD 03.04.2003 #108446# - add parameters <_bCollectOnlyPreviousFtns> and
2109 /// <_pRefFtnBossFrm> in order to control, if only footnotes, which are positioned
2110 /// before the given reference footnote boss frame have to be collected.
2111 /// Note: if parameter <_bCollectOnlyPreviousFtns> is true, then parameter
2112 /// <_pRefFtnBossFrm> have to be referenced to an object.
2113 /// Adjust parameter names.
2114 void SwFtnBossFrm::_CollectFtns( const SwCntntFrm* _pRef,
2115 SwFtnFrm* _pFtn,
2116 SvPtrarr& _rFtnArr,
2117 sal_Bool _bCollectOnlyPreviousFtns,
2118 const SwFtnBossFrm* _pRefFtnBossFrm)
2119 {
2120 // OD 03.04.2003 #108446# - assert, that no reference footnote boss frame
2121 // is set, in spite of the order, that only previous footnotes has to be
2122 // collected.
2123 ASSERT( !_bCollectOnlyPreviousFtns || _pRefFtnBossFrm,
2124 "<SwFtnBossFrm::_CollectFtns(..)> - No reference footnote boss frame for collecting only previous footnotes set.\nCrash will be caused!" );
2125
2126 //Alle Fussnoten die von pRef referenziert werden nacheinander
2127 //einsammeln (Attribut fuer Attribut), zusammengefuegen
2128 //(der Inhalt zu einem Attribut kann ueber mehrere Seiten verteilt sein)
2129 //und ausschneiden.
2130
2131 SvPtrarr aNotFtnArr( 20, 20 ); //Zur Robustheit werden hier die nicht
2132 //dazugehoerigen Fussnoten eingetragen.
2133 //Wenn eine Fussnote zweimal angefasst wird
2134 //ists vorbei! So kommt die Funktion auch
2135 //noch mit einem kaputten Layout
2136 //einigermassen (ohne Schleife und Absturz)
2137 //"klar".
2138
2139 //Hier sollte keiner mit einer Follow-Ftn ankommen, es sei denn er hat
2140 //ernste Absichten (:-)); spricht er kommt mit einer Ftn an die vor der
2141 //ersten der Referenz liegt.
2142 ASSERT( !_pFtn->GetMaster() || _pFtn->GetRef() != _pRef, "FollowFtn moven?" );
2143 while ( _pFtn->GetMaster() )
2144 _pFtn = _pFtn->GetMaster();
2145
2146 BOOL bFound = FALSE;
2147
2148 while ( _pFtn )
2149 {
2150 //Erstmal die naechste Fussnote der Spalte/Seite suchen, damit wir nicht
2151 //nach dem Cut jeder Fussnote von vorn anfangen muessen.
2152 SwFtnFrm *pNxtFtn = _pFtn;
2153 while ( pNxtFtn->GetFollow() )
2154 pNxtFtn = pNxtFtn->GetFollow();
2155 pNxtFtn = (SwFtnFrm*)pNxtFtn->GetNext();
2156
2157 if ( !pNxtFtn )
2158 {
2159 SwFtnBossFrm* pBoss = _pFtn->FindFtnBossFrm();
2160 SwPageFrm* pPage = pBoss->FindPageFrm();
2161 do
2162 {
2163 lcl_NextFtnBoss( pBoss, pPage, FALSE );
2164 if( pBoss )
2165 {
2166 SwLayoutFrm* pCont = pBoss->FindFtnCont();
2167 if( pCont )
2168 {
2169 pNxtFtn = (SwFtnFrm*)pCont->Lower();
2170 if( pNxtFtn )
2171 {
2172 while( pNxtFtn->GetMaster() )
2173 pNxtFtn = pNxtFtn->GetMaster();
2174 if( pNxtFtn == _pFtn )
2175 pNxtFtn = NULL;
2176 }
2177 }
2178 }
2179 } while( !pNxtFtn && pBoss );
2180 }
2181 else if( !pNxtFtn->GetAttr()->GetFtn().IsEndNote() )
2182 { ASSERT( !pNxtFtn->GetMaster(), "_CollectFtn: Master exspected" );
2183 while ( pNxtFtn->GetMaster() )
2184 pNxtFtn = pNxtFtn->GetMaster();
2185 }
2186 if ( pNxtFtn == _pFtn )
2187 {
2188 ASSERT( FALSE, "_CollectFtn: Devil's circle" );
2189 pNxtFtn = 0;
2190 }
2191
2192 // OD 03.04.2003 #108446# - determine, if found footnote has to be collected.
2193 sal_Bool bCollectFoundFtn = sal_False;
2194 if ( _pFtn->GetRef() == _pRef && !_pFtn->GetAttr()->GetFtn().IsEndNote() )
2195 {
2196 if ( _bCollectOnlyPreviousFtns )
2197 {
2198 SwFtnBossFrm* pBossOfFoundFtn = _pFtn->FindFtnBossFrm( sal_True );
2199 ASSERT( pBossOfFoundFtn,
2200 "<SwFtnBossFrm::_CollectFtns(..)> - footnote boss frame of found footnote frame missing.\nWrong layout!" );
2201 if ( !pBossOfFoundFtn || // don't crash, if no footnote boss is found.
2202 pBossOfFoundFtn->IsBefore( _pRefFtnBossFrm )
2203 )
2204 {
2205 bCollectFoundFtn = sal_True;
2206 }
2207 }
2208 else
2209 {
2210 bCollectFoundFtn = sal_True;
2211 }
2212 }
2213
2214 if ( bCollectFoundFtn )
2215 {
2216 ASSERT( !_pFtn->GetMaster(), "FollowFtn moven?" );
2217 SwFtnFrm *pNxt = _pFtn->GetFollow();
2218 while ( pNxt )
2219 {
2220 SwFrm *pCnt = pNxt->ContainsAny();
2221 if ( pCnt )
2222 { //Unterwegs wird der Follow zerstoert weil er leer wird!
2223 do
2224 { SwFrm *pNxtCnt = pCnt->GetNext();
2225 pCnt->Cut();
2226 pCnt->Paste( _pFtn );
2227 pCnt = pNxtCnt;
2228 } while ( pCnt );
2229 }
2230 else
2231 { ASSERT( !pNxt, "Fussnote ohne Inhalt?" );
2232 pNxt->Cut();
2233 delete pNxt;
2234 }
2235 pNxt = _pFtn->GetFollow();
2236 }
2237 _pFtn->Cut();
2238 FtnInArr( _rFtnArr, _pFtn );
2239 bFound = TRUE;
2240 }
2241 else
2242 {
2243 FtnInArr( aNotFtnArr, _pFtn );
2244 if( bFound )
2245 break;
2246 }
2247 if ( pNxtFtn &&
2248 USHRT_MAX == _rFtnArr.GetPos( (VoidPtr)pNxtFtn ) &&
2249 USHRT_MAX == aNotFtnArr.GetPos( (VoidPtr)pNxtFtn ) )
2250 _pFtn = pNxtFtn;
2251 else
2252 break;
2253 }
2254 }
2255
2256 /*************************************************************************
2257 |*
2258 |* SwFtnBossFrm::_MoveFtns()
2259 |*
2260 |* Ersterstellung MA 26. Feb. 93
2261 |* Letzte Aenderung AMA 29. Oct. 98
2262 |*
2263 |*************************************************************************/
2264
2265
2266 void SwFtnBossFrm::_MoveFtns( SvPtrarr &rFtnArr, BOOL bCalc )
2267 {
2268 //Alle Fussnoten die von pRef referenziert werden muessen von der
2269 //aktuellen Position, die sich durch die alte Spalte/Seite ergab, auf eine
2270 //neue Position, bestimmt durch die neue Spalte/Seite, gemoved werden.
2271 const USHORT nMyNum = FindPageFrm()->GetPhyPageNum();
2272 const USHORT nMyCol = lcl_ColumnNum( this );
2273 SWRECTFN( this )
2274
2275 // --> OD 2004-06-11 #i21478# - keep last inserted footnote in order to
2276 // format the content of the following one.
2277 SwFtnFrm* pLastInsertedFtn = 0L;
2278 for ( USHORT i = 0; i < rFtnArr.Count(); ++i )
2279 {
2280 SwFtnFrm *pFtn = (SwFtnFrm*)rFtnArr[i];
2281
2282 SwFtnBossFrm* pRefBoss = pFtn->GetRef()->FindFtnBossFrm( TRUE );
2283 if( pRefBoss != this )
2284 {
2285 const USHORT nRefNum = pRefBoss->FindPageFrm()->GetPhyPageNum();
2286 const USHORT nRefCol = lcl_ColumnNum( this );
2287 if( nRefNum < nMyNum || ( nRefNum == nMyNum && nRefCol <= nMyCol ) )
2288 pRefBoss = this;
2289 }
2290 pRefBoss->InsertFtn( pFtn );
2291
2292 if ( pFtn->GetUpper() ) //Robust, z.B. bei doppelten
2293 {
2294 // Damit FtnFrms, die nicht auf die Seite passen, nicht fuer zuviel
2295 // Unruhe sorgen (Loop 66312), wird ihr Inhalt zunaechst zusammengestaucht.
2296 // Damit wird der FtnCont erst gegrowt, wenn der Inhalt formatiert wird
2297 // und feststellt, dass er auf die Seite passt.
2298 SwFrm *pCnt = pFtn->ContainsAny();
2299 while( pCnt )
2300 {
2301 if( pCnt->IsLayoutFrm() )
2302 {
2303 SwFrm* pTmp = ((SwLayoutFrm*)pCnt)->ContainsAny();
2304 while( pTmp && ((SwLayoutFrm*)pCnt)->IsAnLower( pTmp ) )
2305 {
2306 pTmp->Prepare( PREP_MOVEFTN );
2307 (pTmp->Frm().*fnRect->fnSetHeight)(0);
2308 (pTmp->Prt().*fnRect->fnSetHeight)(0);
2309 pTmp = pTmp->FindNext();
2310 }
2311 }
2312 else
2313 pCnt->Prepare( PREP_MOVEFTN );
2314 (pCnt->Frm().*fnRect->fnSetHeight)(0);
2315 (pCnt->Prt().*fnRect->fnSetHeight)(0);
2316 pCnt = pCnt->GetNext();
2317 }
2318 (pFtn->Frm().*fnRect->fnSetHeight)(0);
2319 (pFtn->Prt().*fnRect->fnSetHeight)(0);
2320 pFtn->Calc();
2321 pFtn->GetUpper()->Calc();
2322
2323 if( bCalc )
2324 {
2325 SwTxtFtn *pAttr = pFtn->GetAttr();
2326 pCnt = pFtn->ContainsAny();
2327 BOOL bUnlock = !pFtn->IsBackMoveLocked();
2328 pFtn->LockBackMove();
2329
2330 // --> OD 2005-05-18 #i49383# - disable unlock of position of
2331 // lower objects during format of footnote content.
2332 pFtn->KeepLockPosOfLowerObjs();
2333 // --> OD 2006-02-02 #i57914# - adjust fix #i49383#
2334 // no extra notify for footnote frame
2335 // SwLayNotify aFtnFrmNotitfy( pFtn );
2336 // <--
2337
2338 while ( pCnt && pCnt->FindFtnFrm()->GetAttr() == pAttr )
2339 {
2340 pCnt->_InvalidatePos();
2341 pCnt->Calc();
2342 // --> OD 2005-05-17 #i49383# - format anchored objects
2343 if ( pCnt->IsTxtFrm() && pCnt->IsValid() )
2344 {
2345 if ( !SwObjectFormatter::FormatObjsAtFrm( *pCnt,
2346 *(pCnt->FindPageFrm()) ) )
2347 {
2348 // restart format with first content
2349 pCnt = pFtn->ContainsAny();
2350 continue;
2351 }
2352 }
2353 // <--
2354 if( pCnt->IsSctFrm() )
2355 { // Wenn es sich um einen nichtleeren Bereich handelt,
2356 // iterieren wir auch ueber seinen Inhalt
2357 SwFrm* pTmp = ((SwSectionFrm*)pCnt)->ContainsAny();
2358 if( pTmp )
2359 pCnt = pTmp;
2360 else
2361 pCnt = pCnt->FindNext();
2362 }
2363 else
2364 pCnt = pCnt->FindNext();
2365 }
2366 if( bUnlock )
2367 {
2368 pFtn->UnlockBackMove();
2369 if( !pFtn->ContainsAny() && !pFtn->IsColLocked() )
2370 {
2371 pFtn->Cut();
2372 delete pFtn;
2373 // --> OD 2004-06-10 #i21478#
2374 pFtn = 0L;
2375 }
2376 }
2377 // --> OD 2005-05-18 #i49383#
2378 if ( pFtn )
2379 {
2380 // --> OD 2006-02-02 #i57914# - adjust fix #i49383#
2381 // enable lock of lower object position before format of footnote frame.
2382 pFtn->UnlockPosOfLowerObjs();
2383 pFtn->Calc();
2384 // pFtn->UnlockPosOfLowerObjs();
2385 // <--
2386 }
2387 // --> OD 2006-02-02 #i57914# - adjust fix #i49383#
2388 // no extra notify for footnote frame
2389 // else
2390 // {
2391 // aFtnFrmNotitfy.FrmDeleted();
2392 // }
2393 // <--
2394 }
2395 }
2396 else
2397 { ASSERT( !pFtn->GetMaster() && !pFtn->GetFollow(),
2398 "DelFtn und Master/Follow?" );
2399 delete pFtn;
2400 // --> OD 2004-06-10 #i21478#
2401 pFtn = 0L;
2402 }
2403
2404 // --> OD 2004-06-10 #i21478#
2405 if ( pFtn )
2406 {
2407 pLastInsertedFtn = pFtn;
2408 }
2409 }
2410
2411 // --> OD 2004-06-10 #i21478# - format content of footnote following
2412 // the new inserted ones.
2413 if ( bCalc && pLastInsertedFtn )
2414 {
2415 if ( pLastInsertedFtn->GetNext() )
2416 {
2417 SwFtnFrm* pNextFtn = static_cast<SwFtnFrm*>(pLastInsertedFtn->GetNext());
2418 SwTxtFtn* pAttr = pNextFtn->GetAttr();
2419 SwFrm* pCnt = pNextFtn->ContainsAny();
2420
2421 BOOL bUnlock = !pNextFtn->IsBackMoveLocked();
2422 pNextFtn->LockBackMove();
2423 // --> OD 2005-05-18 #i49383# - disable unlock of position of
2424 // lower objects during format of footnote content.
2425 pNextFtn->KeepLockPosOfLowerObjs();
2426 // --> OD 2006-02-02 #i57914# - adjust fix #i49383#
2427 // no extra notify for footnote frame
2428 // SwLayNotify aFtnFrmNotitfy( pNextFtn );
2429 // <--
2430
2431 while ( pCnt && pCnt->FindFtnFrm()->GetAttr() == pAttr )
2432 {
2433 pCnt->_InvalidatePos();
2434 pCnt->Calc();
2435 // --> OD 2005-05-17 #i49383# - format anchored objects
2436 if ( pCnt->IsTxtFrm() && pCnt->IsValid() )
2437 {
2438 if ( !SwObjectFormatter::FormatObjsAtFrm( *pCnt,
2439 *(pCnt->FindPageFrm()) ) )
2440 {
2441 // restart format with first content
2442 pCnt = pNextFtn->ContainsAny();
2443 continue;
2444 }
2445 }
2446 // <--
2447 if( pCnt->IsSctFrm() )
2448 { // Wenn es sich um einen nichtleeren Bereich handelt,
2449 // iterieren wir auch ueber seinen Inhalt
2450 SwFrm* pTmp = ((SwSectionFrm*)pCnt)->ContainsAny();
2451 if( pTmp )
2452 pCnt = pTmp;
2453 else
2454 pCnt = pCnt->FindNext();
2455 }
2456 else
2457 pCnt = pCnt->FindNext();
2458 }
2459 if( bUnlock )
2460 {
2461 pNextFtn->UnlockBackMove();
2462 }
2463 // --> OD 2005-05-18 #i49383#
2464 // --> OD 2006-02-02 #i57914# - adjust fix #i49383#
2465 // enable lock of lower object position before format of footnote frame.
2466 pNextFtn->UnlockPosOfLowerObjs();
2467 pNextFtn->Calc();
2468 // pNextFtn->UnlockPosOfLowerObjs();
2469 // <--
2470 }
2471 }
2472 }
2473
2474 /*************************************************************************
2475 |*
2476 |* SwFtnBossFrm::MoveFtns()
2477 |*
2478 |* Ersterstellung BP 05. Aug. 93
2479 |* Letzte Aenderung AMA 29. Oct. 98
2480 |*
2481 |*************************************************************************/
2482
2483
2484 void SwFtnBossFrm::MoveFtns( const SwCntntFrm *pSrc, SwCntntFrm *pDest,
2485 SwTxtFtn *pAttr )
2486 {
2487 if( ( GetFmt()->GetDoc()->GetFtnInfo().ePos == FTNPOS_CHAPTER &&
2488 (!GetUpper()->IsSctFrm() || !((SwSectionFrm*)GetUpper())->IsFtnAtEnd()))
2489 || pAttr->GetFtn().IsEndNote() )
2490 return;
2491
2492 ASSERT( this == pSrc->FindFtnBossFrm( TRUE ),
2493 "SwPageFrm::MoveFtns: source frame isn't on that FtnBoss" );
2494
2495 SwFtnFrm *pFtn = FindFirstFtn();
2496 if( pFtn )
2497 {
2498 ChangeFtnRef( pSrc, pAttr, pDest );
2499 SwFtnBossFrm *pDestBoss = pDest->FindFtnBossFrm( TRUE );
2500 ASSERT( pDestBoss, "+SwPageFrm::MoveFtns: no destination boss" );
2501 if( pDestBoss ) // robust
2502 {
2503 SvPtrarr aFtnArr( 5, 5 );
2504 pDestBoss->_CollectFtns( pDest, pFtn, aFtnArr );
2505 if ( aFtnArr.Count() )
2506 {
2507 pDestBoss->_MoveFtns( aFtnArr, TRUE );
2508 SwPageFrm* pSrcPage = FindPageFrm();
2509 SwPageFrm* pDestPage = pDestBoss->FindPageFrm();
2510 // Nur beim Seitenwechsel FtnNum Updaten
2511 if( pSrcPage != pDestPage )
2512 {
2513 if( pSrcPage->GetPhyPageNum() > pDestPage->GetPhyPageNum() )
2514 pSrcPage->UpdateFtnNum();
2515 pDestPage->UpdateFtnNum();
2516 }
2517 }
2518 }
2519 }
2520 }
2521
2522 /*************************************************************************
2523 |*
2524 |* SwFtnBossFrm::RearrangeFtns()
2525 |*
2526 |* Ersterstellung MA 20. Jan. 94
2527 |* Letzte Aenderung AMA 29. Oct. 98
2528 |*
2529 |*************************************************************************/
2530
2531
2532 void SwFtnBossFrm::RearrangeFtns( const SwTwips nDeadLine, const BOOL bLock,
2533 const SwTxtFtn *pAttr )
2534 {
2535 //Alle Fussnoten der Spalte/Seite dergestalt anformatieren,
2536 //dass sie ggf. die Spalte/Seite wechseln.
2537
2538 SwSaveFtnHeight aSave( this, nDeadLine );
2539 SwFtnFrm *pFtn = FindFirstFtn();
2540 if( pFtn && pFtn->GetPrev() && bLock )
2541 {
2542 SwFtnFrm* pFirst = (SwFtnFrm*)pFtn->GetUpper()->Lower();
2543 SwFrm* pCntnt = pFirst->ContainsAny();
2544 if( pCntnt )
2545 {
2546 BOOL bUnlock = !pFirst->IsBackMoveLocked();
2547 pFirst->LockBackMove();
2548 pFirst->Calc();
2549 pCntnt->Calc();
2550 // --> OD 2005-05-17 #i49383# - format anchored objects
2551 if ( pCntnt->IsTxtFrm() && pCntnt->IsValid() )
2552 {
2553 SwObjectFormatter::FormatObjsAtFrm( *pCntnt,
2554 *(pCntnt->FindPageFrm()) );
2555 }
2556 // <--
2557 if( bUnlock )
2558 pFirst->UnlockBackMove();
2559 }
2560 pFtn = FindFirstFtn();
2561 }
2562 SwDoc *pDoc = GetFmt()->GetDoc();
2563 const ULONG nFtnPos = pAttr ? ::lcl_FindFtnPos( pDoc, pAttr ) : 0;
2564 SwFrm *pCnt = pFtn ? pFtn->ContainsAny() : 0;
2565 if ( pCnt )
2566 {
2567 BOOL bMore = TRUE;
2568 BOOL bStart = pAttr == 0; // wenn kein Attribut uebergeben wird, alle bearbeiten
2569 // --> OD 2005-05-18 #i49383# - disable unlock of position of
2570 // lower objects during format of footnote and footnote content.
2571 SwFtnFrm* pLastFtnFrm( 0L );
2572 // --> OD 2006-02-02 #i57914# - adjust fix #i49383#
2573 // no extra notify for footnote frame
2574 // SwLayNotify* pFtnFrmNotify( 0L );
2575 // footnote frame needs to be locked, if <bLock> isn't set.
2576 bool bUnlockLastFtnFrm( false );
2577 // <--
2578 do
2579 {
2580 if( !bStart )
2581 bStart = ::lcl_FindFtnPos( pDoc, pCnt->FindFtnFrm()->GetAttr() )
2582 == nFtnPos;
2583 if( bStart )
2584 {
2585 pCnt->_InvalidatePos();
2586 pCnt->_InvalidateSize();
2587 pCnt->Prepare( PREP_ADJUST_FRM );
2588 SwFtnFrm* pFtnFrm = pCnt->FindFtnFrm();
2589 // --> OD 2005-05-18 #i49383#
2590 if ( pFtnFrm != pLastFtnFrm )
2591 {
2592 if ( pLastFtnFrm )
2593 {
2594 if ( !bLock && bUnlockLastFtnFrm )
2595 {
2596 pLastFtnFrm->ColUnlock();
2597 }
2598 // --> OD 2006-02-02 #i57914# - adjust fix #i49383#
2599 // enable lock of lower object position before format of footnote frame.
2600 pLastFtnFrm->UnlockPosOfLowerObjs();
2601 pLastFtnFrm->Calc();
2602 // pLastFtnFrm->UnlockPosOfLowerObjs();
2603 // no extra notify for footnote frame
2604 // delete pFtnFrmNotify;
2605 // <--
2606 if ( !bLock && bUnlockLastFtnFrm &&
2607 !pLastFtnFrm->GetLower() &&
2608 !pLastFtnFrm->IsColLocked() &&
2609 !pLastFtnFrm->IsBackMoveLocked() )
2610 {
2611 pLastFtnFrm->Cut();
2612 delete pLastFtnFrm;
2613 pLastFtnFrm = 0L;
2614 }
2615 }
2616 if ( !bLock )
2617 {
2618 bUnlockLastFtnFrm = !pFtnFrm->IsColLocked();
2619 pFtnFrm->ColLock();
2620 }
2621 pFtnFrm->KeepLockPosOfLowerObjs();
2622 pLastFtnFrm = pFtnFrm;
2623 // --> OD 2006-02-02 #i57914# - adjust fix #i49383#
2624 // no extra notify for footnote frame
2625 // pFtnFrmNotify = new SwLayNotify( pLastFtnFrm );
2626 // <--
2627 }
2628 // <--
2629 // OD 30.10.2002 #97265# - invalidate position of footnote
2630 // frame, if it's below its footnote container, in order to
2631 // assure its correct position, probably calculating its previous
2632 // footnote frames.
2633 {
2634 SWRECTFN( this );
2635 SwFrm* aFtnContFrm = pFtnFrm->GetUpper();
2636 if ( (pFtnFrm->Frm().*fnRect->fnTopDist)((aFtnContFrm->*fnRect->fnGetPrtBottom)()) > 0 )
2637 {
2638 pFtnFrm->_InvalidatePos();
2639 }
2640 }
2641 if ( bLock )
2642 {
2643 BOOL bUnlock = !pFtnFrm->IsBackMoveLocked();
2644 pFtnFrm->LockBackMove();
2645 pFtnFrm->Calc();
2646 pCnt->Calc();
2647 // --> OD 2005-05-17 #i49383# - format anchored objects
2648 if ( pCnt->IsTxtFrm() && pCnt->IsValid() )
2649 {
2650 if ( !SwObjectFormatter::FormatObjsAtFrm( *pCnt,
2651 *(pCnt->FindPageFrm()) ) )
2652 {
2653 // restart format with first content
2654 pCnt = pFtn->ContainsAny();
2655 continue;
2656 }
2657 }
2658 // <--
2659 if( bUnlock )
2660 {
2661 pFtnFrm->UnlockBackMove();
2662 if( !pFtnFrm->Lower() &&
2663 !pFtnFrm->IsColLocked() )
2664 {
2665 // --> OD 2005-08-10 #i49383#
2666 ASSERT( pLastFtnFrm == pFtnFrm,
2667 "<SwFtnBossFrm::RearrangeFtns(..)> - <pLastFtnFrm> != <pFtnFrm>" );
2668 pLastFtnFrm = 0L;
2669 // --> OD 2006-02-02 #i57914# - adjust fix #i49383#
2670 // no extra notify for footnote frame
2671 // pFtnFrmNotify->FrmDeleted();
2672 // delete pFtnFrmNotify;
2673 // <--
2674 pFtnFrm->Cut();
2675 delete pFtnFrm;
2676 }
2677 }
2678 }
2679 else
2680 {
2681 pFtnFrm->Calc();
2682 pCnt->Calc();
2683 // --> OD 2005-05-17 #i49383# - format anchored objects
2684 if ( pCnt->IsTxtFrm() && pCnt->IsValid() )
2685 {
2686 if ( !SwObjectFormatter::FormatObjsAtFrm( *pCnt,
2687 *(pCnt->FindPageFrm()) ) )
2688 {
2689 // restart format with first content
2690 pCnt = pFtn->ContainsAny();
2691 continue;
2692 }
2693 }
2694 // <--
2695 }
2696 }
2697 SwSectionFrm *pDel = NULL;
2698 if( pCnt->IsSctFrm() )
2699 {
2700 SwFrm* pTmp = ((SwSectionFrm*)pCnt)->ContainsAny();
2701 if( pTmp )
2702 {
2703 pCnt = pTmp;
2704 continue;
2705 }
2706 pDel = (SwSectionFrm*)pCnt;
2707 }
2708 if ( pCnt->GetNext() )
2709 pCnt = pCnt->GetNext();
2710 else
2711 {
2712 pCnt = pCnt->FindNext();
2713 if ( pCnt )
2714 {
2715 SwFtnFrm* pFtnFrm = pCnt->FindFtnFrm();
2716 if( pFtnFrm->GetRef()->FindFtnBossFrm(
2717 pFtnFrm->GetAttr()->GetFtn().IsEndNote() ) != this )
2718 bMore = FALSE;
2719 }
2720 else
2721 bMore = FALSE;
2722 }
2723 if( pDel )
2724 {
2725 pDel->Cut();
2726 delete pDel;
2727 }
2728 if ( bMore )
2729 {
2730 //Nicht weiter als bis zur angegebenen Fussnote, falls eine
2731 //angegeben wurde.
2732 if ( pAttr &&
2733 (::lcl_FindFtnPos( pDoc,
2734 pCnt->FindFtnFrm()->GetAttr()) > nFtnPos ) )
2735 bMore = FALSE;
2736 }
2737 } while ( bMore );
2738 // --> OD 2005-05-18 #i49383#
2739 if ( pLastFtnFrm )
2740 {
2741 if ( !bLock && bUnlockLastFtnFrm )
2742 {
2743 pLastFtnFrm->ColUnlock();
2744 }
2745 // --> OD 2006-02-02 #i57914# - adjust fix #i49383#
2746 // enable lock of lower object position before format of footnote frame.
2747 pLastFtnFrm->UnlockPosOfLowerObjs();
2748 pLastFtnFrm->Calc();
2749 // pLastFtnFrm->UnlockPosOfLowerObjs();
2750 // no extra notify for footnote frame
2751 // delete pFtnFrmNotify;
2752 // <--
2753 if ( !bLock && bUnlockLastFtnFrm &&
2754 !pLastFtnFrm->GetLower() &&
2755 !pLastFtnFrm->IsColLocked() &&
2756 !pLastFtnFrm->IsBackMoveLocked() )
2757 {
2758 pLastFtnFrm->Cut();
2759 delete pLastFtnFrm;
2760 }
2761 }
2762 // <--
2763 }
2764 }
2765
2766 /*************************************************************************
2767 |*
2768 |* SwPageFrm::UpdateFtnNum()
2769 |*
2770 |* Ersterstellung MA 02. Mar. 93
2771 |* Letzte Aenderung AMA 29. Oct. 98
2772 |*
2773 |*************************************************************************/
2774
2775 void SwPageFrm::UpdateFtnNum()
2776 {
2777 //Seitenweise Numerierung nur wenn es am Dokument so eingestellt ist.
2778 if ( GetFmt()->GetDoc()->GetFtnInfo().eNum != FTNNUM_PAGE )
2779 return;
2780
2781 SwLayoutFrm* pBody = FindBodyCont();
2782 if( !pBody || !pBody->Lower() )
2783 return;
2784
2785 SwCntntFrm* pCntnt = pBody->ContainsCntnt();
2786 USHORT nNum = 0;
2787
2788 while( pCntnt && pCntnt->FindPageFrm() == this )
2789 {
2790 if( ((SwTxtFrm*)pCntnt)->HasFtn() )
2791 {
2792 SwFtnBossFrm* pBoss = pCntnt->FindFtnBossFrm( TRUE );
2793 if( pBoss->GetUpper()->IsSctFrm() &&
2794 ((SwSectionFrm*)pBoss->GetUpper())->IsOwnFtnNum() )
2795 pCntnt = ((SwSectionFrm*)pBoss->GetUpper())->FindLastCntnt();
2796 else
2797 {
2798 SwFtnFrm* pFtn = (SwFtnFrm*)pBoss->FindFirstFtn( pCntnt );
2799 while( pFtn )
2800 {
2801 SwTxtFtn* pTxtFtn = pFtn->GetAttr();
2802 if( !pTxtFtn->GetFtn().IsEndNote() &&
2803 !pTxtFtn->GetFtn().GetNumStr().Len() &&
2804 !pFtn->GetMaster() &&
2805 (pTxtFtn->GetFtn().GetNumber() != ++nNum) )
2806 pTxtFtn->SetNumber( nNum );
2807 if ( pFtn->GetNext() )
2808 pFtn = (SwFtnFrm*)pFtn->GetNext();
2809 else
2810 {
2811 SwFtnBossFrm* pTmpBoss = pFtn->FindFtnBossFrm( TRUE );
2812 SwPageFrm* pPage = pTmpBoss->FindPageFrm();
2813 pFtn = NULL;
2814 lcl_NextFtnBoss( pTmpBoss, pPage, FALSE );
2815 if( pTmpBoss )
2816 {
2817 SwFtnContFrm *pCont = pTmpBoss->FindNearestFtnCont();
2818 if ( pCont )
2819 pFtn = (SwFtnFrm*)pCont->Lower();
2820 }
2821 }
2822 if( pFtn && pFtn->GetRef() != pCntnt )
2823 pFtn = NULL;
2824 }
2825 }
2826 }
2827 pCntnt = pCntnt->FindNextCnt();
2828 }
2829 }
2830
2831 /*************************************************************************
2832 |*
2833 |* SwFtnBossFrm::SetFtnDeadLine()
2834 |*
2835 |* Ersterstellung MA 02. Aug. 93
2836 |* Letzte Aenderung MA 16. Nov. 98
2837 |*
2838 |*************************************************************************/
2839
2840 void SwFtnBossFrm::SetFtnDeadLine( const SwTwips nDeadLine )
2841 {
2842 SwFrm *pBody = FindBodyCont();
2843 pBody->Calc();
2844
2845 SwFrm *pCont = FindFtnCont();
2846 const SwTwips nMax = nMaxFtnHeight;//Aktuelle MaxHeight nicht ueberschreiten.
2847 SWRECTFN( this )
2848 if ( pCont )
2849 {
2850 pCont->Calc();
2851 nMaxFtnHeight = -(pCont->Frm().*fnRect->fnBottomDist)( nDeadLine );
2852 }
2853 else
2854 nMaxFtnHeight = -(pBody->Frm().*fnRect->fnBottomDist)( nDeadLine );
2855
2856 if ( GetFmt()->getIDocumentSettingAccess()->get(IDocumentSettingAccess::BROWSE_MODE) )
2857 nMaxFtnHeight += pBody->Grow( LONG_MAX, TRUE );
2858 if ( IsInSct() )
2859 nMaxFtnHeight += FindSctFrm()->Grow( LONG_MAX, TRUE );
2860
2861 if ( nMaxFtnHeight < 0 )
2862 nMaxFtnHeight = 0;
2863 if ( nMax != LONG_MAX && nMaxFtnHeight > nMax )
2864 nMaxFtnHeight = nMax;
2865 }
2866
2867 /*************************************************************************
2868 |*
2869 |* SwFtnBossFrm::GetVarSpace()
2870 |*
2871 |* Ersterstellung MA 03. Apr. 95
2872 |* Letzte Aenderung MA 16. Nov. 98
2873 |*
2874 |*************************************************************************/
2875 SwTwips SwFtnBossFrm::GetVarSpace() const
2876 {
2877 //Fuer Seiten soll ein Wert von 20% der Seitenhoehe nicht unterschritten
2878 //werden (->AMA: was macht MS da?)
2879 //->AMA: Was ist da fuer Bereiche sinnvoll (und kompatibel zu MS ;-)?
2880 //AMA: MS kennt scheinbar kein Begrenzung, die Fussnoten nehmen durchaus
2881 // die ganze Seite/Spalte ein.
2882
2883 const SwPageFrm* pPg = FindPageFrm();
2884 ASSERT( pPg || IsInSct(), "Footnote lost page" );
2885
2886 const SwFrm *pBody = FindBodyCont();
2887 SwTwips nRet;
2888 if( pBody )
2889 {
2890 SWRECTFN( this )
2891 if( IsInSct() )
2892 {
2893 nRet = 0;
2894 SwTwips nTmp = (*fnRect->fnYDiff)( (pBody->*fnRect->fnGetPrtTop)(),
2895 (Frm().*fnRect->fnGetTop)() );
2896 const SwSectionFrm* pSect = FindSctFrm();
2897 // Endnotes in a ftncontainer causes a deadline:
2898 // the bottom of the last contentfrm
2899 if( pSect->IsEndnAtEnd() ) // endnotes allowed?
2900 {
2901 ASSERT( !Lower() || !Lower()->GetNext() || Lower()->GetNext()->
2902 IsFtnContFrm(), "FtnContainer exspected" );
2903 const SwFtnContFrm* pCont = Lower() ?
2904 (SwFtnContFrm*)Lower()->GetNext() : 0;
2905 if( pCont )
2906 {
2907 SwFtnFrm* pFtn = (SwFtnFrm*)pCont->Lower();
2908 while( pFtn)
2909 {
2910 if( pFtn->GetAttr()->GetFtn().IsEndNote() )
2911 { // endnote found
2912 SwFrm* pFrm = ((SwLayoutFrm*)Lower())->Lower();
2913 if( pFrm )
2914 {
2915 while( pFrm->GetNext() )
2916 pFrm = pFrm->GetNext(); // last cntntfrm
2917 nTmp += (*fnRect->fnYDiff)(
2918 (Frm().*fnRect->fnGetTop)(),
2919 (pFrm->Frm().*fnRect->fnGetBottom)() );
2920 }
2921 break;
2922 }
2923 pFtn = (SwFtnFrm*)pFtn->GetNext();
2924 }
2925 }
2926 }
2927 if( nTmp < nRet )
2928 nRet = nTmp;
2929 }
2930 else
2931 nRet = - (pPg->Prt().*fnRect->fnGetHeight)()/5;
2932 nRet += (pBody->Frm().*fnRect->fnGetHeight)();
2933 if( nRet < 0 )
2934 nRet = 0;
2935 }
2936 else
2937 nRet = 0;
2938 if ( IsPageFrm() &&
2939 GetFmt()->getIDocumentSettingAccess()->get(IDocumentSettingAccess::BROWSE_MODE) )
2940 nRet += BROWSE_HEIGHT - Frm().Height();
2941 return nRet;
2942 }
2943
2944 /*************************************************************************
2945 |*
2946 |* SwFtnBossFrm::NeighbourhoodAdjustment(SwFrm*)
2947 |*
2948 |* gibt Auskunft, ob die Groessenveraenderung von pFrm von AdjustNeighbourhood(...)
2949 |* oder von Grow/Shrink(..) verarbeitet werden sollte.
2950 |* Bei einem PageFrm oder in Spalten direkt unterhalb der Seite muss AdjustNei..
2951 |* gerufen werden, in Rahmenspalten Grow/Shrink.
2952 |* Spannend sind die spaltigen Bereiche: Wenn es in der Spalte einen Fussnotencontainer
2953 |* gibt und die Fussnoten nicht vom Bereich eingesammelt werden, ist ein Adjust..,
2954 |* ansonsten ein Grow/Shrink notwendig.
2955 |*
2956 |* Ersterstellung AMA 09. Dec 98
2957 |* Letzte Aenderung AMA 09. Dec 98
2958 |*
2959 |*************************************************************************/
2960
2961 BYTE SwFtnBossFrm::_NeighbourhoodAdjustment( const SwFrm* ) const
2962 {
2963 BYTE nRet = NA_ONLY_ADJUST;
2964 if( GetUpper() && !GetUpper()->IsPageBodyFrm() )
2965 {
2966 // Spaltige Rahmen erfordern Grow/Shrink
2967 if( GetUpper()->IsFlyFrm() )
2968 nRet = NA_GROW_SHRINK;
2969 else
2970 {
2971 ASSERT( GetUpper()->IsSctFrm(), "NeighbourhoodAdjustment: Unexspected Upper" );
2972 if( !GetNext() && !GetPrev() )
2973 nRet = NA_GROW_ADJUST; // section with a single column (FtnAtEnd)
2974 else
2975 {
2976 const SwFrm* pTmp = Lower();
2977 ASSERT( pTmp, "NeighbourhoodAdjustment: Missing Lower()" );
2978 if( !pTmp->GetNext() )
2979 nRet = NA_GROW_SHRINK;
2980 else if( !GetUpper()->IsColLocked() )
2981 nRet = NA_ADJUST_GROW;
2982 ASSERT( !pTmp->GetNext() || pTmp->GetNext()->IsFtnContFrm(),
2983 "NeighbourhoodAdjustment: Who's that guy?" );
2984 }
2985 }
2986 }
2987 return nRet;
2988 }
2989
2990 /*************************************************************************
2991 |*
2992 |* SwPageFrm::SetColMaxFtnHeight()
2993 |*
2994 |* Ersterstellung AMA 29. Oct 98
2995 |* Letzte Aenderung AMA 29. Oct 98
2996 |*
2997 |*************************************************************************/
2998 void SwPageFrm::SetColMaxFtnHeight()
2999 {
3000 SwLayoutFrm *pBody = FindBodyCont();
3001 if( pBody && pBody->Lower() && pBody->Lower()->IsColumnFrm() )
3002 {
3003 SwColumnFrm* pCol = (SwColumnFrm*)pBody->Lower();
3004 do
3005 {
3006 pCol->SetMaxFtnHeight( GetMaxFtnHeight() );
3007 pCol = (SwColumnFrm*)pCol->GetNext();
3008 } while ( pCol );
3009 }
3010 }
3011
3012 /*************************************************************************
3013 |*
3014 |* SwLayoutFrm::MoveLowerFtns
3015 |*
3016 |* Ersterstellung MA 01. Sep. 94
3017 |* Letzte Aenderung MA 05. Sep. 95
3018 |*
3019 |*************************************************************************/
3020
3021
3022 BOOL SwLayoutFrm::MoveLowerFtns( SwCntntFrm *pStart, SwFtnBossFrm *pOldBoss,
3023 SwFtnBossFrm *pNewBoss, const BOOL bFtnNums )
3024 {
3025 SwDoc *pDoc = GetFmt()->GetDoc();
3026 if ( !pDoc->GetFtnIdxs().Count() )
3027 return FALSE;
3028 if( pDoc->GetFtnInfo().ePos == FTNPOS_CHAPTER &&
3029 ( !IsInSct() || !FindSctFrm()->IsFtnAtEnd() ) )
3030 return TRUE;
3031
3032 if ( !pNewBoss )
3033 pNewBoss = FindFtnBossFrm( TRUE );
3034 if ( pNewBoss == pOldBoss )
3035 return FALSE;
3036
3037 BOOL bMoved = FALSE;
3038 if( !pStart )
3039 pStart = ContainsCntnt();
3040
3041 SvPtrarr aFtnArr( 5, 5 );
3042
3043 while ( IsAnLower( pStart ) )
3044 {
3045 if ( ((SwTxtFrm*)pStart)->HasFtn() )
3046 {
3047 // OD 03.04.2003 #108446# - To avoid unnecessary moves of footnotes
3048 // use new parameter <_bCollectOnlyPreviousFtn> (4th parameter of
3049 // method <SwFtnBossFrm::CollectFtn(..)>) to control, that only
3050 // footnotes have to be collected, that are positioned before the
3051 // new dedicated footnote boss frame.
3052 pNewBoss->CollectFtns( pStart, pOldBoss, aFtnArr, sal_True );
3053 }
3054 pStart = pStart->GetNextCntntFrm();
3055 }
3056
3057 ASSERT( pOldBoss->IsInSct() == pNewBoss->IsInSct(),
3058 "MoveLowerFtns: Section confusion" );
3059 SvPtrarr *pFtnArr;
3060 SwLayoutFrm* pNewChief = 0;
3061 SwLayoutFrm* pOldChief = 0;
3062 if( pStart && pOldBoss->IsInSct() && ( pOldChief = pOldBoss->FindSctFrm() )
3063 != ( pNewChief = pNewBoss->FindSctFrm() ) )
3064 {
3065 pFtnArr = new SvPtrarr( 5, 5 );
3066 pOldChief = pOldBoss->FindFtnBossFrm( TRUE );
3067 pNewChief = pNewBoss->FindFtnBossFrm( TRUE );
3068 while( pOldChief->IsAnLower( pStart ) )
3069 {
3070 if ( ((SwTxtFrm*)pStart)->HasFtn() )
3071 ((SwFtnBossFrm*)pNewChief)->CollectFtns( pStart,
3072 (SwFtnBossFrm*)pOldBoss, *pFtnArr );
3073 pStart = pStart->GetNextCntntFrm();
3074 }
3075 if( !pFtnArr->Count() )
3076 {
3077 delete pFtnArr;
3078 pFtnArr = NULL;
3079 }
3080 }
3081 else
3082 pFtnArr = NULL;
3083
3084 if ( aFtnArr.Count() || pFtnArr )
3085 {
3086 if( aFtnArr.Count() )
3087 pNewBoss->_MoveFtns( aFtnArr, TRUE );
3088 if( pFtnArr )
3089 {
3090 ((SwFtnBossFrm*)pNewChief)->_MoveFtns( *pFtnArr, TRUE );
3091 delete pFtnArr;
3092 }
3093 bMoved = TRUE;
3094
3095 // Nur bei einem Seitenwechsel muss die FtnNum neu berechnet werden
3096 if ( bFtnNums )
3097 {
3098 SwPageFrm* pOldPage = pOldBoss->FindPageFrm();
3099 SwPageFrm* pNewPage =pNewBoss->FindPageFrm();
3100 if( pOldPage != pNewPage )
3101 {
3102 pOldPage->UpdateFtnNum();
3103 pNewPage->UpdateFtnNum();
3104 }
3105 }
3106 }
3107 return bMoved;
3108 }
3109
3110 /*************************************************************************
3111 |*
3112 |* SwLayoutFrm::MoveFtnCntFwd()
3113 |*
3114 |* Ersterstellung MA 24. Nov. 94
3115 |* Letzte Aenderung MA 15. Jun. 95
3116 |*
3117 |*************************************************************************/
3118
3119
3120 BOOL SwCntntFrm::MoveFtnCntFwd( BOOL bMakePage, SwFtnBossFrm *pOldBoss )
3121 {
3122 ASSERT( IsInFtn(), "Keine Ftn." );
3123 SwLayoutFrm *pFtn = FindFtnFrm();
3124
3125 // The first paragraph in the first footnote in the first column in the
3126 // sectionfrm at the top of the page has not to move forward, if the
3127 // columnbody is empty.
3128 if( pOldBoss->IsInSct() && !pOldBoss->GetIndPrev() && !GetIndPrev() &&
3129 !pFtn->GetPrev() )
3130 {
3131 SwLayoutFrm* pBody = pOldBoss->FindBodyCont();
3132 if( !pBody || !pBody->Lower() )
3133 return TRUE;
3134 }
3135
3136 //fix(9538): Wenn die Ftn noch Nachbarn hinter sich hat, so muessen
3137 //diese ersteinmal verschwinden.
3138 SwLayoutFrm *pNxt = (SwLayoutFrm*)pFtn->GetNext();
3139 SwLayoutFrm *pLst = 0;
3140 while ( pNxt )
3141 {
3142 while ( pNxt->GetNext() )
3143 pNxt = (SwLayoutFrm*)pNxt->GetNext();
3144 if ( pNxt == pLst )
3145 pNxt = 0;
3146 else
3147 { pLst = pNxt;
3148 SwCntntFrm *pCnt = pNxt->ContainsCntnt();
3149 if( pCnt )
3150 pCnt->MoveFtnCntFwd( TRUE, pOldBoss );
3151 pNxt = (SwLayoutFrm*)pFtn->GetNext();
3152 }
3153 }
3154
3155 BOOL bSamePage = TRUE;
3156 SwLayoutFrm *pNewUpper =
3157 GetLeaf( bMakePage ? MAKEPAGE_INSERT : MAKEPAGE_NONE, TRUE );
3158
3159 if ( pNewUpper )
3160 {
3161 BOOL bSameBoss = TRUE;
3162 SwFtnBossFrm * const pNewBoss = pNewUpper->FindFtnBossFrm();
3163 //Wechseln wir die Spalte/Seite?
3164 if ( FALSE == ( bSameBoss = pNewBoss == pOldBoss ) )
3165 {
3166 bSamePage = pOldBoss->FindPageFrm() == pNewBoss->FindPageFrm(); // Seitenwechsel?
3167 pNewUpper->Calc();
3168 }
3169
3170 //Das Layoutblatt, dass wir fuer Fussnoten bekommen ist entweder
3171 //ein Fussnotencontainer oder eine Fussnote
3172 //Wenn es eine Fussnote ist, und sie die gleiche Fussnotenreferez
3173 //wie der alte Upper hat, so moven wir uns direkt hinein.
3174 //Ist die Referenz einen andere oder ist es ein Container, so wird
3175 //eine neue Fussnote erzeugt und in den Container gestellt.
3176 // Wenn wir in einem Bereich innerhalb der Fussnote sind, muss
3177 // SectionFrame noch angelegt werden.
3178 SwFtnFrm* pTmpFtn = pNewUpper->IsFtnFrm() ? ((SwFtnFrm*)pNewUpper) : 0;
3179 if( !pTmpFtn )
3180 {
3181 ASSERT( pNewUpper->IsFtnContFrm(), "Neuer Upper kein FtnCont.");
3182 SwFtnContFrm *pCont = (SwFtnContFrm*)pNewUpper;
3183
3184 //Fussnote erzeugen.
3185 SwFtnFrm *pOld = FindFtnFrm();
3186 pTmpFtn = new SwFtnFrm( pOld->GetFmt()->GetDoc()->GetDfltFrmFmt(),
3187 pOld->GetRef(), pOld->GetAttr() );
3188 //Verkettung der Fussnoten.
3189 if ( pOld->GetFollow() )
3190 {
3191 pTmpFtn->SetFollow( pOld->GetFollow() );
3192 pOld->GetFollow()->SetMaster( pTmpFtn );
3193 }
3194 pOld->SetFollow( pTmpFtn );
3195 pTmpFtn->SetMaster( pOld );
3196 SwFrm* pNx = pCont->Lower();
3197 if( pNx && pTmpFtn->GetAttr()->GetFtn().IsEndNote() )
3198 while(pNx && !((SwFtnFrm*)pNx)->GetAttr()->GetFtn().IsEndNote())
3199 pNx = pNx->GetNext();
3200 pTmpFtn->Paste( pCont, pNx );
3201 pTmpFtn->Calc();
3202 }
3203 ASSERT( pTmpFtn->GetAttr() == FindFtnFrm()->GetAttr(), "Wrong Footnote!" );
3204 // Bereiche in Fussnoten beduerfen besonderer Behandlung
3205 SwLayoutFrm *pNewUp = pTmpFtn;
3206 if( IsInSct() )
3207 {
3208 SwSectionFrm* pSect = FindSctFrm();
3209 // Bereich in Fussnote (oder nur Fussnote in Bereich)?
3210 if( pSect->IsInFtn() )
3211 {
3212 if( pTmpFtn->Lower() && pTmpFtn->Lower()->IsSctFrm() &&
3213 pSect->GetFollow() == (SwSectionFrm*)pTmpFtn->Lower() )
3214 pNewUp = (SwSectionFrm*)pTmpFtn->Lower();
3215 else
3216 {
3217 pNewUp = new SwSectionFrm( *pSect, FALSE );
3218 pNewUp->InsertBefore( pTmpFtn, pTmpFtn->Lower() );
3219 static_cast<SwSectionFrm*>(pNewUp)->Init();
3220 pNewUp->Frm().Pos() = pTmpFtn->Frm().Pos();
3221 pNewUp->Frm().Pos().Y() += 1; //wg. Benachrichtigungen.
3222
3223 // Wenn unser Bereichsframe einen Nachfolger hat, so muss dieser
3224 // umgehaengt werden hinter den neuen Follow der Bereichsframes.
3225 SwFrm* pTmp = pSect->GetNext();
3226 if( pTmp )
3227 {
3228 SwFlowFrm* pTmpNxt;
3229 if( pTmp->IsCntntFrm() )
3230 pTmpNxt = (SwCntntFrm*)pTmp;
3231 else if( pTmp->IsSctFrm() )
3232 pTmpNxt = (SwSectionFrm*)pTmp;
3233 else
3234 {
3235 ASSERT( pTmp->IsTabFrm(), "GetNextSctLeaf: Wrong Type" );
3236 pTmpNxt = (SwTabFrm*)pTmp;
3237 }
3238 pTmpNxt->MoveSubTree( pTmpFtn, pNewUp->GetNext() );
3239 }
3240 }
3241 }
3242 }
3243
3244 MoveSubTree( pNewUp, pNewUp->Lower() );
3245
3246 if( !bSameBoss )
3247 Prepare( PREP_BOSS_CHGD );
3248 }
3249 return bSamePage;
3250 }
3251
3252 /*************************************************************************
3253 |*
3254 |* class SwSaveFtnHeight
3255 |*
3256 |* Ersterstellung MA 19. Jan. 94
3257 |* Letzte Aenderung MA 19. Jan. 94
3258 |*
3259 |*************************************************************************/
3260
3261
3262 SwSaveFtnHeight::SwSaveFtnHeight( SwFtnBossFrm *pBs, const SwTwips nDeadLine ) :
3263 pBoss( pBs ),
3264 nOldHeight( pBs->GetMaxFtnHeight() )
3265 {
3266 pBoss->SetFtnDeadLine( nDeadLine );
3267 nNewHeight = pBoss->GetMaxFtnHeight();
3268 }
3269
3270
3271
3272 SwSaveFtnHeight::~SwSaveFtnHeight()
3273 {
3274 //Wenn zwischendurch jemand an der DeadLine gedreht hat, so lassen wir
3275 //ihm seinen Spass!
3276 if ( nNewHeight == pBoss->GetMaxFtnHeight() )
3277 pBoss->nMaxFtnHeight = nOldHeight;
3278 }
3279
3280
3281 #ifndef PRODUCT
3282 //JP 15.10.2001: in a non pro version test if the attribute has the same
3283 // meaning which his reference is
3284
3285 // Normally, the pRef member and the GetRefFromAttr() result has to be
3286 // identically. Sometimes footnote will be moved from a master to its follow,
3287 // but the GetRef() is called first, so we have to ignore a master/follow
3288 // mismatch.
3289
3290 const SwCntntFrm* SwFtnFrm::GetRef() const
3291 {
3292 const SwCntntFrm* pRefAttr = GetRefFromAttr();
3293 ASSERT( pRef == pRefAttr || pRef->IsAnFollow( pRefAttr )
3294 || pRefAttr->IsAnFollow( pRef ),
3295 "access to deleted Frame? pRef != pAttr->GetRef()" );
3296 return pRef;
3297 }
3298
3299 SwCntntFrm* SwFtnFrm::GetRef()
3300 {
3301 const SwCntntFrm* pRefAttr = GetRefFromAttr();
3302 ASSERT( pRef == pRefAttr || pRef->IsAnFollow( pRefAttr )
3303 || pRefAttr->IsAnFollow( pRef ),
3304 "access to deleted Frame? pRef != pAttr->GetRef()" );
3305 return pRef;
3306 }
3307
3308 #endif
3309
3310 const SwCntntFrm* SwFtnFrm::GetRefFromAttr() const
3311 {
3312 SwFtnFrm* pThis = (SwFtnFrm*)this;
3313 return pThis->GetRefFromAttr();
3314 }
3315
3316 SwCntntFrm* SwFtnFrm::GetRefFromAttr()
3317 {
3318 ASSERT( pAttr, "invalid Attribute" );
3319 SwTxtNode& rTNd = (SwTxtNode&)pAttr->GetTxtNode();
3320 SwPosition aPos( rTNd, SwIndex( &rTNd, *pAttr->GetStart() ));
3321 SwCntntFrm* pCFrm = rTNd.GetFrm( 0, &aPos, FALSE );
3322 return pCFrm;
3323 }
3324
3325 /** search for last content in the current footnote frame
3326
3327 OD 2005-12-02 #i27138#
3328
3329 @author OD
3330 */
3331 SwCntntFrm* SwFtnFrm::FindLastCntnt()
3332 {
3333 SwCntntFrm* pLastCntntFrm( 0L );
3334
3335 // find last lower, which is a content frame or contains content.
3336 // hidden text frames, empty sections and empty tables have to be skipped.
3337 SwFrm* pLastLowerOfFtn( GetLower() );
3338 SwFrm* pTmpLastLower( pLastLowerOfFtn );
3339 while ( pTmpLastLower && pTmpLastLower->GetNext() )
3340 {
3341 pTmpLastLower = pTmpLastLower->GetNext();
3342 if ( ( pTmpLastLower->IsTxtFrm() &&
3343 !static_cast<SwTxtFrm*>(pTmpLastLower)->IsHiddenNow() ) ||
3344 ( pTmpLastLower->IsSctFrm() &&
3345 static_cast<SwSectionFrm*>(pTmpLastLower)->GetSection() &&
3346 static_cast<SwSectionFrm*>(pTmpLastLower)->ContainsCntnt() ) ||
3347 ( pTmpLastLower->IsTabFrm() &&
3348 static_cast<SwTabFrm*>(pTmpLastLower)->ContainsCntnt() ) )
3349 {
3350 pLastLowerOfFtn = pTmpLastLower;
3351 }
3352 }
3353
3354 // determine last content frame depending on type of found last lower.
3355 if ( pLastLowerOfFtn && pLastLowerOfFtn->IsTabFrm() )
3356 {
3357 pLastCntntFrm = static_cast<SwTabFrm*>(pLastLowerOfFtn)->FindLastCntnt();
3358 }
3359 else if ( pLastLowerOfFtn && pLastLowerOfFtn->IsSctFrm() )
3360 {
3361 pLastCntntFrm = static_cast<SwSectionFrm*>(pLastLowerOfFtn)->FindLastCntnt();
3362 }
3363 else
3364 {
3365 pLastCntntFrm = dynamic_cast<SwCntntFrm*>(pLastLowerOfFtn);
3366 }
3367
3368 return pLastCntntFrm;
3369 }
3370
vba interoperability for OOo