lotuswordpro/source/filter/lwppagelayout.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  *  The Contents of this file are made available subject to the terms of
   5  *  either of the following licenses
   6  *
   7  *         - GNU Lesser General Public License Version 2.1
   8  *         - Sun Industry Standards Source License Version 1.1
   9  *
  10  *  Sun Microsystems Inc., October, 2000
  11  *
  12  *  GNU Lesser General Public License Version 2.1
  13  *  =============================================
  14  *  Copyright 2000 by Sun Microsystems, Inc.
  15  *  901 San Antonio Road, Palo Alto, CA 94303, USA
  16  *
  17  *  This library is free software; you can redistribute it and/or
  18  *  modify it under the terms of the GNU Lesser General Public
  19  *  License version 2.1, as published by the Free Software Foundation.
  20  *
  21  *  This library is distributed in the hope that it will be useful,
  22  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24  *  Lesser General Public License for more details.
  25  *
  26  *  You should have received a copy of the GNU Lesser General Public
  27  *  License along with this library; if not, write to the Free Software
  28  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  29  *  MA  02111-1307  USA
  30  *
  31  *
  32  *  Sun Industry Standards Source License Version 1.1
  33  *  =================================================
  34  *  The contents of this file are subject to the Sun Industry Standards
  35  *  Source License Version 1.1 (the "License"); You may not use this file
  36  *  except in compliance with the License. You may obtain a copy of the
  37  *  License at http://www.openoffice.org/license.html.
  38  *
  39  *  Software provided under this License is provided on an "AS IS" basis,
  40  *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  41  *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
  42  *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
  43  *  See the License for the specific provisions governing your rights and
  44  *  obligations concerning the Software.
  45  *
  46  *  The Initial Developer of the Original Code is: IBM Corporation
  47  *
  48  *  Copyright: 2008 by IBM Corporation
  49  *
  50  *  All Rights Reserved.
  51  *
  52  *  Contributor(s): _______________________________________
  53  *
  54  *
  55  ************************************************************************/
  56 /*************************************************************************
  57  * Change History
  58 Mar 2005            Created
  59  ************************************************************************/
  60 #include "lwppagelayout.hxx"
  61 #include "lwplaypiece.hxx"
  62 #include "lwpfootnote.hxx"
  63 #include "lwpdoc.hxx"
  64 #include "lwpholder.hxx"
  65 #include "lwppagehint.hxx"
  66 #include "lwpdivinfo.hxx"
  67 #include "lwpstory.hxx"
  68 #include "xfilter/xfstylemanager.hxx"
  69 #include "xfilter/xfmasterpage.hxx"
  70 #include "xfilter/xfcontentcontainer.hxx"
  71 #include "xfilter/xfheader.hxx"
  72 #include "xfilter/xfheaderstyle.hxx"
  73 #include "xfilter/xffooterstyle.hxx"
  74 #include "xfilter/xffooter.hxx"
  75 #include <sfx2/printer.hxx>
  76 #include "lwpchangemgr.hxx"
  77 #include "lwpglobalmgr.hxx"
  78
  79 LwpPageLayout::LwpPageLayout(LwpObjectHeader &objHdr, LwpSvStream* pStrm)
  80     : LwpLayout(objHdr, pStrm), m_pPrinterBinName(new LwpAtomHolder),
  81     m_pPaperName(new LwpAtomHolder),m_pXFPageMaster(NULL)
  82 {
  83 }
  84
  85 LwpPageLayout::~LwpPageLayout()
  86 {
  87     if (m_pPrinterBinName)
  88     {
  89         delete m_pPrinterBinName;
  90     }
  91     if (m_pPaperName)
  92     {
  93         delete m_pPaperName;
  94     }
  95 }
  96 void LwpPageLayout::Read()
  97 {
  98     LwpLayout::Read();
  99
 100     if (LwpFileHeader::m_nFileRevision < 0x000B)
 101     {
 102         // read PreRevBLayout...
 103     }
 104
 105     m_nPrinterBin = m_pObjStrm->QuickReaduInt16();
 106     m_pPrinterBinName->Read(m_pObjStrm);
 107
 108     if (LwpFileHeader::m_nFileRevision >= 0x000B)
 109         m_nBdroffset = m_pObjStrm->QuickReadInt32();
 110
 111     if (m_pObjStrm->CheckExtra())
 112     {
 113         m_pPaperName->Read(m_pObjStrm);
 114         m_pObjStrm->SkipExtra();
 115     }
 116
 117 }
 118
 119 void LwpPageLayout::Parse(IXFStream* pOutputStream)
 120 {
 121     //Only parse this layout
 122     LwpObject* pStory = m_Content.obj();
 123     if(pStory)
 124     {
 125         pStory->SetFoundry(m_pFoundry);
 126         pStory->Parse(pOutputStream);   //Do not parse the next story
 127     }
 128 }
 129
 130 /**
 131 * @descr:   set page margins
 132 *
 133 */
 134 void LwpPageLayout::ParseMargins(XFPageMaster* pm1)
 135 {
 136     double fLeft    = GetMarginsValue(MARGIN_LEFT);
 137     double fRight   = GetMarginsValue(MARGIN_RIGHT);
 138     double fTop = GetMarginsValue(MARGIN_TOP);
 139     double fBottom  = GetMarginsValue(MARGIN_BOTTOM);
 140
 141     pm1->SetMargins( fLeft, fRight, fTop, fBottom );
 142
 143 }
 144
 145 /**
 146 * @descr:   set page height and width
 147 *
 148 */
 149 void LwpPageLayout::ParseGeometry(XFPageMaster* pm1)
 150 {
 151     /*
 152     LwpLayoutGeometry* pLayoutGeo = GetGeometry();
 153     if(pLayoutGeo)
 154     {
 155         pm1->SetPageHeight( GetGeometryHeight() );
 156         pm1->SetPageWidth( GetGeometryWidth() );
 157     }
 158     */
 159     double fWidth =0;
 160     double fHeight = 0;
 161     GetWidthAndHeight(fWidth, fHeight);
 162     pm1->SetPageWidth( fWidth );
 163     pm1->SetPageHeight( fHeight );
 164 }
 165
 166 /**
 167 * @descr:   set page watermark
 168 *
 169 */
 170 void LwpPageLayout::ParseWaterMark(XFPageMaster *pm1)
 171 {
 172     XFBGImage* pXFBGImage = GetXFBGImage();
 173     if(pXFBGImage)
 174     {
 175         pm1->SetBackImage(pXFBGImage);
 176     }
 177 }
 178
 179 /**
 180 * @descr:   set page columns
 181 *
 182 */
 183 void LwpPageLayout::ParseColumns(XFPageMaster * pm1)
 184 {
 185     XFColumns* pColumns = GetXFColumns();
 186     if(pColumns)
 187     {
 188         pm1->SetColumns(pColumns);
 189     }
 190 }
 191
 192 /**
 193 * @descr:   set page borders
 194 *
 195 */
 196 void LwpPageLayout::ParseBorders(XFPageMaster *pm1)
 197 {
 198     XFBorders* pBordres = GetXFBorders();
 199     if(pBordres)
 200     {
 201         pm1->SetBorders(pBordres);
 202     }
 203 }
 204
 205
 206 /**
 207 * @descr:   set page shadow
 208 *
 209 */
 210 void LwpPageLayout::ParseShadow(XFPageMaster *pm1)
 211 {
 212     XFShadow* pXFShadow = GetXFShadow();
 213     if(pXFShadow)
 214     {
 215         pm1->SetShadow(pXFShadow);
 216     }
 217 }
 218
 219 /**
 220 * @descr:   set page back pattern
 221 *
 222 */
 223 void LwpPageLayout::ParsePatternFill(XFPageMaster* pm1)
 224 {
 225     XFBGImage* pXFBGImage = this->GetFillPattern();
 226     if (pXFBGImage)
 227     {
 228         pm1->SetBackImage(pXFBGImage);
 229     }
 230 }
 231 /**
 232 * @descr:   set page background
 233 *
 234 */
 235 void LwpPageLayout::ParseBackGround(XFPageMaster* pm1)
 236 {
 237     if (this->IsPatternFill())
 238     {
 239         ParsePatternFill(pm1);
 240     }
 241     else
 242     {
 243         ParseBackColor(pm1);
 244     }
 245 }
 246
 247 /**
 248 * @descr:   set page back color
 249 *
 250 */
 251 void LwpPageLayout::ParseBackColor(XFPageMaster* pm1)
 252 {
 253     LwpColor* pColor = GetBackColor();
 254     if(pColor)
 255     {
 256         pm1->SetBackColor(XFColor(pColor->To24Color()));
 257     }
 258 }
 259
 260 /**
 261 * @descr:   set page footnote separator information
 262 *
 263 */
 264 void LwpPageLayout::ParseFootNoteSeparator(XFPageMaster * pm1)
 265 {
 266     //Get the footnoteoptions for the root document
 267     LwpDocument* pDocument = m_pFoundry->GetDocument();
 268     if(pDocument)
 269     {
 270         LwpObjectID* pFontnodeId = pDocument->GetValidFootnoteOpts();
 271
 272         LwpFootnoteOptions* pFootnoteOpts = pFontnodeId ? dynamic_cast<LwpFootnoteOptions*>(pFontnodeId->obj()) : NULL;
 273         if(pFootnoteOpts)
 274         {
 275             LwpFootnoteSeparatorOptions* pFootnoteSep = pFootnoteOpts->GetFootnoteSeparator();
 276             //set length
 277             sal_uInt32 nLengthPercent = 100;
 278             double fWidth = 0;
 279             if(pFootnoteSep->HasSeparator())
 280             {
 281                 fWidth = pFootnoteSep->GetTopBorderWidth();
 282             }
 283             if(pFootnoteSep->HasCustomLength())
 284             {
 285                 nLengthPercent =  static_cast<sal_uInt32>(100*LwpTools::ConvertFromUnitsToMetric(pFootnoteSep->GetLength())/GetMarginWidth());
 286                 if(nLengthPercent > 100)
 287                     nLengthPercent = 100;
 288             }
 289             double fAbove = LwpTools::ConvertFromUnitsToMetric(pFootnoteSep->GetAbove());
 290             double fBelow = LwpTools::ConvertFromUnitsToMetric(pFootnoteSep->GetBelow());
 291             LwpColor aColor = pFootnoteSep->GetTopBorderColor();
 292             enumXFAlignType eAlignType = enumXFAlignStart;
 293             if(pFootnoteSep->GetIndent() > 0)
 294             {
 295                 //SODC don't support indent
 296                 sal_uInt32 nIndentPercent =  static_cast<sal_uInt32>(100*LwpTools::ConvertFromUnitsToMetric(pFootnoteSep->GetIndent())/GetMarginWidth());
 297                 if(nIndentPercent + nLengthPercent >= 100)
 298                     eAlignType = enumXFAlignEnd;
 299             }
 300             if(aColor.IsValidColor())
 301             {
 302                 XFColor aXFColor(aColor.To24Color());
 303                 pm1->SetFootNoteSeparator(eAlignType,fWidth, nLengthPercent, fAbove, fBelow, aXFColor);
 304             }
 305         }
 306     }
 307 }
 308
 309 /**
 310 * @descr:   Register master page and page master style
 311 *
 312 */
 313 void LwpPageLayout::RegisterStyle()
 314 {
 315     XFPageMaster* pm1 = new XFPageMaster();
 316     m_pXFPageMaster = pm1;
 317
 318     ParseGeometry( pm1 );
 319     //Does not process LayoutScale, for watermark is not supported in SODC.
 320     ParseWaterMark( pm1);
 321     ParseMargins( pm1);
 322     ParseColumns(pm1);
 323     ParseBorders(pm1);
 324     ParseShadow(pm1);
 325 //  ParseBackColor(pm1);
 326     ParseBackGround(pm1);
 327     ParseFootNoteSeparator(pm1);
 328     pm1->SetTextDir(GetTextDirection());
 329
 330     LwpUseWhen* pUseWhen = GetUseWhen();
 331     if(IsComplex() ||( pUseWhen && pUseWhen->IsUseOnAllOddPages()))
 332     {
 333         pm1->SetPageUsage(enumXFPageUsageMirror);
 334     }
 335
 336     //Add the page master to stylemanager
 337     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
 338     m_pXFPageMaster = pm1 = (XFPageMaster*)pXFStyleManager->AddStyle(pm1);
 339     OUString pmname = pm1->GetStyleName();
 340
 341     //Add master page
 342     XFMasterPage* mp1 = new XFMasterPage();
 343     mp1->SetStyleName(GetName()->str());
 344     mp1->SetPageMaster(pmname);
 345     mp1 = (XFMasterPage*)pXFStyleManager->AddStyle(mp1);
 346     m_StyleName = mp1->GetStyleName();
 347
 348     //Set footer style
 349     LwpFooterLayout* pLayoutFooter = GetFooterLayout();
 350     if(pLayoutFooter)
 351     {
 352         pLayoutFooter->SetFoundry(m_pFoundry);
 353         pLayoutFooter->RegisterStyle(pm1);
 354         pLayoutFooter->RegisterStyle(mp1);
 355     }
 356
 357     //Set header style
 358     LwpHeaderLayout* pLayoutHeader = GetHeaderLayout();
 359     if(pLayoutHeader)
 360     {
 361         pLayoutHeader->SetFoundry(m_pFoundry);
 362         pLayoutHeader->RegisterStyle(pm1);
 363         pLayoutHeader->RegisterStyle(mp1);
 364     }
 365     //register child layout style for mirror page and frame
 366     RegisterChildStyle();
 367 }
 368
 369 /**
 370 * @descr:   Register master page for endnote which name is "endnote"
 371 * @return:  Return the master page name.
 372 */
 373 OUString LwpPageLayout::RegisterEndnoteStyle()
 374 {
 375     XFPageMaster* pm1 = new XFPageMaster();
 376     m_pXFPageMaster = pm1;
 377
 378     ParseGeometry( pm1 );
 379     ParseWaterMark( pm1);
 380     ParseMargins( pm1);
 381     ParseColumns(pm1);
 382     ParseBorders(pm1);
 383     ParseShadow(pm1);
 384 //  ParseBackColor(pm1);
 385     ParseBackGround(pm1);
 386     //ParseFootNoteSeparator(pm1);
 387     pm1->SetTextDir(GetTextDirection());
 388
 389     LwpUseWhen* pUseWhen = GetUseWhen();
 390     if(IsComplex() ||( pUseWhen && pUseWhen->IsUseOnAllOddPages()))
 391     {
 392         pm1->SetPageUsage(enumXFPageUsageMirror);
 393     }
 394
 395     //Add the page master to stylemanager
 396     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
 397     m_pXFPageMaster = pm1 = (XFPageMaster*)pXFStyleManager->AddStyle(pm1);
 398     OUString pmname = pm1->GetStyleName();
 399
 400     //Add master page
 401     XFMasterPage* mp1 = new XFMasterPage();
 402     mp1->SetStyleName(A2OUSTR("Endnote"));
 403     mp1->SetPageMaster(pmname);
 404
 405     //Set footer style
 406     LwpFooterLayout* pLayoutFooter = GetFooterLayout();
 407     if(pLayoutFooter)
 408     {
 409         pLayoutFooter->SetFoundry(m_pFoundry);
 410         pLayoutFooter->RegisterStyle(pm1);
 411         pLayoutFooter->RegisterStyle(mp1);
 412     }
 413
 414     //Set header style
 415     LwpHeaderLayout* pLayoutHeader = GetHeaderLayout();
 416     if(pLayoutHeader)
 417     {
 418         pLayoutHeader->SetFoundry(m_pFoundry);
 419         pLayoutHeader->RegisterStyle(pm1);
 420         pLayoutHeader->RegisterStyle(mp1);
 421     }
 422
 423     return pXFStyleManager->AddStyle(mp1)->GetStyleName();
 424 }
 425 /**
 426 * @descr:   Whether current page layout has columns
 427 *
 428 */
 429 sal_Bool LwpPageLayout::HasColumns()
 430 {
 431     return GetNumCols() > 1 ? sal_True : sal_False;
 432 }
 433
 434 /**
 435 * @descr:   Whether has filler page text in current page layout
 436 *
 437 */
 438 sal_Bool LwpPageLayout::HasFillerPageText(LwpFoundry* pFoundry)
 439 {
 440     if(!pFoundry) return sal_False;
 441
 442     sal_Bool bFillerPage = sal_False;
 443     LwpLayout::UseWhenType eWhenType = GetUseWhenType();
 444     if(eWhenType==LwpLayout::StartOnOddPage||eWhenType==LwpLayout::StartOnEvenPage)
 445     {
 446         //get pagenumber
 447         sal_uInt16 nPageNumber = 0;
 448
 449         //get the page number that current page layout inserted
 450         nPageNumber = GetPageNumber(FIRST_LAYOUTPAGENO)-1;
 451
 452         if(nPageNumber>0)
 453         {
 454             if((eWhenType==LwpLayout::StartOnOddPage)&&(LwpTools::IsOddNumber(nPageNumber)))
 455             {
 456                 bFillerPage = sal_True;
 457             }
 458             else if((eWhenType==LwpLayout::StartOnEvenPage)&&(LwpTools::IsEvenNumber(nPageNumber)))
 459             {
 460                 bFillerPage = sal_True;
 461             }
 462             else
 463             {
 464                 bFillerPage = sal_False;
 465             }
 466         }
 467     }
 468
 469     return bFillerPage;
 470 }
 471
 472 /**
 473 * @descr:   Parse filler page text
 474 *
 475 */
 476 void LwpPageLayout::ConvertFillerPageText(XFContentContainer* pCont)
 477 {
 478     if(HasFillerPageText(m_pFoundry))
 479     {
 480         //get filerpage story from division info
 481         LwpDocument* pDoc = m_pFoundry->GetDocument();
 482         LwpDivInfo* pDivInfo = dynamic_cast<LwpDivInfo*>(pDoc->GetDivInfoID()->obj());
 483         LwpStory* pStory = dynamic_cast<LwpStory*>(pDivInfo->GetFillerPageTextID()->obj());
 484
 485         //parse fillerpage story
 486         if(pStory)
 487         {
 488             pStory->XFConvert(pCont);
 489         }
 490     }
 491 }
 492 /**
 493 * @descr:   Clear columns style in page layout
 494 *
 495 */
 496 void LwpPageLayout::ResetXFColumns()
 497 {
 498     if(m_pXFPageMaster)
 499     {
 500         m_pXFPageMaster->SetColumns(NULL);
 501     }
 502 }
 503
 504 LwpHeaderLayout* LwpPageLayout::GetHeaderLayout()
 505 {
 506     LwpVirtualLayout* pLay = dynamic_cast<LwpVirtualLayout*>(GetChildHead()->obj());
 507     while(pLay)
 508     {
 509         if( pLay->GetLayoutType() == LWP_HEADER_LAYOUT )
 510             return ( static_cast<LwpHeaderLayout*> (pLay) );
 511         pLay = dynamic_cast<LwpVirtualLayout*> (pLay->GetNext()->obj());
 512     }
 513     return NULL;
 514 }
 515
 516 LwpFooterLayout* LwpPageLayout::GetFooterLayout()
 517 {
 518     LwpVirtualLayout* pLay = dynamic_cast<LwpVirtualLayout*>(GetChildHead()->obj());
 519     while(pLay)
 520     {
 521         if( pLay->GetLayoutType() == LWP_FOOTER_LAYOUT )
 522             return ( static_cast<LwpFooterLayout*> (pLay) );
 523         pLay = dynamic_cast<LwpVirtualLayout*> (pLay->GetNext()->obj());
 524     }
 525     return NULL;
 526 }
 527
 528 /**
 529 * @descr:   Get the odd layout if current page layout is mirror page
 530 *
 531 */
 532 LwpPageLayout* LwpPageLayout::GetOddChildLayout()
 533 {
 534     if(IsComplex())
 535     {
 536         LwpVirtualLayout* pLay = dynamic_cast<LwpVirtualLayout*>(GetChildHead()->obj());
 537         while(pLay)
 538         {
 539             if( pLay->GetLayoutType() == LWP_PAGE_LAYOUT )
 540             {
 541                 LwpPageLayout* pPageLayout = static_cast<LwpPageLayout*> (pLay);
 542                 LwpUseWhen* pUseWhen = pPageLayout->GetUseWhen();
 543                 if(pUseWhen && pUseWhen->IsUseOnAllOddPages())
 544                 {
 545                     return pPageLayout;
 546                 }
 547             }
 548             pLay = dynamic_cast<LwpVirtualLayout*> (pLay->GetNext()->obj());
 549         }
 550     }
 551     return NULL;
 552 }
 553
 554 /**
 555 * @descr:   Get margin width of page
 556 *
 557 */
 558 double LwpPageLayout::GetMarginWidth()
 559 {
 560     double fPagewidth = GetGeometryWidth();
 561     double fLeftMargin = GetMarginsValue(MARGIN_LEFT);
 562     double fRightMargin = GetMarginsValue(MARGIN_RIGHT);
 563
 564     return fPagewidth - (fLeftMargin + fRightMargin);
 565 }
 566
 567 /**
 568  * @descr:  Get the pagenumber
 569  * @param:  if  nLayoutNumber =FIRST_LAYOUTPAGENO,  return the first page number  that current page layout covers
 570                               =LAST_LAYOUTPAGENO, return the last page number that current page layout covers
 571                                else, return the specified page number that current page layout covers
 572  * @param:
 573  * @return:  if reture value >=0, success to find the page number, or fail.
 574 */
 575 sal_Int32 LwpPageLayout::GetPageNumber(sal_uInt16 nLayoutNumber)
 576 {
 577     sal_Int16 nPageNumber = -1;
 578     LwpFoundry* pFoundry = this->GetFoundry();
 579     LwpDocument* pDoc = pFoundry->GetDocument();
 580     LwpDLVListHeadTailHolder* pHeadTail = dynamic_cast<LwpDLVListHeadTailHolder*>(pDoc->GetPageHintsID()->obj());
 581     if(!pHeadTail) return nPageNumber;
 582
 583     //get first pagehint
 584     LwpPageHint* pPageHint = dynamic_cast<LwpPageHint*>(pHeadTail->GetHead()->obj());
 585     while(pPageHint)
 586     {
 587         if(*(this->GetObjectID()) == *(pPageHint->GetPageLayoutID()))
 588         {
 589             sal_uInt16 nNumber = pPageHint->GetPageNumber();
 590             if(nLayoutNumber==FIRST_LAYOUTPAGENO && pPageHint->GetLayoutPageNumber()==1)
 591             {
 592                 //get the first page number
 593                 nPageNumber = nNumber;
 594                 break;
 595             }
 596             else if( nLayoutNumber ==LAST_LAYOUTPAGENO && nNumber >nPageNumber )
 597             {
 598                 //get the last page number
 599                 nPageNumber = nNumber;
 600                 if(pPageHint->GetNext()->IsNull())
 601                 {
 602                     //if is last page number of entire document, reture directly
 603                     return nPageNumber + pDoc->GetNumberOfPagesBefore();
 604                 }
 605             }
 606             else if(nLayoutNumber > 0 && pPageHint->GetLayoutPageNumber() == nLayoutNumber)
 607             {
 608                 //get specified page number
 609                 nPageNumber = nNumber;
 610                 break;
 611             }
 612
 613         }
 614         pPageHint = dynamic_cast<LwpPageHint*>(pPageHint->GetNext()->obj());
 615     }
 616     if(nPageNumber>=0)
 617     {
 618         return nPageNumber + 1 + pDoc->GetNumberOfPagesBefore();
 619     }
 620     return -1;
 621 }
 622
 623 /**
 624 * @descr:   Get page width and height
 625 *
 626 */
 627 void LwpPageLayout::GetWidthAndHeight(double& fWidth, double& fHeight)
 628 {
 629     //use customized size
 630     LwpLayoutGeometry* pLayoutGeo = GetGeometry();
 631     if(pLayoutGeo)
 632     {
 633         fWidth = GetGeometryWidth();
 634         fHeight = GetGeometryHeight();
 635     }
 636
 637     if(GetUsePrinterSettings())
 638     {
 639         //replaced by printer paper size
 640         Printer aPrinter;
 641         sal_Bool bScreen = aPrinter.IsDisplayPrinter();
 642         if (!bScreen)//Printer available
 643         {
 644             Size aPaperSize = aPrinter.GetPaperSize();
 645             aPaperSize = aPrinter.PixelToLogic( aPaperSize, MapMode( MAP_10TH_MM ) );
 646             fWidth = static_cast<double>(aPaperSize.Width())/100;   //cm unit
 647             fHeight = static_cast<double>(aPaperSize.Height())/100;
 648         }
 649     }
 650
 651     //Follow the former design of Lotus WordPro filter, some default will be given:
 652     //Page Width: 8.5 Inch -> 21.59 cm
 653     //Page Height: 11 Inch -> 27.94 cm
 654     if (fWidth < 4.39)
 655         fWidth = 21.59;
 656     if (fHeight < 4.49)
 657         fHeight = 27.94;
 658     //End of modification, by ZF
 659 }
 660
 661 /**
 662 * @descr:   Get page width
 663 *
 664 */
 665 double LwpPageLayout::GetWidth()
 666 {
 667     double fWidth =0, fHeight = 0;
 668     GetWidthAndHeight(fWidth, fHeight);
 669     return fWidth;
 670 }
 671
 672 /**
 673 * @descr:   Get page height
 674 *
 675 */
 676 double LwpPageLayout::GetHeight()
 677 {
 678     double fWidth =0, fHeight = 0;
 679     GetWidthAndHeight(fWidth, fHeight);
 680     return fHeight;
 681 }
 682 /**
 683 * @descr:  Compare the position of layout. If the poistion of this layout is earlier than other layout,return ture, or return false
 684 *
 685 */
 686 sal_Bool LwpPageLayout::operator<(LwpPageLayout& Other)
 687 {
 688     LwpPara* pThisPara = GetPagePosition();
 689     LwpPara* pOtherPara = Other.GetPagePosition();
 690     if(pThisPara && pOtherPara)
 691     {
 692         if(pThisPara == pOtherPara)
 693         {
 694             //If the two layouts in the same para, compare which layout is earlied according to frib order
 695             return pThisPara->ComparePagePosition(this, &Other);
 696         }
 697         else
 698         {
 699             return *pThisPara < *pOtherPara;
 700         }
 701     }
 702
 703     if(!pThisPara)
 704         return sal_True;
 705
 706     return sal_False;
 707 }
 708
 709 /**
 710 * @descr:  Get the position of pagelayout
 711 *
 712 */
 713 LwpPara* LwpPageLayout::GetPagePosition()
 714 {
 715     LwpPara* pPara = dynamic_cast<LwpPara*>(GetPosition()->obj());
 716     if(pPara)
 717         return pPara;
 718     //Get the position from its related section
 719     LwpSection* pSection = NULL;
 720     LwpFoundry* pFoundry = GetFoundry();
 721     if(pFoundry)
 722     {
 723         while( (pSection = pFoundry->EnumSections(pSection)) )
 724         {
 725             if(pSection->GetPageLayout() == this)
 726                 return dynamic_cast<LwpPara*>(pSection->GetPosition()->obj());
 727         }
 728     }
 729
 730     return NULL;
 731 }
 732 LwpHeaderLayout::LwpHeaderLayout( LwpObjectHeader &objHdr, LwpSvStream* pStrm )
 733     : LwpPlacableLayout(objHdr, pStrm)
 734 {
 735 }
 736
 737 LwpHeaderLayout::~LwpHeaderLayout()
 738 {
 739 }
 740
 741 void LwpHeaderLayout::Read()
 742 {
 743     LwpPlacableLayout::Read();
 744
 745     if(LwpFileHeader::m_nFileRevision >= 0x000E)
 746         m_nBorderOffset = m_pObjStrm->QuickReadInt32();
 747     else
 748         m_nBorderOffset = 0;
 749     m_pObjStrm->SkipExtra();
 750 }
 751
 752
 753 void LwpHeaderLayout::RegisterStyle(XFPageMaster* pm1)
 754 {
 755     XFHeaderStyle* pHeaderStyle = new XFHeaderStyle();
 756
 757     //Modify page top margin
 758     //page top maring: from top of header to the top edge
 759     double top = GetMarginsValue(MARGIN_TOP);
 760     pm1->SetMargins(-1, -1, top, -1);
 761
 762     ParseMargins(pHeaderStyle);
 763     ParseBorder(pHeaderStyle);
 764     ParseShadow(pHeaderStyle);
 765 //  ParseBackColor(pHeaderStyle);
 766     ParseBackGround(pHeaderStyle);
 767
 768     ParseWaterMark(pHeaderStyle);
 769     //End by
 770
 771     pm1->SetHeaderStyle(pHeaderStyle);
 772 }
 773
 774 void LwpHeaderLayout::ParseMargins(XFHeaderStyle* ph1)
 775 {
 776     //Set height: from top of header to top of body, including the spacing between header and body
 777     double height = GetGeometryHeight()- GetMarginsValue(MARGIN_TOP);
 778     if( IsAutoGrowDown() )
 779     {
 780         ph1->SetMinHeight(height);
 781     }
 782     else
 783     {
 784         ph1->SetHeight(height);
 785     }
 786
 787     //Set left,right,bottom margins
 788     LwpMiddleLayout* parent = dynamic_cast<LwpMiddleLayout*> (GetParent()->obj());
 789     //left margin in SODC: the space from the left edge of body to the left edge of header
 790     double left = GetMarginsValue(MARGIN_LEFT) - (parent ? parent->GetMarginsValue(MARGIN_LEFT) : 0);
 791     if(left<=0) //The left margin in SODC can not be minus value
 792     {
 793         left = -1;
 794     }
 795     //left margin in SODC: the space from the right edge of header to the right edge of body
 796     double right = GetMarginsValue(MARGIN_RIGHT) - (parent ? parent->GetMarginsValue(MARGIN_RIGHT) : 0);
 797     if(right<=0)//The right margin in SODC can not be minus value
 798     {
 799         right = -1;
 800     }
 801     ph1->SetMargins( left, right, GetMarginsValue(MARGIN_BOTTOM));
 802
 803     //Word Pro has no dynamic spacing, should be set to false
 804     ph1->SetDynamicSpace(sal_False);
 805 }
 806
 807 void LwpHeaderLayout::ParseBorder(XFHeaderStyle* pHeaderStyle)
 808 {
 809     XFBorders* pBordres = GetXFBorders();
 810     if(pBordres)
 811     {
 812         pHeaderStyle->SetBorders(pBordres);
 813     }
 814 }
 815
 816 void LwpHeaderLayout::ParseShadow(XFHeaderStyle* pHeaderStyle)
 817 {
 818     XFShadow* pXFShadow = GetXFShadow();
 819     if(pXFShadow)
 820     {
 821         pHeaderStyle->SetShadow(pXFShadow);
 822     }
 823 }
 824
 825 /**
 826 * @descr:   set header back pattern
 827 *
 828 */
 829 void LwpHeaderLayout::ParsePatternFill(XFHeaderStyle* pHeaderStyle)
 830 {
 831     XFBGImage* pXFBGImage = this->GetFillPattern();
 832     if (pXFBGImage)
 833     {
 834         pHeaderStyle->SetBackImage(pXFBGImage);
 835     }
 836 }
 837 /**
 838 * @descr:   set header background
 839 *
 840 */
 841 void LwpHeaderLayout::ParseBackGround(XFHeaderStyle* pHeaderStyle)
 842 {
 843     if (this->IsPatternFill())
 844     {
 845         ParsePatternFill(pHeaderStyle);
 846     }
 847     else
 848     {
 849         ParseBackColor(pHeaderStyle);
 850     }
 851 }
 852
 853 void LwpHeaderLayout::ParseBackColor(XFHeaderStyle* pHeaderStyle)
 854 {
 855     LwpColor* pColor = GetBackColor();
 856     if(pColor)
 857     {
 858         pHeaderStyle->SetBackColor(XFColor(pColor->To24Color()));
 859     }
 860 }
 861
 862
 863 void LwpHeaderLayout::ParseWaterMark(XFHeaderStyle * pHeaderStyle)
 864 {
 865     XFBGImage* pXFBGImage = GetXFBGImage();
 866     if(pXFBGImage)
 867     {
 868         pHeaderStyle->SetBackImage(pXFBGImage);
 869     }
 870 }
 871 //End by
 872
 873 void LwpHeaderLayout::RegisterStyle(XFMasterPage* mp1)
 874 {
 875     XFHeader* pHeader = new XFHeader();
 876     LwpObject* pStory = m_Content.obj();
 877     if(pStory)
 878     {
 879         LwpGlobalMgr* pGlobal = LwpGlobalMgr::GetInstance();
 880         LwpChangeMgr* pChangeMgr = pGlobal->GetLwpChangeMgr();
 881         pChangeMgr->SetHeadFootFribMap(sal_True);
 882
 883         //Call the RegisterStyle first to register the styles in header paras, and then XFConvert()
 884         pStory->SetFoundry(m_pFoundry);
 885         pStory->RegisterStyle();
 886         //, 06/27/2005
 887         //register child layout style for framelayout,
 888         RegisterChildStyle();
 889         //End
 890         pChangeMgr->SetHeadFootChange(pHeader);
 891         pStory->XFConvert(pHeader);
 892
 893         pChangeMgr->SetHeadFootFribMap(sal_False);
 894     }
 895     mp1->SetHeader(pHeader);
 896 }
 897
 898 LwpFooterLayout::LwpFooterLayout( LwpObjectHeader &objHdr, LwpSvStream* pStrm )
 899     : LwpPlacableLayout( objHdr, pStrm )
 900 {
 901 }
 902
 903 LwpFooterLayout::~LwpFooterLayout()
 904 {
 905 }
 906
 907 void LwpFooterLayout::Read()
 908 {
 909     LwpPlacableLayout::Read();
 910
 911     if(LwpFileHeader::m_nFileRevision >= 0x000E)
 912         m_nBorderOffset = m_pObjStrm->QuickReadInt32();
 913     else
 914         m_nBorderOffset = 0;
 915     m_pObjStrm->SkipExtra();
 916 }
 917
 918 void LwpFooterLayout::RegisterStyle(XFPageMaster* pm1)
 919 {
 920     XFFooterStyle* pFooterStyle = new XFFooterStyle();
 921
 922     //Modify page bottom margin
 923     //page bottom maring: from bottom of footer to the bottom edge
 924     double bottom = GetMarginsValue(MARGIN_BOTTOM);
 925     pm1->SetMargins(-1, -1, -1, bottom);
 926
 927     ParseMargins(pFooterStyle);
 928     ParseBorder(pFooterStyle);
 929     ParseShadow(pFooterStyle);
 930     ParseBackGround(pFooterStyle);
 931 //  ParseBackColor(pFooterStyle);
 932
 933     ParseWaterMark(pFooterStyle);
 934     //End by
 935
 936     pm1->SetFooterStyle(pFooterStyle);
 937 }
 938
 939 void LwpFooterLayout::ParseMargins(XFFooterStyle* pFooterStyle)
 940 {
 941
 942     //Set height: from top of header to top of body, including the spacing between header and body
 943     double height = GetGeometryHeight() - GetMarginsValue(MARGIN_BOTTOM);
 944     if( IsAutoGrowUp() )
 945     {
 946         pFooterStyle->SetMinHeight(height);
 947     }
 948     else
 949     {
 950         pFooterStyle->SetHeight(height);
 951     }
 952
 953     //Set left,right,top margins
 954     LwpMiddleLayout* parent = dynamic_cast<LwpMiddleLayout*> (GetParent()->obj());
 955     double left = GetMarginsValue(MARGIN_LEFT) - (parent ? parent->GetMarginsValue(MARGIN_LEFT) : 0);
 956     if(left<=0) //The left margin in SODC can not be minus value
 957     {
 958         left = -1;
 959     }
 960     double right = GetMarginsValue(MARGIN_RIGHT) - (parent ? parent->GetMarginsValue(MARGIN_RIGHT) : 0);
 961     if(right<=0)//The left margin in SODC can not be minus value
 962     {
 963         right = -1;
 964     }
 965     pFooterStyle->SetMargins( left, right, GetMarginsValue(MARGIN_TOP));
 966
 967     //Word Pro has no dynamic spacing, should be set to false
 968     pFooterStyle->SetDynamicSpace(sal_False);
 969 }
 970
 971 void LwpFooterLayout::ParseBorder(XFFooterStyle* pFooterStyle)
 972 {
 973     XFBorders* pBordres = GetXFBorders();
 974     if(pBordres)
 975     {
 976         pFooterStyle->SetBorders(pBordres);
 977     }
 978 }
 979
 980 void LwpFooterLayout::ParseShadow(XFFooterStyle* pFooterStyle)
 981 {
 982     XFShadow* pXFShadow = GetXFShadow();
 983     if(pXFShadow)
 984     {
 985         pFooterStyle->SetShadow(pXFShadow);
 986     }
 987 }
 988 /**
 989 * @descr:   set footer back pattern
 990 *
 991 */
 992 void LwpFooterLayout::ParsePatternFill(XFFooterStyle* pFooterStyle)
 993 {
 994     XFBGImage* pXFBGImage = this->GetFillPattern();
 995     if (pXFBGImage)
 996     {
 997         pFooterStyle->SetBackImage(pXFBGImage);
 998     }
 999 }
1000 /**
1001 * @descr:   set footer background
1002 *
1003 */
1004 void LwpFooterLayout::ParseBackGround(XFFooterStyle* pFooterStyle)
1005 {
1006     if (this->IsPatternFill())
1007     {
1008         ParsePatternFill(pFooterStyle);
1009     }
1010     else
1011     {
1012         ParseBackColor(pFooterStyle);
1013     }
1014 }
1015
1016 void LwpFooterLayout::ParseBackColor(XFFooterStyle* pFooterStyle)
1017 {
1018     LwpColor* pColor = GetBackColor();
1019     if(pColor)
1020     {
1021         pFooterStyle->SetBackColor(XFColor(pColor->To24Color()));
1022     }
1023 }
1024
1025 void LwpFooterLayout::RegisterStyle(XFMasterPage* mp1)
1026 {
1027     XFFooter* pFooter = new XFFooter();
1028     LwpObject* pStory = m_Content.obj(VO_STORY);
1029     //Call the RegisterStyle first to register the styles in footer paras, and then XFConvert()
1030     if(pStory)
1031     {
1032         LwpGlobalMgr* pGlobal = LwpGlobalMgr::GetInstance();
1033         LwpChangeMgr* pChangeMgr = pGlobal->GetLwpChangeMgr();
1034         pChangeMgr->SetHeadFootFribMap(sal_True);
1035
1036         pStory->SetFoundry(m_pFoundry);
1037         pStory->RegisterStyle();
1038         //, 06/27/2005
1039         //register child layout style for framelayout,
1040         RegisterChildStyle();
1041         //End
1042
1043         pChangeMgr->SetHeadFootChange(pFooter);//add by ,7/6
1044
1045         pStory->XFConvert(pFooter);
1046
1047         pChangeMgr->SetHeadFootFribMap(sal_False);
1048     }
1049     mp1->SetFooter(pFooter);
1050 }
1051
1052
1053 void LwpFooterLayout::ParseWaterMark(XFFooterStyle * pFooterStyle)
1054 {
1055     XFBGImage* pXFBGImage = GetXFBGImage();
1056     if(pXFBGImage)
1057     {
1058         pFooterStyle->SetBackImage(pXFBGImage);
1059     }
1060 }
1061 //End by
1062
1063 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */