sw/source/core/layout/hffrm.cxx

   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: hffrm.cxx,v $
  10  * $Revision: 1.27 $
  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 #include "pagefrm.hxx"
  35 #include "viewsh.hxx"
  36 #include "doc.hxx"
  37 #include "errhdl.hxx"
  38 #include <fmtcntnt.hxx>
  39 #include <fmthdft.hxx>
  40 #include <fmtfsize.hxx>
  41 #include "hffrm.hxx"
  42 #include "txtfrm.hxx"
  43 #include "sectfrm.hxx"
  44 #include "flyfrm.hxx"
  45 #include "frmtool.hxx"
  46 #include "dflyobj.hxx"
  47 #include "frmfmt.hxx"
  48 #include "ndindex.hxx"
  49 #include "hfspacingitem.hxx"
  50 // OD 2004-05-24 #i28701#
  51 #include <sortedobjs.hxx>
  52 // --> OD 2005-03-03 #i43771#
  53 #include <objectformatter.hxx>
  54 // <--
  55
  56 extern BOOL bObjsDirect;        //frmtool.cxx
  57
  58 static SwTwips lcl_GetFrmMinHeight(const SwLayoutFrm & rFrm)
  59 {
  60     const SwFmtFrmSize &rSz = rFrm.GetFmt()->GetFrmSize();
  61     SwTwips nMinHeight;
  62
  63     switch (rSz.GetHeightSizeType())
  64     {
  65     case ATT_MIN_SIZE:
  66         nMinHeight = rSz.GetHeight();
  67
  68         break;
  69
  70     default:
  71         nMinHeight = 0;
  72     }
  73
  74
  75     return nMinHeight;
  76 }
  77
  78
  79 static SwTwips lcl_CalcContentHeight(SwLayoutFrm & frm)
  80 {
  81     SwFrm* pFrm = frm.Lower();
  82
  83     SwTwips nRemaining = 0;
  84     USHORT nNum = 0;
  85     pFrm = frm.Lower();
  86     while ( pFrm )
  87     {
  88         SwTwips nTmp;
  89
  90         nTmp = pFrm->Frm().Height();
  91         nRemaining += nTmp;
  92         if( pFrm->IsTxtFrm() && ((SwTxtFrm*)pFrm)->IsUndersized() )
  93         {
  94             nTmp = ((SwTxtFrm*)pFrm)->GetParHeight()
  95                 - pFrm->Prt().Height();
  96             // Dieser TxtFrm waere gern ein bisschen groesser
  97             nRemaining += nTmp;
  98         }
  99         else if( pFrm->IsSctFrm() && ((SwSectionFrm*)pFrm)->IsUndersized() )
 100         {
 101             nTmp = ((SwSectionFrm*)pFrm)->Undersize();
 102             nRemaining += nTmp;
 103         }
 104         pFrm = pFrm->GetNext();
 105
 106         nNum++;
 107     }
 108
 109     return nRemaining;
 110 }
 111
 112 static void lcl_LayoutFrmEnsureMinHeight(SwLayoutFrm & rFrm,
 113                                          const SwBorderAttrs * )
 114 {
 115     SwTwips nMinHeight = lcl_GetFrmMinHeight(rFrm);
 116
 117     if (rFrm.Frm().Height() < nMinHeight)
 118     {
 119         rFrm.Grow(nMinHeight - rFrm.Frm().Height());
 120     }
 121 }
 122
 123 SwHeadFootFrm::SwHeadFootFrm( SwFrmFmt * pFmt, USHORT nTypeIn)
 124     : SwLayoutFrm(pFmt)
 125 {
 126     nType = nTypeIn;
 127     SetDerivedVert( FALSE );
 128
 129     const SwFmtCntnt &rCnt = pFmt->GetCntnt();
 130
 131     ASSERT( rCnt.GetCntntIdx(), "Kein Inhalt fuer Header." );
 132
 133     //Fuer Header Footer die Objekte gleich erzeugen lassen.
 134     BOOL bOld = bObjsDirect;
 135     bObjsDirect = TRUE;
 136     ULONG nIndex = rCnt.GetCntntIdx()->GetIndex();
 137     ::_InsertCnt( this, pFmt->GetDoc(), ++nIndex );
 138     bObjsDirect = bOld;
 139 }
 140
 141 void SwHeadFootFrm::FormatPrt(SwTwips & nUL, const SwBorderAttrs * pAttrs)
 142 {
 143     if (GetEatSpacing())
 144     {
 145         /* The minimal height of the print area is the minimal height of the
 146            frame without the height needed for borders and shadow. */
 147         SwTwips nMinHeight = lcl_GetFrmMinHeight(*this);
 148
 149         nMinHeight -= pAttrs->CalcTop();
 150         nMinHeight -= pAttrs->CalcBottom();
 151
 152         /* If the minimal height of the print area is negative, try to
 153            compensate by overlapping */
 154         SwTwips nOverlap = 0;
 155         if (nMinHeight < 0)
 156         {
 157             nOverlap = -nMinHeight;
 158             nMinHeight = 0;
 159         }
 160
 161         /* Calculate desired height of content. The minimal height has to be
 162            adhered. */
 163         SwTwips nHeight;
 164
 165         if ( ! HasFixSize() )
 166             nHeight = lcl_CalcContentHeight(*this);
 167         else
 168             nHeight = nMinHeight;
 169
 170         if (nHeight < nMinHeight)
 171             nHeight = nMinHeight;
 172
 173         /* calculate initial spacing/line space */
 174         SwTwips nSpace, nLine;
 175
 176         if (IsHeaderFrm())
 177         {
 178             nSpace = pAttrs->CalcBottom();
 179             nLine = pAttrs->CalcBottomLine();
 180         }
 181         else
 182         {
 183             nSpace = pAttrs->CalcTop();
 184             nLine = pAttrs->CalcTopLine();
 185         }
 186
 187         /* calculate overlap and correct spacing */
 188         nOverlap += nHeight - nMinHeight;
 189         if (nOverlap < nSpace - nLine)
 190             nSpace -= nOverlap;
 191         else
 192             nSpace = nLine;
 193
 194         /* calculate real vertical space between frame and print area */
 195         if (IsHeaderFrm())
 196             nUL = pAttrs->CalcTop() + nSpace;
 197         else
 198             nUL = pAttrs->CalcBottom() + nSpace;
 199
 200         /* set print area */
 201         // OD 23.01.2003 #106895# - add first parameter to <SwBorderAttrs::CalcRight(..)>
 202         SwTwips nLR = pAttrs->CalcLeft( this ) + pAttrs->CalcRight( this );
 203
 204         aPrt.Left(pAttrs->CalcLeft(this));
 205
 206         if (IsHeaderFrm())
 207             aPrt.Top(pAttrs->CalcTop());
 208         else
 209             aPrt.Top(nSpace);
 210
 211         aPrt.Width(aFrm.Width() - nLR);
 212
 213         SwTwips nNewHeight;
 214
 215         if (nUL < aFrm.Height())
 216             nNewHeight = aFrm.Height() - nUL;
 217         else
 218             nNewHeight = 0;
 219
 220         aPrt.Height(nNewHeight);
 221
 222     }
 223     else
 224     {
 225         //Position einstellen.
 226         aPrt.Left( pAttrs->CalcLeft( this ) );
 227         aPrt.Top ( pAttrs->CalcTop()  );
 228
 229         //Sizes einstellen; die Groesse gibt der umgebende Frm vor, die
 230         //die Raender werden einfach abgezogen.
 231         // OD 23.01.2003 #106895# - add first parameter to <SwBorderAttrs::CalcRight(..)>
 232         SwTwips nLR = pAttrs->CalcLeft( this ) + pAttrs->CalcRight( this );
 233         aPrt.Width ( aFrm.Width() - nLR );
 234         aPrt.Height( aFrm.Height()- nUL );
 235
 236     }
 237
 238     bValidPrtArea = TRUE;
 239 }
 240
 241 void SwHeadFootFrm::FormatSize(SwTwips nUL, const SwBorderAttrs * pAttrs)
 242 {
 243     if ( !HasFixSize() )
 244     {
 245         if( !IsColLocked() )
 246         {
 247             bValidSize = bValidPrtArea = TRUE;
 248
 249             const SwTwips nBorder = nUL;
 250             SwTwips nMinHeight = lcl_GetFrmMinHeight(*this);
 251             nMinHeight -= pAttrs->CalcTop();
 252             nMinHeight -= pAttrs->CalcBottom();
 253
 254             if (nMinHeight < 0)
 255                 nMinHeight = 0;
 256
 257             ColLock();
 258
 259             SwTwips nMaxHeight = LONG_MAX;
 260             SwTwips nRemaining, nOldHeight;
 261             // --> OD 2006-05-24 #i64301#
 262             // use the position of the footer printing area to control invalidation
 263             // of the first footer content.
 264             Point aOldFooterPrtPos;
 265             // <--
 266
 267             do
 268             {
 269                 nOldHeight = Prt().Height();
 270                 SwFrm* pFrm = Lower();
 271                 // --> OD 2006-05-24 #i64301#
 272                 if ( pFrm &&
 273                      aOldFooterPrtPos != ( Frm().Pos() + Prt().Pos() ) )
 274                 {
 275                     pFrm->_InvalidatePos();
 276                     aOldFooterPrtPos = Frm().Pos() + Prt().Pos();
 277                 }
 278                 // <--
 279                 while( pFrm )
 280                 {
 281                     pFrm->Calc();
 282                     // --> OD 2005-03-03 #i43771# - format also object anchored
 283                     // at the frame
 284                     // --> OD 2005-05-03 #i46941# - frame has to be valid.
 285                     // Note: frame could be invalid after calling its format,
 286                     //       if it's locked
 287                     ASSERT( StackHack::IsLocked() || !pFrm->IsTxtFrm() ||
 288                             pFrm->IsValid() ||
 289                             static_cast<SwTxtFrm*>(pFrm)->IsJoinLocked(),
 290                             "<SwHeadFootFrm::FormatSize(..)> - text frame invalid and not locked." );
 291                     if ( pFrm->IsTxtFrm() && pFrm->IsValid() )
 292                     {
 293                         if ( !SwObjectFormatter::FormatObjsAtFrm( *pFrm,
 294                                                                   *(pFrm->FindPageFrm()) ) )
 295                         {
 296                             // restart format with first content
 297                             pFrm = Lower();
 298                             continue;
 299                         }
 300                     }
 301                     // <--
 302                     pFrm = pFrm->GetNext();
 303                 }
 304                 nRemaining = 0;
 305                 pFrm = Lower();
 306
 307                 while ( pFrm )
 308                 {
 309                     nRemaining += pFrm->Frm().Height();
 310
 311                     if( pFrm->IsTxtFrm() &&
 312                         ((SwTxtFrm*)pFrm)->IsUndersized() )
 313                         // Dieser TxtFrm waere gern ein bisschen groesser
 314                         nRemaining += ((SwTxtFrm*)pFrm)->GetParHeight()
 315                             - pFrm->Prt().Height();
 316                     else if( pFrm->IsSctFrm() &&
 317                              ((SwSectionFrm*)pFrm)->IsUndersized() )
 318                         nRemaining += ((SwSectionFrm*)pFrm)->Undersize();
 319                     pFrm = pFrm->GetNext();
 320                 }
 321                 if ( nRemaining < nMinHeight )
 322                     nRemaining = nMinHeight;
 323
 324                 SwTwips nDiff = nRemaining - nOldHeight;
 325
 326                 if( !nDiff )
 327                     break;
 328                 if( nDiff < 0 )
 329                 {
 330                     nMaxHeight = nOldHeight;
 331
 332                     if( nRemaining <= nMinHeight )
 333                         nRemaining = ( nMaxHeight + nMinHeight + 1 ) / 2;
 334                 }
 335                 else
 336                 {
 337                     if (nOldHeight > nMinHeight)
 338                         nMinHeight = nOldHeight;
 339
 340                     if( nRemaining >= nMaxHeight )
 341                         nRemaining = ( nMaxHeight + nMinHeight + 1 ) / 2;
 342                 }
 343
 344                 nDiff = nRemaining - nOldHeight;
 345
 346                 if ( nDiff )
 347                 {
 348                     ColUnlock();
 349                     if ( nDiff > 0 )
 350                     {
 351                         if ( Grow( nDiff ) )
 352                         {
 353                             pFrm = Lower();
 354
 355                             while ( pFrm )
 356                             {
 357                                 if( pFrm->IsTxtFrm())
 358                                 {
 359                                     SwTxtFrm * pTmpFrm = (SwTxtFrm*) pFrm;
 360                                     if (pTmpFrm->IsUndersized() )
 361                                     {
 362                                         pTmpFrm->InvalidateSize();
 363                                         pTmpFrm->Prepare(PREP_ADJUST_FRM);
 364                                     }
 365                                 }
 366                                 /* #i3568# Undersized sections need to be
 367                                    invalidated too. */
 368                                 else if (pFrm->IsSctFrm())
 369                                 {
 370                                     SwSectionFrm * pTmpFrm =
 371                                         (SwSectionFrm*) pFrm;
 372                                     if (pTmpFrm->IsUndersized() )
 373                                     {
 374                                         pTmpFrm->InvalidateSize();
 375                                         pTmpFrm->Prepare(PREP_ADJUST_FRM);
 376                                     }
 377                                 }
 378                                 pFrm = pFrm->GetNext();
 379                             }
 380                         }
 381                     }
 382                     else
 383                         Shrink( -nDiff );
 384                     //Schnell auf dem kurzen Dienstweg die Position updaten.
 385
 386                     MakePos();
 387                     ColLock();
 388                 }
 389                 else
 390                     break;
 391                 //Unterkante des Uppers nicht ueberschreiten.
 392                 if ( GetUpper() && Frm().Height() )
 393                 {
 394                     const SwTwips nDeadLine = GetUpper()->Frm().Top() +
 395                         GetUpper()->Prt().Bottom();
 396                     const SwTwips nBot = Frm().Bottom();
 397                     if ( nBot > nDeadLine )
 398                     {
 399                         Frm().Bottom( nDeadLine );
 400                         Prt().SSize().Height() = Frm().Height() - nBorder;
 401                     }
 402                 }
 403                 bValidSize = bValidPrtArea = TRUE;
 404             } while( nRemaining<=nMaxHeight && nOldHeight!=Prt().Height() );
 405             ColUnlock();
 406         }
 407         bValidSize = bValidPrtArea = TRUE;
 408     }
 409     else //if ( GetType() & 0x0018 )
 410     {
 411         do
 412         {
 413             if ( Frm().Height() != pAttrs->GetSize().Height() )
 414                 ChgSize( Size( Frm().Width(), pAttrs->GetSize().Height()));
 415             bValidSize = TRUE;
 416             MakePos();
 417         } while ( !bValidSize );
 418     }
 419 }
 420
 421 void SwHeadFootFrm::Format(const SwBorderAttrs * pAttrs)
 422 {
 423     ASSERT( pAttrs, "SwFooterFrm::Format, pAttrs ist 0." );
 424
 425     if ( bValidPrtArea && bValidSize )
 426         return;
 427
 428     if ( ! GetEatSpacing() && IsHeaderFrm())
 429     {
 430         SwLayoutFrm::Format(pAttrs);
 431     }
 432     else
 433     {
 434         lcl_LayoutFrmEnsureMinHeight(*this, pAttrs);
 435
 436         long nUL = pAttrs->CalcTop()  + pAttrs->CalcBottom();
 437
 438         if ( !bValidPrtArea )
 439             FormatPrt(nUL, pAttrs);
 440
 441         if ( !bValidSize )
 442             FormatSize(nUL, pAttrs);
 443     }
 444 }
 445
 446 SwTwips SwHeadFootFrm::GrowFrm( SwTwips nDist, BOOL bTst,  BOOL bInfo )
 447 {
 448     SwTwips nResult;
 449
 450     if ( IsColLocked() )
 451     {
 452         nResult = 0;
 453     }
 454     else if (!GetEatSpacing())
 455     {
 456         nResult = SwLayoutFrm::GrowFrm(nDist, bTst, bInfo);
 457     }
 458     else
 459     {
 460         nResult = 0;
 461
 462         SwBorderAttrAccess * pAccess =
 463             new SwBorderAttrAccess( SwFrm::GetCache(), this );
 464         ASSERT(pAccess, "no border attributes");
 465
 466         SwBorderAttrs * pAttrs = pAccess->Get();
 467
 468         /* First assume the whole amount to grow can be provided by eating
 469            spacing. */
 470         SwTwips nEat = nDist;
 471         SwTwips nMaxEat;
 472
 473         /* calculate maximum eatable spacing */
 474         if (IsHeaderFrm())
 475             nMaxEat = aFrm.Height() - aPrt.Top() - aPrt.Height() - pAttrs->CalcBottomLine();
 476         else
 477             nMaxEat = aPrt.Top() - pAttrs->CalcTopLine();
 478
 479         delete pAccess;
 480
 481         if (nMaxEat < 0)
 482             nMaxEat = 0;
 483
 484         /* If the frame is too small, eat less spacing thus letting the frame
 485            grow more. */
 486         SwTwips nMinHeight = lcl_GetFrmMinHeight(*this);
 487         SwTwips nFrameTooSmall = nMinHeight - Frm().Height();
 488
 489         if (nFrameTooSmall > 0)
 490             nEat -= nFrameTooSmall;
 491
 492         /* No negative eating, not eating more than allowed. */
 493         if (nEat < 0)
 494             nEat = 0;
 495         else if (nEat > nMaxEat)
 496             nEat = nMaxEat;
 497
 498         // OD 10.04.2003 #108719# - Notify fly frame, if header frame
 499         // grows. Consider, that 'normal' grow of layout frame already notifys
 500         // the fly frames.
 501         sal_Bool bNotifyFlys = sal_False;
 502         if (nEat > 0)
 503         {
 504             if ( ! bTst)
 505             {
 506                 if (! IsHeaderFrm())
 507                 {
 508                     aPrt.Top(aPrt.Top() - nEat);
 509                     aPrt.Height(aPrt.Height() - nEat);
 510                 }
 511
 512                 InvalidateAll();
 513             }
 514
 515             nResult += nEat;
 516             // OD 14.04.2003 #108719# - trigger fly frame notify.
 517             if ( IsHeaderFrm() )
 518             {
 519                 bNotifyFlys = sal_True;
 520             }
 521         }
 522
 523         if (nDist - nEat > 0)
 524         {
 525             SwTwips nFrmGrow =
 526                 SwLayoutFrm::GrowFrm( nDist - nEat, bTst, bInfo );
 527
 528             nResult += nFrmGrow;
 529             if ( nFrmGrow > 0 )
 530             {
 531                 bNotifyFlys = sal_False;
 532             }
 533         }
 534
 535         // OD 10.04.2003 #108719# - notify fly frames, if necessary and triggered.
 536         if ( ( nResult > 0 ) && bNotifyFlys )
 537         {
 538             NotifyLowerObjs();
 539         }
 540     }
 541
 542     if ( nResult && !bTst )
 543         SetCompletePaint();
 544
 545     return nResult;
 546 }
 547
 548 SwTwips SwHeadFootFrm::ShrinkFrm( SwTwips nDist, BOOL bTst, BOOL bInfo )
 549 {
 550     SwTwips nResult;
 551
 552     if ( IsColLocked() )
 553     {
 554         nResult = 0;
 555     }
 556     else if (! GetEatSpacing())
 557     {
 558         nResult = SwLayoutFrm::ShrinkFrm(nDist, bTst, bInfo);
 559     }
 560     else
 561     {
 562         nResult = 0;
 563
 564         SwTwips nMinHeight = lcl_GetFrmMinHeight(*this);
 565         SwTwips nOldHeight = Frm().Height();
 566         SwTwips nRest = 0; // Amount to shrink by spitting out spacing
 567
 568         if ( nOldHeight >= nMinHeight )
 569         {
 570             /* If the frame's height is bigger than its minimum height, shrink
 571                the frame towards its minimum height. If this is not sufficient
 572                to provide the shrinking requested provide the rest by spitting
 573                out spacing. */
 574
 575             SwTwips nBiggerThanMin = nOldHeight - nMinHeight;
 576
 577             if (nBiggerThanMin < nDist)
 578             {
 579                 nRest = nDist - nBiggerThanMin;
 580             }
 581             /* info: declaration of nRest -> else nRest = 0 */
 582         }
 583         else
 584             /* The frame cannot shrink. Provide shrinking by spitting out
 585                spacing. */
 586             nRest = nDist;
 587
 588         // OD 10.04.2003 #108719# - Notify fly frame, if header/footer frame
 589         // shrinks. Consider, that 'normal' shrink of layout frame already notifys
 590         // the fly frames.
 591         sal_Bool bNotifyFlys = sal_False;
 592         if (nRest > 0)
 593         {
 594
 595             SwBorderAttrAccess * pAccess =
 596                 new SwBorderAttrAccess( SwFrm::GetCache(), this );
 597             ASSERT(pAccess, "no border attributes");
 598
 599             SwBorderAttrs * pAttrs = pAccess->Get();
 600
 601             /* minimal height of print area */
 602             SwTwips nMinPrtHeight = nMinHeight
 603                 - pAttrs->CalcTop()
 604                 - pAttrs->CalcBottom();
 605
 606             if (nMinPrtHeight < 0)
 607                 nMinPrtHeight = 0;
 608
 609             delete pAccess;
 610
 611             /* assume all shrinking can be provided */
 612             SwTwips nShrink = nRest;
 613
 614             /* calculate maximum shrinking */
 615             SwTwips nMaxShrink = aPrt.Height() - nMinPrtHeight;
 616
 617             /* shrink no more than maximum shrinking */
 618             if (nShrink > nMaxShrink)
 619             {
 620                 //nRest -= nShrink - nMaxShrink;
 621                 nShrink = nMaxShrink;
 622             }
 623
 624             if (!bTst)
 625             {
 626                 if (! IsHeaderFrm() )
 627                 {
 628                     aPrt.Top(aPrt.Top() + nShrink);
 629                     aPrt.Height(aPrt.Height() - nShrink);
 630                 }
 631
 632                 InvalidateAll();
 633             }
 634             nResult += nShrink;
 635             // OD 14.04.2003 #108719# - trigger fly frame notify.
 636             if ( IsHeaderFrm() )
 637             {
 638                 bNotifyFlys = sal_True;
 639             }
 640         }
 641
 642         /* The shrinking not providable by spitting out spacing has to be done
 643            by the frame. */
 644         if (nDist - nRest > 0)
 645         {
 646             SwTwips nShrinkAmount = SwLayoutFrm::ShrinkFrm( nDist - nRest, bTst, bInfo );
 647             nResult += nShrinkAmount;
 648             if ( nShrinkAmount > 0 )
 649             {
 650                 bNotifyFlys = sal_False;
 651             }
 652         }
 653
 654         // OD 10.04.2003 #108719# - notify fly frames, if necessary.
 655         if ( ( nResult > 0 ) && bNotifyFlys )
 656         {
 657             NotifyLowerObjs();
 658         }
 659     }
 660
 661     return nResult;
 662 }
 663
 664 BOOL SwHeadFootFrm::GetEatSpacing() const
 665 {
 666     const SwFrmFmt * pFmt = GetFmt();
 667     ASSERT(pFmt, "SwHeadFootFrm: no format?");
 668
 669     if (pFmt->GetHeaderAndFooterEatSpacing().GetValue())
 670         return TRUE;
 671
 672     return FALSE;
 673 }
 674
 675
 676 /*************************************************************************
 677 |*
 678 |*      SwPageFrm::PrepareHeader()
 679 |*
 680 |*      Beschreibung            Erzeugt oder Entfernt Header
 681 |*      Ersterstellung          MA 04. Feb. 93
 682 |*      Letzte Aenderung        MA 12. May. 96
 683 |*
 684 |*************************************************************************/
 685
 686
 687 void DelFlys( SwLayoutFrm *pFrm, SwPageFrm *pPage )
 688 {
 689     for ( int i = 0; pPage->GetSortedObjs() &&
 690                         pPage->GetSortedObjs()->Count() &&
 691                         i < (int)pPage->GetSortedObjs()->Count(); ++i )
 692     {
 693         SwAnchoredObject* pObj = (*pPage->GetSortedObjs())[i];
 694         if ( pObj->ISA(SwFlyFrm) )
 695         {
 696             SwFlyFrm* pFlyFrm = static_cast<SwFlyFrm*>(pObj);
 697             if ( pFrm->IsAnLower( pFlyFrm ) )
 698             {
 699                 delete pFlyFrm;
 700                 --i;
 701             }
 702         }
 703     }
 704 }
 705
 706
 707
 708 void SwPageFrm::PrepareHeader()
 709 {
 710     SwLayoutFrm *pLay = (SwLayoutFrm*)Lower();
 711     if ( !pLay )
 712         return;
 713
 714     const SwFmtHeader &rH = ((SwFrmFmt*)pRegisteredIn)->GetHeader();
 715
 716     const BOOL bOn = !((SwFrmFmt*)pRegisteredIn)->getIDocumentSettingAccess()->get(IDocumentSettingAccess::BROWSE_MODE);
 717
 718     if ( bOn && rH.IsActive() )
 719     {   //Header einsetzen, vorher entfernen falls vorhanden.
 720         ASSERT( rH.GetHeaderFmt(), "FrmFmt fuer Header nicht gefunden." );
 721
 722         if ( pLay->GetFmt() == (SwFrmFmt*)rH.GetHeaderFmt() )
 723             return;     //Der Footer ist bereits der richtige
 724
 725         if ( pLay->IsHeaderFrm() )
 726         {       SwLayoutFrm *pDel = pLay;
 727             pLay = (SwLayoutFrm*)pLay->GetNext();
 728             ::DelFlys( pDel, this );
 729             pDel->Cut();
 730             delete pDel;
 731         }
 732         ASSERT( pLay, "Wohin mit dem Header?" );
 733         SwHeaderFrm *pH = new SwHeaderFrm( (SwFrmFmt*)rH.GetHeaderFmt() );
 734         pH->Paste( this, pLay );
 735         if ( GetUpper() )
 736             ::RegistFlys( this, pH );
 737     }
 738     else if ( pLay && pLay->IsHeaderFrm() )
 739     {   //Header entfernen falls vorhanden.
 740         ::DelFlys( pLay, this );
 741         pLay->Cut();
 742         delete pLay;
 743     }
 744 }
 745 /*************************************************************************
 746 |*
 747 |*      SwPageFrm::PrepareFooter()
 748 |*
 749 |*      Beschreibung            Erzeugt oder Entfernt Footer
 750 |*      Ersterstellung          MA 04. Feb. 93
 751 |*      Letzte Aenderung        MA 12. May. 96
 752 |*
 753 |*************************************************************************/
 754
 755
 756 void SwPageFrm::PrepareFooter()
 757 {
 758     SwLayoutFrm *pLay = (SwLayoutFrm*)Lower();
 759     if ( !pLay )
 760         return;
 761
 762     const SwFmtFooter &rF = ((SwFrmFmt*)pRegisteredIn)->GetFooter();
 763     while ( pLay->GetNext() )
 764         pLay = (SwLayoutFrm*)pLay->GetNext();
 765
 766     const BOOL bOn = !((SwFrmFmt*)pRegisteredIn)->getIDocumentSettingAccess()->get(IDocumentSettingAccess::BROWSE_MODE);
 767
 768     if ( bOn && rF.IsActive() )
 769     {   //Footer einsetzen, vorher entfernen falls vorhanden.
 770         ASSERT( rF.GetFooterFmt(), "FrmFmt fuer Footer nicht gefunden." );
 771
 772         if ( pLay->GetFmt() == (SwFrmFmt*)rF.GetFooterFmt() )
 773             return; //Der Footer ist bereits der richtige.
 774
 775         if ( pLay->IsFooterFrm() )
 776         {       ::DelFlys( pLay, this );
 777             pLay->Cut();
 778             delete pLay;
 779         }
 780         SwFooterFrm *pF = new SwFooterFrm( (SwFrmFmt*)rF.GetFooterFmt() );
 781         pF->Paste( this );
 782         if ( GetUpper() )
 783             ::RegistFlys( this, pF );
 784     }
 785     else if ( pLay && pLay->IsFooterFrm() )
 786     {   //Footer entfernen falls vorhanden.
 787         ::DelFlys( pLay, this );
 788         ViewShell *pSh;
 789         if ( pLay->GetPrev() && 0 != (pSh = GetShell()) &&
 790              pSh->VisArea().HasArea() )
 791             pSh->InvalidateWindows( pSh->VisArea() );
 792         pLay->Cut();
 793         delete pLay;
 794     }
 795 }
 796
 797
 798