lotuswordpro/source/filter/lwppagelayout.cxx

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