Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include "pagefrm.hxx"
21 : #include <fmtcntnt.hxx>
22 : #include <fmthdft.hxx>
23 : #include <fmtfsize.hxx>
24 : #include "viewopt.hxx"
25 : #include "hffrm.hxx"
26 : #include "rootfrm.hxx"
27 : #include "txtfrm.hxx"
28 : #include "sectfrm.hxx"
29 : #include "flyfrm.hxx"
30 : #include "frmtool.hxx"
31 : #include "hfspacingitem.hxx"
32 : #include <sortedobjs.hxx>
33 : #include <objectformatter.hxx>
34 :
35 : extern bool bObjsDirect; //frmtool.cxx
36 :
37 9729 : static SwTwips lcl_GetFrmMinHeight(const SwLayoutFrm & rFrm)
38 : {
39 9729 : const SwFormatFrmSize &rSz = rFrm.GetFormat()->GetFrmSize();
40 : SwTwips nMinHeight;
41 :
42 9729 : switch (rSz.GetHeightSizeType())
43 : {
44 : case ATT_MIN_SIZE:
45 9723 : nMinHeight = rSz.GetHeight();
46 :
47 9723 : break;
48 :
49 : default:
50 6 : nMinHeight = 0;
51 : }
52 :
53 9729 : return nMinHeight;
54 : }
55 :
56 1925 : static SwTwips lcl_CalcContentHeight(SwLayoutFrm & frm)
57 : {
58 1925 : SwTwips nRemaining = 0;
59 1925 : SwFrm* pFrm = frm.Lower();
60 :
61 7188 : while ( pFrm )
62 : {
63 : SwTwips nTmp;
64 :
65 3338 : nTmp = pFrm->Frm().Height();
66 3338 : nRemaining += nTmp;
67 3338 : if( pFrm->IsTextFrm() && static_cast<SwTextFrm*>(pFrm)->IsUndersized() )
68 : {
69 0 : nTmp = static_cast<SwTextFrm*>(pFrm)->GetParHeight()
70 0 : - pFrm->Prt().Height();
71 : // This TextFrm would like to be a bit bigger
72 0 : nRemaining += nTmp;
73 : }
74 3338 : else if( pFrm->IsSctFrm() && static_cast<SwSectionFrm*>(pFrm)->IsUndersized() )
75 : {
76 0 : nTmp = static_cast<SwSectionFrm*>(pFrm)->Undersize();
77 0 : nRemaining += nTmp;
78 : }
79 3338 : pFrm = pFrm->GetNext();
80 : }
81 :
82 1925 : return nRemaining;
83 : }
84 :
85 1999 : static void lcl_LayoutFrmEnsureMinHeight(SwLayoutFrm & rFrm,
86 : const SwBorderAttrs * )
87 : {
88 1999 : SwTwips nMinHeight = lcl_GetFrmMinHeight(rFrm);
89 :
90 1999 : if (rFrm.Frm().Height() < nMinHeight)
91 : {
92 1836 : rFrm.Grow(nMinHeight - rFrm.Frm().Height());
93 : }
94 1999 : }
95 :
96 1925 : SwHeadFootFrm::SwHeadFootFrm( SwFrameFormat * pFormat, SwFrm* pSib, sal_uInt16 nTypeIn)
97 1925 : : SwLayoutFrm( pFormat, pSib )
98 : {
99 1925 : mnFrmType = nTypeIn;
100 1925 : SetDerivedVert( false );
101 :
102 1925 : const SwFormatContent &rCnt = pFormat->GetContent();
103 :
104 : OSL_ENSURE( rCnt.GetContentIdx(), "No content for Header." );
105 :
106 : // Have the objects created right now for header and footer
107 1925 : bool bOld = bObjsDirect;
108 1925 : bObjsDirect = true;
109 1925 : sal_uLong nIndex = rCnt.GetContentIdx()->GetIndex();
110 1925 : ::_InsertCnt( this, pFormat->GetDoc(), ++nIndex );
111 1925 : bObjsDirect = bOld;
112 1925 : }
113 :
114 1999 : void SwHeadFootFrm::FormatPrt(SwTwips & nUL, const SwBorderAttrs * pAttrs)
115 : {
116 1999 : if (GetEatSpacing())
117 : {
118 : /* The minimal height of the print area is the minimal height of the
119 : frame without the height needed for borders and shadow. */
120 1925 : SwTwips nMinHeight = lcl_GetFrmMinHeight(*this);
121 :
122 1925 : nMinHeight -= pAttrs->CalcTop();
123 1925 : nMinHeight -= pAttrs->CalcBottom();
124 :
125 : /* If the minimal height of the print area is negative, try to
126 : compensate by overlapping */
127 1925 : SwTwips nOverlap = 0;
128 1925 : if (nMinHeight < 0)
129 : {
130 0 : nOverlap = -nMinHeight;
131 0 : nMinHeight = 0;
132 : }
133 :
134 : /* Calculate desired height of content. The minimal height has to be
135 : adhered. */
136 : SwTwips nHeight;
137 :
138 1925 : if ( ! HasFixSize() )
139 1925 : nHeight = lcl_CalcContentHeight(*this);
140 : else
141 0 : nHeight = nMinHeight;
142 :
143 1925 : if (nHeight < nMinHeight)
144 1781 : nHeight = nMinHeight;
145 :
146 : /* calculate initial spacing/line space */
147 : SwTwips nSpace, nLine;
148 :
149 1925 : if (IsHeaderFrm())
150 : {
151 938 : nSpace = pAttrs->CalcBottom();
152 938 : nLine = pAttrs->CalcBottomLine();
153 : }
154 : else
155 : {
156 987 : nSpace = pAttrs->CalcTop();
157 987 : nLine = pAttrs->CalcTopLine();
158 : }
159 :
160 : /* calculate overlap and correct spacing */
161 1925 : nOverlap += nHeight - nMinHeight;
162 1925 : if (nOverlap < nSpace - nLine)
163 1626 : nSpace -= nOverlap;
164 : else
165 299 : nSpace = nLine;
166 :
167 : /* calculate real vertical space between frame and print area */
168 1925 : if (IsHeaderFrm())
169 938 : nUL = pAttrs->CalcTop() + nSpace;
170 : else
171 987 : nUL = pAttrs->CalcBottom() + nSpace;
172 :
173 : /* set print area */
174 : // OD 23.01.2003 #106895# - add first parameter to <SwBorderAttrs::CalcRight(..)>
175 1925 : SwTwips nLR = pAttrs->CalcLeft( this ) + pAttrs->CalcRight( this );
176 :
177 1925 : maPrt.Left(pAttrs->CalcLeft(this));
178 :
179 1925 : if (IsHeaderFrm())
180 938 : maPrt.Top(pAttrs->CalcTop());
181 : else
182 987 : maPrt.Top(nSpace);
183 :
184 1925 : maPrt.Width(maFrm.Width() - nLR);
185 :
186 : SwTwips nNewHeight;
187 :
188 1925 : if (nUL < maFrm.Height())
189 1925 : nNewHeight = maFrm.Height() - nUL;
190 : else
191 0 : nNewHeight = 0;
192 :
193 1925 : maPrt.Height(nNewHeight);
194 : }
195 : else
196 : {
197 : // Set position
198 74 : maPrt.Left( pAttrs->CalcLeft( this ) );
199 74 : maPrt.Top ( pAttrs->CalcTop() );
200 :
201 : // Set sizes - the sizes are given by the surrounding Frm, just
202 : // subtract the borders.
203 : // OD 23.01.2003 #106895# - add first parameter to <SwBorderAttrs::CalcRight(..)>
204 74 : SwTwips nLR = pAttrs->CalcLeft( this ) + pAttrs->CalcRight( this );
205 74 : maPrt.Width ( maFrm.Width() - nLR );
206 74 : maPrt.Height( maFrm.Height()- nUL );
207 :
208 : }
209 :
210 1999 : mbValidPrtArea = true;
211 1999 : }
212 :
213 1996 : void SwHeadFootFrm::FormatSize(SwTwips nUL, const SwBorderAttrs * pAttrs)
214 : {
215 1996 : if ( !HasFixSize() )
216 : {
217 1993 : if( !IsColLocked() )
218 : {
219 1993 : mbValidSize = mbValidPrtArea = true;
220 :
221 1993 : const SwTwips nBorder = nUL;
222 1993 : SwTwips nMinHeight = lcl_GetFrmMinHeight(*this);
223 1993 : nMinHeight -= pAttrs->CalcTop();
224 1993 : nMinHeight -= pAttrs->CalcBottom();
225 :
226 1993 : if (nMinHeight < 0)
227 13 : nMinHeight = 0;
228 :
229 1993 : ColLock();
230 :
231 1993 : SwTwips nMaxHeight = LONG_MAX;
232 : SwTwips nRemaining, nOldHeight;
233 : // #i64301#
234 : // use the position of the footer printing area to control invalidation
235 : // of the first footer content.
236 1993 : Point aOldFooterPrtPos;
237 :
238 1826 : do
239 : {
240 3819 : nOldHeight = Prt().Height();
241 3819 : SwFrm* pFrm = Lower();
242 : // #i64301#
243 15276 : if ( pFrm &&
244 15276 : aOldFooterPrtPos != ( Frm().Pos() + Prt().Pos() ) )
245 : {
246 2976 : pFrm->_InvalidatePos();
247 2976 : aOldFooterPrtPos = Frm().Pos() + Prt().Pos();
248 : }
249 14313 : while( pFrm )
250 : {
251 6675 : pFrm->Calc();
252 : // #i43771# - format also object anchored
253 : // at the frame
254 : // #i46941# - frame has to be valid.
255 : // Note: frame could be invalid after calling its format,
256 : // if it's locked
257 : OSL_ENSURE( StackHack::IsLocked() || !pFrm->IsTextFrm() ||
258 : pFrm->IsValid() ||
259 : static_cast<SwTextFrm*>(pFrm)->IsJoinLocked(),
260 : "<SwHeadFootFrm::FormatSize(..)> - text frame invalid and not locked." );
261 6675 : if ( pFrm->IsTextFrm() && pFrm->IsValid() )
262 : {
263 6345 : if ( !SwObjectFormatter::FormatObjsAtFrm( *pFrm,
264 6345 : *(pFrm->FindPageFrm()) ) )
265 : {
266 : // restart format with first content
267 141 : pFrm = Lower();
268 141 : continue;
269 : }
270 : }
271 6534 : pFrm = pFrm->GetNext();
272 : }
273 3819 : nRemaining = 0;
274 3819 : pFrm = Lower();
275 :
276 14169 : while ( pFrm )
277 : {
278 6531 : nRemaining += pFrm->Frm().Height();
279 :
280 12732 : if( pFrm->IsTextFrm() &&
281 6201 : static_cast<SwTextFrm*>(pFrm)->IsUndersized() )
282 : // This TextFrm would like to be a bit bigger
283 3022 : nRemaining += static_cast<SwTextFrm*>(pFrm)->GetParHeight()
284 3022 : - pFrm->Prt().Height();
285 3509 : else if( pFrm->IsSctFrm() &&
286 0 : static_cast<SwSectionFrm*>(pFrm)->IsUndersized() )
287 0 : nRemaining += static_cast<SwSectionFrm*>(pFrm)->Undersize();
288 6531 : pFrm = pFrm->GetNext();
289 : }
290 3819 : if ( nRemaining < nMinHeight )
291 43 : nRemaining = nMinHeight;
292 :
293 3819 : SwTwips nDiff = nRemaining - nOldHeight;
294 :
295 3819 : if( !nDiff )
296 1993 : break;
297 1826 : if( nDiff < 0 )
298 : {
299 0 : nMaxHeight = nOldHeight;
300 :
301 0 : if( nRemaining <= nMinHeight )
302 0 : nRemaining = ( nMaxHeight + nMinHeight + 1 ) / 2;
303 : }
304 : else
305 : {
306 1826 : if (nOldHeight > nMinHeight)
307 20 : nMinHeight = nOldHeight;
308 :
309 1826 : if( nRemaining >= nMaxHeight )
310 0 : nRemaining = ( nMaxHeight + nMinHeight + 1 ) / 2;
311 : }
312 :
313 1826 : nDiff = nRemaining - nOldHeight;
314 :
315 1826 : if ( nDiff )
316 : {
317 1826 : ColUnlock();
318 1826 : if ( nDiff > 0 )
319 : {
320 1826 : if ( Grow( nDiff ) )
321 : {
322 1826 : pFrm = Lower();
323 :
324 6766 : while ( pFrm )
325 : {
326 3114 : if( pFrm->IsTextFrm())
327 : {
328 3014 : SwTextFrm * pTmpFrm = static_cast<SwTextFrm*>(pFrm);
329 3014 : if (pTmpFrm->IsUndersized() )
330 : {
331 2993 : pTmpFrm->InvalidateSize();
332 2993 : pTmpFrm->Prepare(PREP_ADJUST_FRM);
333 : }
334 : }
335 : /* #i3568# Undersized sections need to be
336 : invalidated too. */
337 100 : else if (pFrm->IsSctFrm())
338 : {
339 : SwSectionFrm * pTmpFrm =
340 0 : static_cast<SwSectionFrm*>(pFrm);
341 0 : if (pTmpFrm->IsUndersized() )
342 : {
343 0 : pTmpFrm->InvalidateSize();
344 0 : pTmpFrm->Prepare(PREP_ADJUST_FRM);
345 : }
346 : }
347 3114 : pFrm = pFrm->GetNext();
348 : }
349 : }
350 : }
351 : else
352 0 : Shrink( -nDiff );
353 : // Quickly update the position
354 :
355 1826 : MakePos();
356 1826 : ColLock();
357 : }
358 : else
359 0 : break;
360 : // Don't overwrite the lower edge of the upper
361 1826 : if ( GetUpper() && Frm().Height() )
362 : {
363 1826 : const SwTwips nDeadLine = GetUpper()->Frm().Top() +
364 1826 : GetUpper()->Prt().Bottom();
365 1826 : const SwTwips nBot = Frm().Bottom();
366 1826 : if ( nBot > nDeadLine )
367 : {
368 0 : Frm().Bottom( nDeadLine );
369 0 : Prt().SSize().Height() = Frm().Height() - nBorder;
370 : }
371 : }
372 1826 : mbValidSize = mbValidPrtArea = true;
373 1826 : } while( nRemaining<=nMaxHeight && nOldHeight!=Prt().Height() );
374 1993 : ColUnlock();
375 : }
376 1993 : mbValidSize = mbValidPrtArea = true;
377 : }
378 : else //if (GetType() & FRM_HEADFOOT)
379 : {
380 3 : do
381 : {
382 3 : if ( Frm().Height() != pAttrs->GetSize().Height() )
383 3 : ChgSize( Size( Frm().Width(), pAttrs->GetSize().Height()));
384 3 : mbValidSize = true;
385 3 : MakePos();
386 3 : } while ( !mbValidSize );
387 : }
388 1996 : }
389 :
390 2208 : void SwHeadFootFrm::Format(const SwBorderAttrs * pAttrs)
391 : {
392 : OSL_ENSURE( pAttrs, "SwFooterFrm::Format, pAttrs is 0." );
393 :
394 2208 : if ( mbValidPrtArea && mbValidSize )
395 2208 : return;
396 :
397 2208 : if ( ! GetEatSpacing() && IsHeaderFrm())
398 : {
399 209 : SwLayoutFrm::Format(pAttrs);
400 : }
401 : else
402 : {
403 1999 : lcl_LayoutFrmEnsureMinHeight(*this, pAttrs);
404 :
405 1999 : long nUL = pAttrs->CalcTop() + pAttrs->CalcBottom();
406 :
407 1999 : if ( !mbValidPrtArea )
408 1999 : FormatPrt(nUL, pAttrs);
409 :
410 1999 : if ( !mbValidSize )
411 1996 : FormatSize(nUL, pAttrs);
412 : }
413 : }
414 :
415 11525 : SwTwips SwHeadFootFrm::GrowFrm( SwTwips nDist, bool bTst, bool bInfo )
416 : {
417 : SwTwips nResult;
418 :
419 11525 : if ( IsColLocked() )
420 : {
421 7486 : nResult = 0;
422 : }
423 4039 : else if (!GetEatSpacing())
424 : {
425 230 : nResult = SwLayoutFrm::GrowFrm(nDist, bTst, bInfo);
426 : }
427 : else
428 : {
429 3809 : nResult = 0;
430 :
431 : SwBorderAttrAccess * pAccess =
432 3809 : new SwBorderAttrAccess( SwFrm::GetCache(), this );
433 : OSL_ENSURE(pAccess, "no border attributes");
434 :
435 3809 : SwBorderAttrs * pAttrs = pAccess->Get();
436 :
437 : /* First assume the whole amount to grow can be provided by eating
438 : spacing. */
439 3809 : SwTwips nEat = nDist;
440 : SwTwips nMaxEat;
441 :
442 : /* calculate maximum eatable spacing */
443 3809 : if (IsHeaderFrm())
444 1850 : nMaxEat = maFrm.Height() - maPrt.Top() - maPrt.Height() - pAttrs->CalcBottomLine();
445 : else
446 1959 : nMaxEat = maPrt.Top() - pAttrs->CalcTopLine();
447 :
448 3809 : delete pAccess;
449 :
450 3809 : if (nMaxEat < 0)
451 0 : nMaxEat = 0;
452 :
453 : /* If the frame is too small, eat less spacing thus letting the frame
454 : grow more. */
455 3809 : SwTwips nMinHeight = lcl_GetFrmMinHeight(*this);
456 3809 : SwTwips nFrameTooSmall = nMinHeight - Frm().Height();
457 :
458 3809 : if (nFrameTooSmall > 0)
459 1781 : nEat -= nFrameTooSmall;
460 :
461 : /* No negative eating, not eating more than allowed. */
462 3809 : if (nEat < 0)
463 0 : nEat = 0;
464 3809 : else if (nEat > nMaxEat)
465 640 : nEat = nMaxEat;
466 :
467 : // OD 10.04.2003 #108719# - Notify fly frame, if header frame
468 : // grows. Consider, that 'normal' grow of layout frame already notifys
469 : // the fly frames.
470 3809 : bool bNotifyFlys = false;
471 3809 : if (nEat > 0)
472 : {
473 1666 : if ( ! bTst)
474 : {
475 1666 : if (! IsHeaderFrm())
476 : {
477 934 : maPrt.Top(maPrt.Top() - nEat);
478 934 : maPrt.Height(maPrt.Height() - nEat);
479 : }
480 :
481 1666 : InvalidateAll();
482 : }
483 :
484 1666 : nResult += nEat;
485 : // OD 14.04.2003 #108719# - trigger fly frame notify.
486 1666 : if ( IsHeaderFrm() )
487 : {
488 732 : bNotifyFlys = true;
489 : }
490 : }
491 :
492 3809 : if (nDist - nEat > 0)
493 : {
494 : SwTwips nFrmGrow =
495 2421 : SwLayoutFrm::GrowFrm( nDist - nEat, bTst, bInfo );
496 :
497 2421 : nResult += nFrmGrow;
498 2421 : if ( nFrmGrow > 0 )
499 : {
500 2421 : bNotifyFlys = false;
501 : }
502 : }
503 :
504 : // OD 10.04.2003 #108719# - notify fly frames, if necessary and triggered.
505 3809 : if ( ( nResult > 0 ) && bNotifyFlys )
506 : {
507 624 : NotifyLowerObjs();
508 : }
509 : }
510 :
511 11525 : if ( nResult && !bTst )
512 4039 : SetCompletePaint();
513 :
514 11525 : return nResult;
515 : }
516 :
517 5 : SwTwips SwHeadFootFrm::ShrinkFrm( SwTwips nDist, bool bTst, bool bInfo )
518 : {
519 : SwTwips nResult;
520 :
521 5 : if ( IsColLocked() )
522 : {
523 0 : nResult = 0;
524 : }
525 5 : else if (! GetEatSpacing())
526 : {
527 2 : nResult = SwLayoutFrm::ShrinkFrm(nDist, bTst, bInfo);
528 : }
529 : else
530 : {
531 3 : nResult = 0;
532 :
533 3 : SwTwips nMinHeight = lcl_GetFrmMinHeight(*this);
534 3 : SwTwips nOldHeight = Frm().Height();
535 3 : SwTwips nRest = 0; // Amount to shrink by spitting out spacing
536 :
537 3 : if ( nOldHeight >= nMinHeight )
538 : {
539 : /* If the frame's height is bigger than its minimum height, shrink
540 : the frame towards its minimum height. If this is not sufficient
541 : to provide the shrinking requested provide the rest by spitting
542 : out spacing. */
543 :
544 3 : SwTwips nBiggerThanMin = nOldHeight - nMinHeight;
545 :
546 3 : if (nBiggerThanMin < nDist)
547 : {
548 0 : nRest = nDist - nBiggerThanMin;
549 : }
550 : /* info: declaration of nRest -> else nRest = 0 */
551 : }
552 : else
553 : /* The frame cannot shrink. Provide shrinking by spitting out
554 : spacing. */
555 0 : nRest = nDist;
556 :
557 : // OD 10.04.2003 #108719# - Notify fly frame, if header/footer frame
558 : // shrinks. Consider, that 'normal' shrink of layout frame already notifys
559 : // the fly frames.
560 3 : bool bNotifyFlys = false;
561 3 : if (nRest > 0)
562 : {
563 :
564 : SwBorderAttrAccess * pAccess =
565 0 : new SwBorderAttrAccess( SwFrm::GetCache(), this );
566 : OSL_ENSURE(pAccess, "no border attributes");
567 :
568 0 : SwBorderAttrs * pAttrs = pAccess->Get();
569 :
570 : /* minimal height of print area */
571 : SwTwips nMinPrtHeight = nMinHeight
572 0 : - pAttrs->CalcTop()
573 0 : - pAttrs->CalcBottom();
574 :
575 0 : if (nMinPrtHeight < 0)
576 0 : nMinPrtHeight = 0;
577 :
578 0 : delete pAccess;
579 :
580 : /* assume all shrinking can be provided */
581 0 : SwTwips nShrink = nRest;
582 :
583 : /* calculate maximum shrinking */
584 0 : SwTwips nMaxShrink = maPrt.Height() - nMinPrtHeight;
585 :
586 : /* shrink no more than maximum shrinking */
587 0 : if (nShrink > nMaxShrink)
588 : {
589 : //nRest -= nShrink - nMaxShrink;
590 0 : nShrink = nMaxShrink;
591 : }
592 :
593 0 : if (!bTst)
594 : {
595 0 : if (! IsHeaderFrm() )
596 : {
597 0 : maPrt.Top(maPrt.Top() + nShrink);
598 0 : maPrt.Height(maPrt.Height() - nShrink);
599 : }
600 :
601 0 : InvalidateAll();
602 : }
603 0 : nResult += nShrink;
604 : // OD 14.04.2003 #108719# - trigger fly frame notify.
605 0 : if ( IsHeaderFrm() )
606 : {
607 0 : bNotifyFlys = true;
608 : }
609 : }
610 :
611 : /* The shrinking not providable by spitting out spacing has to be done
612 : by the frame. */
613 3 : if (nDist - nRest > 0)
614 : {
615 3 : SwTwips nShrinkAmount = SwLayoutFrm::ShrinkFrm( nDist - nRest, bTst, bInfo );
616 3 : nResult += nShrinkAmount;
617 3 : if ( nShrinkAmount > 0 )
618 : {
619 3 : bNotifyFlys = false;
620 : }
621 : }
622 :
623 : // OD 10.04.2003 #108719# - notify fly frames, if necessary.
624 3 : if ( ( nResult > 0 ) && bNotifyFlys )
625 : {
626 0 : NotifyLowerObjs();
627 : }
628 : }
629 :
630 5 : return nResult;
631 : }
632 :
633 8251 : bool SwHeadFootFrm::GetEatSpacing() const
634 : {
635 8251 : const SwFrameFormat * pFormat = GetFormat();
636 : OSL_ENSURE(pFormat, "SwHeadFootFrm: no format?");
637 :
638 8251 : if (pFormat->GetHeaderAndFooterEatSpacing().GetValue())
639 7662 : return true;
640 :
641 589 : return false;
642 : }
643 :
644 11 : void DelFlys( SwLayoutFrm *pFrm, SwPageFrm *pPage )
645 : {
646 11 : size_t i = 0;
647 77 : while ( pPage->GetSortedObjs() &&
648 41 : pPage->GetSortedObjs()->size() &&
649 16 : i < pPage->GetSortedObjs()->size() )
650 : {
651 14 : SwAnchoredObject* pObj = (*pPage->GetSortedObjs())[i];
652 14 : if ( pObj->ISA(SwFlyFrm) )
653 : {
654 10 : SwFlyFrm* pFlyFrm = static_cast<SwFlyFrm*>(pObj);
655 10 : if ( pFrm->IsAnLower( pFlyFrm ) )
656 : {
657 8 : SwFrm::DestroyFrm(pFlyFrm);
658 : // Do not increment index, in this case
659 8 : continue;
660 : }
661 : }
662 6 : ++i;
663 : }
664 11 : }
665 :
666 : /// Creates or removes headers
667 910 : void SwPageFrm::PrepareHeader()
668 : {
669 910 : SwLayoutFrm *pLay = static_cast<SwLayoutFrm*>(Lower());
670 910 : if ( !pLay )
671 0 : return;
672 :
673 910 : const SwFormatHeader &rH = static_cast<SwFrameFormat*>(GetRegisteredIn())->GetHeader();
674 :
675 910 : const SwViewShell *pSh = getRootFrm()->GetCurrShell();
676 910 : const bool bOn = !(pSh && pSh->GetViewOptions()->getBrowseMode());
677 :
678 910 : if ( bOn && rH.IsActive() )
679 : { //Implant header, but remove first, if already present
680 : OSL_ENSURE( rH.GetHeaderFormat(), "FrameFormat for Header not found." );
681 :
682 897 : if ( pLay->GetFormat() == rH.GetHeaderFormat() )
683 0 : return; // Header is already the correct one.
684 :
685 897 : if ( pLay->IsHeaderFrm() )
686 0 : { SwLayoutFrm *pDel = pLay;
687 0 : pLay = static_cast<SwLayoutFrm*>(pLay->GetNext());
688 0 : ::DelFlys( pDel, this );
689 0 : pDel->Cut();
690 0 : SwFrm::DestroyFrm(pDel);
691 : }
692 : OSL_ENSURE( pLay, "Where to with the Header?" );
693 897 : SwHeaderFrm *pH = new SwHeaderFrm( const_cast<SwFrameFormat*>(rH.GetHeaderFormat()), this );
694 897 : pH->Paste( this, pLay );
695 897 : if ( GetUpper() )
696 8 : ::RegistFlys( this, pH );
697 : }
698 13 : else if ( pLay && pLay->IsHeaderFrm() )
699 : { // Remove header if present.
700 0 : ::DelFlys( pLay, this );
701 0 : pLay->Cut();
702 0 : SwFrm::DestroyFrm(pLay);
703 : }
704 : }
705 :
706 : /// Creates or removes footer
707 1046 : void SwPageFrm::PrepareFooter()
708 : {
709 1046 : SwLayoutFrm *pLay = static_cast<SwLayoutFrm*>(Lower());
710 1046 : if ( !pLay )
711 0 : return;
712 :
713 1046 : const SwFormatFooter &rF = static_cast<SwFrameFormat*>(GetRegisteredIn())->GetFooter();
714 2887 : while ( pLay->GetNext() )
715 795 : pLay = static_cast<SwLayoutFrm*>(pLay->GetNext());
716 :
717 1046 : const SwViewShell *pSh = getRootFrm()->GetCurrShell();
718 1046 : const bool bOn = !(pSh && pSh->GetViewOptions()->getBrowseMode());
719 :
720 1046 : if ( bOn && rF.IsActive() )
721 : { //Implant footer, but remove first, if already present
722 : OSL_ENSURE( rF.GetFooterFormat(), "FrameFormat for Footer not found." );
723 :
724 1028 : if ( pLay->GetFormat() == rF.GetFooterFormat() )
725 0 : return; // Footer is already the correct one.
726 :
727 1028 : if ( pLay->IsFooterFrm() )
728 : {
729 6 : ::DelFlys( pLay, this );
730 6 : pLay->Cut();
731 6 : SwFrm::DestroyFrm(pLay);
732 : }
733 1028 : SwFooterFrm *pF = new SwFooterFrm( const_cast<SwFrameFormat*>(rF.GetFooterFormat()), this );
734 1028 : pF->Paste( this );
735 1028 : if ( GetUpper() )
736 15 : ::RegistFlys( this, pF );
737 : }
738 18 : else if ( pLay->IsFooterFrm() )
739 : { // Remove footer if already present
740 5 : ::DelFlys( pLay, this );
741 : SwViewShell *pShell;
742 10 : if ( pLay->GetPrev() && 0 != (pShell = getRootFrm()->GetCurrShell()) &&
743 5 : pShell->VisArea().HasArea() )
744 5 : pShell->InvalidateWindows( pShell->VisArea() );
745 5 : pLay->Cut();
746 5 : SwFrm::DestroyFrm(pLay);
747 : }
748 177 : }
749 :
750 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
