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 #include "lwppagelayout.hxx"
  58 #include "lwplaypiece.hxx"
  59 #include "lwpfootnote.hxx"
  60 #include "lwpdoc.hxx"
  61 #include "lwpholder.hxx"
  62 #include "lwppagehint.hxx"
  63 #include "lwpdivinfo.hxx"
  64 #include "lwpstory.hxx"
  65 #include "xfilter/xfstylemanager.hxx"
  66 #include "xfilter/xfmasterpage.hxx"
  67 #include "xfilter/xfcontentcontainer.hxx"
  68 #include "xfilter/xfheader.hxx"
  69 #include "xfilter/xfheaderstyle.hxx"
  70 #include "xfilter/xffooterstyle.hxx"
  71 #include "xfilter/xffooter.hxx"
  72 #include <sfx2/printer.hxx>
  73 #include "lwpchangemgr.hxx"
  74 #include "lwpglobalmgr.hxx"
  75
  76 LwpPageLayout::LwpPageLayout(LwpObjectHeader &objHdr, LwpSvStream* pStrm)
  77     : LwpLayout(objHdr, pStrm)
  78     , m_pPrinterBinName(new LwpAtomHolder)
  79     , m_nPrinterBin(0)
  80     , m_nBdroffset(0)
  81     , m_pPaperName(new LwpAtomHolder)
  82     , m_pXFPageMaster(nullptr)
  83 {
  84 }
  85
  86 LwpPageLayout::~LwpPageLayout()
  87 {
  88     if (m_pPrinterBinName)
  89     {
  90         delete m_pPrinterBinName;
  91     }
  92     if (m_pPaperName)
  93     {
  94         delete m_pPaperName;
  95     }
  96 }
  97 void LwpPageLayout::Read()
  98 {
  99     LwpLayout::Read();
 100
 101     if (LwpFileHeader::m_nFileRevision < 0x000B)
 102     {
 103         // read PreRevBLayout...
 104     }
 105
 106     m_nPrinterBin = m_pObjStrm->QuickReaduInt16();
 107     m_pPrinterBinName->Read(m_pObjStrm);
 108
 109     if (LwpFileHeader::m_nFileRevision >= 0x000B)
 110         m_nBdroffset = m_pObjStrm->QuickReadInt32();
 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     rtl::Reference<LwpObject> pStory = m_Content.obj();
 124     if(pStory.is())
 125     {
 126         pStory->SetFoundry(m_pFoundry);
 127         pStory->DoParse(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 * @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 = 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 (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 ? m_pFoundry->GetDocument() : nullptr;
 268     if (pDocument)
 269     {
 270         LwpObjectID* pFontnodeId = pDocument->GetValidFootnoteOpts();
 271
 272         LwpFootnoteOptions* pFootnoteOpts = pFontnodeId ? dynamic_cast<LwpFootnoteOptions*>(pFontnodeId->obj().get()) : nullptr;
 273         if(pFootnoteOpts)
 274         {
 275             LwpFootnoteSeparatorOptions& rFootnoteSep = pFootnoteOpts->GetFootnoteSeparator();
 276             //set length
 277             sal_uInt32 nLengthPercent = 100;
 278             double fWidth = 0;
 279             if(rFootnoteSep.HasSeparator())
 280             {
 281                 fWidth = rFootnoteSep.GetTopBorderWidth();
 282             }
 283             if(rFootnoteSep.HasCustomLength())
 284             {
 285                 nLengthPercent =  static_cast<sal_uInt32>(100*LwpTools::ConvertFromUnitsToMetric(rFootnoteSep.GetLength())/GetMarginWidth());
 286                 if(nLengthPercent > 100)
 287                     nLengthPercent = 100;
 288             }
 289             double fAbove = LwpTools::ConvertFromUnitsToMetric(rFootnoteSep.GetAbove());
 290             double fBelow = LwpTools::ConvertFromUnitsToMetric(rFootnoteSep.GetBelow());
 291             LwpColor aColor = rFootnoteSep.GetTopBorderColor();
 292             enumXFAlignType eAlignType = enumXFAlignStart;
 293             if(rFootnoteSep.GetIndent() > 0)
 294             {
 295                 //SODC don't support indent
 296                 sal_uInt32 nIndentPercent =  static_cast<sal_uInt32>(100*LwpTools::ConvertFromUnitsToMetric(rFootnoteSep.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 = static_cast<XFPageMaster*>(pXFStyleManager->AddStyle(pm1).m_pStyle);
 339     OUString pmname = pm1->GetStyleName();
 340
 341     //Add master page
 342     XFMasterPage* p1 = new XFMasterPage();
 343     p1->SetStyleName(GetName().str());
 344     p1->SetPageMaster(pmname);
 345     p1 = static_cast<XFMasterPage*>(pXFStyleManager->AddStyle(p1).m_pStyle);
 346     m_StyleName = p1->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(p1);
 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(p1);
 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 = static_cast<XFPageMaster*>(pXFStyleManager->AddStyle(pm1).m_pStyle);
 398     OUString pmname = pm1->GetStyleName();
 399
 400     //Add master page
 401     XFMasterPage* p1 = new XFMasterPage();
 402     p1->SetStyleName("Endnote");
 403     p1->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(p1);
 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(p1);
 421     }
 422
 423     return pXFStyleManager->AddStyle(p1).m_pStyle->GetStyleName();
 424 }
 425 /**
 426 * @descr:   Whether current page layout has columns
 427 *
 428 */
 429 bool LwpPageLayout::HasColumns()
 430 {
 431     return GetNumCols() > 1;
 432 }
 433
 434 /**
 435 * @descr:   Whether has filler page text in current page layout
 436 *
 437 */
 438 bool LwpPageLayout::HasFillerPageText(LwpFoundry* pFoundry)
 439 {
 440     if(!pFoundry) return false;
 441
 442     bool bFillerPage = 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 = true;
 457             }
 458             else if((eWhenType==LwpLayout::StartOnEvenPage)&&(LwpTools::IsEvenNumber(nPageNumber)))
 459             {
 460                 bFillerPage = true;
 461             }
 462             else
 463             {
 464                 bFillerPage = 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 fillerpage story from division info
 481         LwpDocument* pDoc = m_pFoundry->GetDocument();
 482         LwpDivInfo* pDivInfo = dynamic_cast<LwpDivInfo*>(pDoc->GetDivInfoID().obj().get());
 483         LwpStory* pStory = dynamic_cast<LwpStory*>(pDivInfo->GetFillerPageTextID().obj().get());
 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(nullptr);
 501     }
 502 }
 503
 504 LwpHeaderLayout* LwpPageLayout::GetHeaderLayout()
 505 {
 506     rtl::Reference<LwpVirtualLayout> xLay(dynamic_cast<LwpVirtualLayout*>(GetChildHead().obj().get()));
 507     while (xLay.is())
 508     {
 509         if (xLay->GetLayoutType() == LWP_HEADER_LAYOUT)
 510             return dynamic_cast<LwpHeaderLayout*>(xLay.get());
 511         xLay.set(dynamic_cast<LwpVirtualLayout*>(xLay->GetNext().obj().get()));
 512     }
 513     return nullptr;
 514 }
 515
 516 LwpFooterLayout* LwpPageLayout::GetFooterLayout()
 517 {
 518     rtl::Reference<LwpVirtualLayout> xLay(dynamic_cast<LwpVirtualLayout*>(GetChildHead().obj().get()));
 519     while (xLay.is())
 520     {
 521         if (xLay->GetLayoutType() == LWP_FOOTER_LAYOUT)
 522             return dynamic_cast<LwpFooterLayout*>(xLay.get());
 523         xLay.set(dynamic_cast<LwpVirtualLayout*>(xLay->GetNext().obj().get()));
 524     }
 525     return nullptr;
 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         rtl::Reference<LwpVirtualLayout> xLay(dynamic_cast<LwpVirtualLayout*>(GetChildHead().obj().get()));
 537         while (xLay.is())
 538         {
 539             if (xLay->GetLayoutType() == LWP_PAGE_LAYOUT)
 540             {
 541                 LwpPageLayout* pPageLayout = static_cast<LwpPageLayout*>(xLay.get());
 542                 LwpUseWhen* pUseWhen = pPageLayout->GetUseWhen();
 543                 if(pUseWhen && pUseWhen->IsUseOnAllOddPages())
 544                 {
 545                     return pPageLayout;
 546                 }
 547             }
 548             xLay.set(dynamic_cast<LwpVirtualLayout*>(xLay->GetNext().obj().get()));
 549         }
 550     }
 551     return nullptr;
 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 = GetFoundry();
 579     if (!pFoundry)
 580         return nPageNumber;
 581     LwpDocument* pDoc = pFoundry->GetDocument();
 582     LwpDLVListHeadTailHolder* pHeadTail = dynamic_cast<LwpDLVListHeadTailHolder*>(pDoc->GetPageHintsID().obj().get());
 583     if(!pHeadTail) return nPageNumber;
 584
 585     //get first pagehint
 586     LwpPageHint* pPageHint = dynamic_cast<LwpPageHint*>(pHeadTail->GetHead().obj().get());
 587     while(pPageHint)
 588     {
 589         if(GetObjectID() == pPageHint->GetPageLayoutID())
 590         {
 591             sal_uInt16 nNumber = pPageHint->GetPageNumber();
 592             if(nLayoutNumber==FIRST_LAYOUTPAGENO && pPageHint->GetLayoutPageNumber()==1)
 593             {
 594                 //get the first page number
 595                 nPageNumber = nNumber;
 596                 break;
 597             }
 598             else if( nLayoutNumber ==LAST_LAYOUTPAGENO && nNumber >nPageNumber )
 599             {
 600                 //get the last page number
 601                 nPageNumber = nNumber;
 602                 if(pPageHint->GetNext().IsNull())
 603                 {
 604                     //if is last page number of entire document, reture directly
 605                     return nPageNumber + pDoc->GetNumberOfPagesBefore();
 606                 }
 607             }
 608             else if(nLayoutNumber > 0 && pPageHint->GetLayoutPageNumber() == nLayoutNumber)
 609             {
 610                 //get specified page number
 611                 nPageNumber = nNumber;
 612                 break;
 613             }
 614
 615         }
 616         pPageHint = dynamic_cast<LwpPageHint*>(pPageHint->GetNext().obj().get());
 617     }
 618     if(nPageNumber>=0)
 619     {
 620         return nPageNumber + 1 + pDoc->GetNumberOfPagesBefore();
 621     }
 622     return -1;
 623 }
 624
 625 /**
 626 * @descr:   Get page width and height
 627 *
 628 */
 629 void LwpPageLayout::GetWidthAndHeight(double& fWidth, double& fHeight)
 630 {
 631     //use customized size
 632     LwpLayoutGeometry* pLayoutGeo = GetGeometry();
 633     if(pLayoutGeo)
 634     {
 635         fWidth = GetGeometryWidth();
 636         fHeight = GetGeometryHeight();
 637     }
 638
 639     if(GetUsePrinterSettings())
 640     {
 641         //replaced by printer paper size
 642         ScopedVclPtrInstance< Printer > pPrinter;
 643         bool bScreen = pPrinter->IsDisplayPrinter();
 644         if (!bScreen)//Printer available
 645         {
 646             Size aPaperSize = pPrinter->GetPaperSize();
 647             aPaperSize = pPrinter->PixelToLogic( aPaperSize, MapMode( MAP_10TH_MM ) );
 648             fWidth = static_cast<double>(aPaperSize.Width())/100;   //cm unit
 649             fHeight = static_cast<double>(aPaperSize.Height())/100;
 650         }
 651     }
 652
 653     //Follow the former design of Lotus WordPro filter, some default will be given:
 654     //Page Width: 8.5 Inch -> 21.59 cm
 655     //Page Height: 11 Inch -> 27.94 cm
 656     if (fWidth < 4.39)
 657         fWidth = 21.59;
 658     if (fHeight < 4.49)
 659         fHeight = 27.94;
 660     //End of modification, by ZF
 661 }
 662
 663 /**
 664 * @descr:   Get page width
 665 *
 666 */
 667 double LwpPageLayout::GetWidth()
 668 {
 669     double fWidth =0, fHeight = 0;
 670     GetWidthAndHeight(fWidth, fHeight);
 671     return fWidth;
 672 }
 673
 674 /**
 675 * @descr:   Get page height
 676 *
 677 */
 678 double LwpPageLayout::GetHeight()
 679 {
 680     double fWidth =0, fHeight = 0;
 681     GetWidthAndHeight(fWidth, fHeight);
 682     return fHeight;
 683 }
 684 /**
 685 * @descr:  Compare the position of layout. If the position of this layout is earlier than other layout,return true, or return false
 686 *
 687 */
 688 bool LwpPageLayout::operator<(LwpPageLayout& Other)
 689 {
 690     LwpPara* pThisPara = GetPagePosition();
 691     LwpPara* pOtherPara = Other.GetPagePosition();
 692     if(pThisPara && pOtherPara)
 693     {
 694         if(pThisPara == pOtherPara)
 695         {
 696             //If the two layouts in the same para, compare which layout is earlied according to frib order
 697             return pThisPara->ComparePagePosition(this, &Other);
 698         }
 699         else
 700         {
 701             return *pThisPara < *pOtherPara;
 702         }
 703     }
 704
 705     if(!pThisPara)
 706         return true;
 707
 708     return false;
 709 }
 710
 711 /**
 712 * @descr:  Get the position of pagelayout
 713 *
 714 */
 715 LwpPara* LwpPageLayout::GetPagePosition()
 716 {
 717     LwpPara* pPara = dynamic_cast<LwpPara*>(GetPosition().obj().get());
 718     if(pPara)
 719         return pPara;
 720     //Get the position from its related section
 721     LwpFoundry* pFoundry = GetFoundry();
 722     if(pFoundry)
 723     {
 724         LwpSection* pSection = nullptr;
 725         while( (pSection = pFoundry->EnumSections(pSection)) )
 726         {
 727             if(pSection->GetPageLayout() == this)
 728                 return dynamic_cast<LwpPara*>(pSection->GetPosition().obj().get());
 729         }
 730     }
 731
 732     return nullptr;
 733 }
 734 LwpHeaderLayout::LwpHeaderLayout( LwpObjectHeader &objHdr, LwpSvStream* pStrm )
 735     : LwpPlacableLayout(objHdr, pStrm)
 736     , m_nBorderOffset(0)
 737 {
 738 }
 739
 740 LwpHeaderLayout::~LwpHeaderLayout()
 741 {
 742 }
 743
 744 void LwpHeaderLayout::Read()
 745 {
 746     LwpPlacableLayout::Read();
 747
 748     if(LwpFileHeader::m_nFileRevision >= 0x000E)
 749         m_nBorderOffset = m_pObjStrm->QuickReadInt32();
 750     else
 751         m_nBorderOffset = 0;
 752     m_pObjStrm->SkipExtra();
 753 }
 754
 755 void LwpHeaderLayout::RegisterStyle(XFPageMaster* pm1)
 756 {
 757     XFHeaderStyle* pHeaderStyle = new XFHeaderStyle();
 758
 759     //Modify page top margin
 760     //page top marging: from top of header to the top edge
 761     double top = GetMarginsValue(MARGIN_TOP);
 762     pm1->SetMargins(-1, -1, top, -1);
 763
 764     ParseMargins(pHeaderStyle);
 765     ParseBorder(pHeaderStyle);
 766     ParseShadow(pHeaderStyle);
 767 //  ParseBackColor(pHeaderStyle);
 768     ParseBackGround(pHeaderStyle);
 769
 770     ParseWaterMark(pHeaderStyle);
 771     //End by
 772
 773     pm1->SetHeaderStyle(pHeaderStyle);
 774 }
 775
 776 void LwpHeaderLayout::ParseMargins(XFHeaderStyle* ph1)
 777 {
 778     //Set height: from top of header to top of body, including the spacing between header and body
 779     double height = GetGeometryHeight()- GetMarginsValue(MARGIN_TOP);
 780     if( IsAutoGrowDown() )
 781     {
 782         ph1->SetMinHeight(height);
 783     }
 784     else
 785     {
 786         ph1->SetHeight(height);
 787     }
 788
 789     //Set left,right,bottom margins
 790     LwpMiddleLayout* parent = dynamic_cast<LwpMiddleLayout*> (GetParent().obj().get());
 791     //left margin in SODC: the space from the left edge of body to the left edge of header
 792     double left = GetMarginsValue(MARGIN_LEFT) - (parent ? parent->GetMarginsValue(MARGIN_LEFT) : 0);
 793     if(left<=0) //The left margin in SODC can not be minus value
 794     {
 795         left = -1;
 796     }
 797     //left margin in SODC: the space from the right edge of header to the right edge of body
 798     double right = GetMarginsValue(MARGIN_RIGHT) - (parent ? parent->GetMarginsValue(MARGIN_RIGHT) : 0);
 799     if(right<=0)//The right margin in SODC can not be minus value
 800     {
 801         right = -1;
 802     }
 803     ph1->SetMargins( left, right, GetMarginsValue(MARGIN_BOTTOM));
 804
 805     //Word Pro has no dynamic spacing, should be set to false
 806     ph1->SetDynamicSpace(false);
 807 }
 808
 809 void LwpHeaderLayout::ParseBorder(XFHeaderStyle* pHeaderStyle)
 810 {
 811     XFBorders* pBordres = GetXFBorders();
 812     if(pBordres)
 813     {
 814         pHeaderStyle->SetBorders(pBordres);
 815     }
 816 }
 817
 818 void LwpHeaderLayout::ParseShadow(XFHeaderStyle* pHeaderStyle)
 819 {
 820     XFShadow* pXFShadow = GetXFShadow();
 821     if(pXFShadow)
 822     {
 823         pHeaderStyle->SetShadow(pXFShadow);
 824     }
 825 }
 826
 827 /**
 828 * @descr:   set header back pattern
 829 *
 830 */
 831 void LwpHeaderLayout::ParsePatternFill(XFHeaderStyle* pHeaderStyle)
 832 {
 833     XFBGImage* pXFBGImage = GetFillPattern();
 834     if (pXFBGImage)
 835     {
 836         pHeaderStyle->SetBackImage(pXFBGImage);
 837     }
 838 }
 839 /**
 840 * @descr:   set header background
 841 *
 842 */
 843 void LwpHeaderLayout::ParseBackGround(XFHeaderStyle* pHeaderStyle)
 844 {
 845     if (IsPatternFill())
 846     {
 847         ParsePatternFill(pHeaderStyle);
 848     }
 849     else
 850     {
 851         ParseBackColor(pHeaderStyle);
 852     }
 853 }
 854
 855 void LwpHeaderLayout::ParseBackColor(XFHeaderStyle* pHeaderStyle)
 856 {
 857     LwpColor* pColor = GetBackColor();
 858     if(pColor)
 859     {
 860         pHeaderStyle->SetBackColor(XFColor(pColor->To24Color()));
 861     }
 862 }
 863
 864 void LwpHeaderLayout::ParseWaterMark(XFHeaderStyle * pHeaderStyle)
 865 {
 866     XFBGImage* pXFBGImage = GetXFBGImage();
 867     if(pXFBGImage)
 868     {
 869         pHeaderStyle->SetBackImage(pXFBGImage);
 870     }
 871 }
 872 //End by
 873
 874 void LwpHeaderLayout::RegisterStyle(XFMasterPage* mp1)
 875 {
 876     XFHeader* pHeader = new XFHeader();
 877     rtl::Reference<LwpObject> pStory = m_Content.obj();
 878     if(pStory.is())
 879     {
 880         LwpGlobalMgr* pGlobal = LwpGlobalMgr::GetInstance();
 881         LwpChangeMgr* pChangeMgr = pGlobal->GetLwpChangeMgr();
 882         pChangeMgr->SetHeadFootFribMap(true);
 883
 884         //Call the RegisterStyle first to register the styles in header paras, and then XFConvert()
 885         pStory->SetFoundry(m_pFoundry);
 886         pStory->DoRegisterStyle();
 887         //, 06/27/2005
 888         //register child layout style for framelayout,
 889         RegisterChildStyle();
 890         //End
 891         pChangeMgr->SetHeadFootChange(pHeader);
 892         pStory->DoXFConvert(pHeader);
 893
 894         pChangeMgr->SetHeadFootFribMap(false);
 895     }
 896     mp1->SetHeader(pHeader);
 897 }
 898
 899 LwpFooterLayout::LwpFooterLayout( LwpObjectHeader &objHdr, LwpSvStream* pStrm )
 900     : LwpPlacableLayout( objHdr, pStrm )
 901     , m_nBorderOffset(0)
 902 {
 903 }
 904
 905 LwpFooterLayout::~LwpFooterLayout()
 906 {
 907 }
 908
 909 void LwpFooterLayout::Read()
 910 {
 911     LwpPlacableLayout::Read();
 912
 913     if(LwpFileHeader::m_nFileRevision >= 0x000E)
 914         m_nBorderOffset = m_pObjStrm->QuickReadInt32();
 915     else
 916         m_nBorderOffset = 0;
 917     m_pObjStrm->SkipExtra();
 918 }
 919
 920 void LwpFooterLayout::RegisterStyle(XFPageMaster* pm1)
 921 {
 922     XFFooterStyle* pFooterStyle = new XFFooterStyle();
 923
 924     //Modify page bottom margin
 925     //page bottom margin: from bottom of footer to the bottom edge
 926     double bottom = GetMarginsValue(MARGIN_BOTTOM);
 927     pm1->SetMargins(-1, -1, -1, bottom);
 928
 929     ParseMargins(pFooterStyle);
 930     ParseBorder(pFooterStyle);
 931     ParseShadow(pFooterStyle);
 932     ParseBackGround(pFooterStyle);
 933 //  ParseBackColor(pFooterStyle);
 934
 935     ParseWaterMark(pFooterStyle);
 936     //End by
 937
 938     pm1->SetFooterStyle(pFooterStyle);
 939 }
 940
 941 void LwpFooterLayout::ParseMargins(XFFooterStyle* pFooterStyle)
 942 {
 943
 944     //Set height: from top of header to top of body, including the spacing between header and body
 945     double height = GetGeometryHeight() - GetMarginsValue(MARGIN_BOTTOM);
 946     if( IsAutoGrowUp() )
 947     {
 948         pFooterStyle->SetMinHeight(height);
 949     }
 950     else
 951     {
 952         pFooterStyle->SetHeight(height);
 953     }
 954
 955     //Set left,right,top margins
 956     LwpMiddleLayout* parent = dynamic_cast<LwpMiddleLayout*> (GetParent().obj().get());
 957     double left = GetMarginsValue(MARGIN_LEFT) - (parent ? parent->GetMarginsValue(MARGIN_LEFT) : 0);
 958     if(left<=0) //The left margin in SODC can not be minus value
 959     {
 960         left = -1;
 961     }
 962     double right = GetMarginsValue(MARGIN_RIGHT) - (parent ? parent->GetMarginsValue(MARGIN_RIGHT) : 0);
 963     if(right<=0)//The left margin in SODC can not be minus value
 964     {
 965         right = -1;
 966     }
 967     pFooterStyle->SetMargins( left, right, GetMarginsValue(MARGIN_TOP));
 968
 969     //Word Pro has no dynamic spacing, should be set to false
 970     pFooterStyle->SetDynamicSpace(false);
 971 }
 972
 973 void LwpFooterLayout::ParseBorder(XFFooterStyle* pFooterStyle)
 974 {
 975     XFBorders* pBordres = GetXFBorders();
 976     if(pBordres)
 977     {
 978         pFooterStyle->SetBorders(pBordres);
 979     }
 980 }
 981
 982 void LwpFooterLayout::ParseShadow(XFFooterStyle* pFooterStyle)
 983 {
 984     XFShadow* pXFShadow = GetXFShadow();
 985     if(pXFShadow)
 986     {
 987         pFooterStyle->SetShadow(pXFShadow);
 988     }
 989 }
 990 /**
 991 * @descr:   set footer back pattern
 992 *
 993 */
 994 void LwpFooterLayout::ParsePatternFill(XFFooterStyle* pFooterStyle)
 995 {
 996     XFBGImage* pXFBGImage = GetFillPattern();
 997     if (pXFBGImage)
 998     {
 999         pFooterStyle->SetBackImage(pXFBGImage);
1000     }
1001 }
1002 /**
1003 * @descr:   set footer background
1004 *
1005 */
1006 void LwpFooterLayout::ParseBackGround(XFFooterStyle* pFooterStyle)
1007 {
1008     if (IsPatternFill())
1009     {
1010         ParsePatternFill(pFooterStyle);
1011     }
1012     else
1013     {
1014         ParseBackColor(pFooterStyle);
1015     }
1016 }
1017
1018 void LwpFooterLayout::ParseBackColor(XFFooterStyle* pFooterStyle)
1019 {
1020     LwpColor* pColor = GetBackColor();
1021     if(pColor)
1022     {
1023         pFooterStyle->SetBackColor(XFColor(pColor->To24Color()));
1024     }
1025 }
1026
1027 void LwpFooterLayout::RegisterStyle(XFMasterPage* mp1)
1028 {
1029     XFFooter* pFooter = new XFFooter();
1030     rtl::Reference<LwpObject> pStory = m_Content.obj(VO_STORY);
1031     //Call the RegisterStyle first to register the styles in footer paras, and then XFConvert()
1032     if(pStory.is())
1033     {
1034         LwpGlobalMgr* pGlobal = LwpGlobalMgr::GetInstance();
1035         LwpChangeMgr* pChangeMgr = pGlobal->GetLwpChangeMgr();
1036         pChangeMgr->SetHeadFootFribMap(true);
1037
1038         pStory->SetFoundry(m_pFoundry);
1039         pStory->DoRegisterStyle();
1040         //register child layout style for framelayout,
1041         RegisterChildStyle();
1042
1043         pChangeMgr->SetHeadFootChange(pFooter);
1044
1045         pStory->DoXFConvert(pFooter);
1046
1047         pChangeMgr->SetHeadFootFribMap(false);
1048     }
1049     mp1->SetFooter(pFooter);
1050 }
1051
1052 void LwpFooterLayout::ParseWaterMark(XFFooterStyle * pFooterStyle)
1053 {
1054     XFBGImage* pXFBGImage = GetXFBGImage();
1055     if(pXFBGImage)
1056     {
1057         pFooterStyle->SetBackImage(pXFBGImage);
1058     }
1059 }
1060
1061 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */