lotuswordpro/source/filter/lwplayout.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  * @file
  58  *  For LWP filter architecture prototype
  59  ************************************************************************/
  60
  61 #include "lwplayout.hxx"
  62 #include "lwpusewhen.hxx"
  63 #include "lwptools.hxx"
  64 #include "lwplaypiece.hxx"
  65 #include "xfilter/xfcolumns.hxx"
  66 #include "lwpstory.hxx"
  67 #include "lwpparastyle.hxx"
  68 #include "lwpholder.hxx"
  69 #include "lwpdoc.hxx"
  70 #include "lwppagehint.hxx"
  71 #include "lwpdivinfo.hxx"
  72 #include "lwpgrfobj.hxx"
  73 #include <osl/thread.h>
  74
  75 LwpVirtualLayout::LwpVirtualLayout(LwpObjectHeader &objHdr, LwpSvStream* pStrm)
  76     : LwpDLNFPVList(objHdr, pStrm)
  77     , m_bGettingHonorProtection(false)
  78     , m_bGettingMarginsSameAsParent(false)
  79     , m_bGettingHasProtection(false)
  80     , m_bGettingIsProtected(false)
  81     , m_bGettingIsAutoGrowDown(false)
  82     , m_bGettingMarginsValue(false)
  83     , m_bGettingExtMarginsValue(false)
  84     , m_nAttributes(0)
  85     , m_nAttributes2(0)
  86     , m_nAttributes3(0)
  87     , m_nOverrideFlag(0)
  88     , m_nDirection(0)
  89     , m_nEditorID(0)
  90 {
  91 }
  92
  93 void LwpVirtualLayout::Read()
  94 {
  95     LwpDLNFPVList::Read();
  96
  97     LwpObjectStream* pStrm = m_pObjStrm.get();
  98     m_nAttributes = pStrm->QuickReaduInt32();
  99     m_nAttributes2 = pStrm->QuickReaduInt32();
 100     m_nAttributes3 = pStrm->QuickReaduInt32();
 101     m_nOverrideFlag = pStrm->QuickReaduInt32();
 102     m_nDirection = pStrm->QuickReaduInt16();
 103
 104     //Note that two bytes is read into m_nEditorID instead of one byte.
 105     m_nEditorID = pStrm->QuickReaduInt16();
 106
 107     m_NextEnumerated.ReadIndexed(pStrm);
 108     m_PreviousEnumerated.ReadIndexed(pStrm);
 109
 110     pStrm->SkipExtra();
 111 }
 112
 113 bool LwpVirtualLayout::MarginsSameAsParent()
 114 {
 115     return (m_nAttributes2 & STYLE2_MARGINSSAMEASPARENT) != 0;
 116 }
 117
 118 /**
 119 * @descr:   Get column width
 120 *
 121 */
 122 double LwpVirtualLayout::GetColWidth(sal_uInt16 /*nIndex*/)
 123 {
 124     //return GetContentWidth(); //not support now
 125     //return LwpTools::ConvertToMetric(5); //test
 126     return 0; //test
 127 }
 128
 129 /**
 130 * @descr:   Get the gap between columns
 131 *
 132 */
 133 double LwpVirtualLayout::GetColGap(sal_uInt16 /*nIndex*/)
 134 {
 135     //return DEFAULTGAPSIZE;
 136     //return LwpTools::ConvertToMetric(0.17);//DEFAULTGAPSIZE=0.17
 137     return LwpTools::ConvertToMetric(0.17);
 138 }
 139
 140 /**
 141 * @descr:   Whether it is honoring protection
 142 *
 143 */
 144 bool LwpVirtualLayout::HonorProtection()
 145 {
 146     if(!(m_nAttributes2 & STYLE2_HONORPROTECTION))
 147         return false;
 148
 149     rtl::Reference<LwpVirtualLayout> xParent(dynamic_cast<LwpVirtualLayout*>(GetParent().obj().get()));
 150     if (xParent.is() && !xParent->IsHeader())
 151     {
 152         return xParent->GetHonorProtection();
 153     }
 154
 155     if(m_pFoundry)//is null now
 156     {
 157         LwpDocument* pDoc = m_pFoundry->GetDocument();
 158         if(pDoc && pDoc->GetRootDocument())
 159             return pDoc->GetRootDocument()->GetHonorProtection();
 160     }
 161
 162     return true;
 163 }
 164
 165 /**
 166 * @descr:   Whether it is protected
 167 *
 168 */
 169 bool LwpVirtualLayout::IsProtected()
 170 {
 171     bool bProtected = (m_nAttributes & STYLE_PROTECTED)!=0;
 172
 173     rtl::Reference<LwpVirtualLayout> xParent(dynamic_cast<LwpVirtualLayout*>(GetParent().obj().get()));
 174     if (xParent.is() && !xParent->IsHeader())
 175     {
 176         if (xParent->GetHonorProtection() && (xParent->GetHasProtection()||bProtected))
 177         {
 178             return true;
 179         }
 180     }
 181     else if(m_pFoundry)//is null now
 182     {
 183         LwpDocument* pDoc = m_pFoundry->GetDocument();
 184         if(pDoc)
 185         {
 186             if (pDoc->GetHonorProtection() && bProtected)
 187             {
 188                 return true;
 189             }
 190         }
 191     }
 192
 193     return false;
 194 }
 195
 196 /**
 197 * @descr:   Whether it has protection
 198 *
 199 */
 200 bool LwpVirtualLayout::HasProtection()
 201 {
 202     if(m_nAttributes & STYLE_PROTECTED)
 203         return true;
 204
 205     rtl::Reference<LwpVirtualLayout> xParent(dynamic_cast<LwpVirtualLayout*>(GetParent().obj().get()));
 206     if (xParent.is() && !xParent->IsHeader())
 207     {
 208         return xParent->GetHasProtection();
 209     }
 210
 211     return false;
 212 }
 213
 214 /**
 215 * @descr:   Whether it is a mirror layout
 216 *
 217 */
 218 bool LwpVirtualLayout::IsComplex()
 219 {
 220     return (m_nAttributes & STYLE_COMPLEX) != 0;
 221 }
 222
 223 /**
 224 * @descr:   Get usewhen pointer
 225 *
 226 */
 227 LwpUseWhen* LwpVirtualLayout::GetUseWhen()
 228 {
 229     /*
 230         If we have a parent, and I'm not a page layout,
 231         use my parents information.
 232     */
 233     if(GetLayoutType()!=LWP_PAGE_LAYOUT)
 234     {
 235         //get parent
 236         rtl::Reference<LwpVirtualLayout> xParent(dynamic_cast<LwpVirtualLayout*>(GetParent().obj().get()));
 237         if (xParent.is() && !xParent->IsHeader() && (xParent->GetLayoutType() != LWP_PAGE_LAYOUT))
 238             return xParent->GetUseWhen();
 239
 240     }
 241
 242     return VirtualGetUseWhen();
 243 }
 244 /**
 245  * @descr:  Whether this layout is page layout or not
 246 */
 247 bool LwpVirtualLayout::IsPage()
 248 {
 249     return (GetLayoutType() == LWP_PAGE_LAYOUT);
 250 }
 251 /**
 252  * @descr:  Whether this layout is header layout or not
 253 */
 254 bool LwpVirtualLayout::IsHeader()
 255 {
 256     return (GetLayoutType() == LWP_HEADER_LAYOUT);
 257 }
 258 /**
 259  * @descr:  Whether this layout is footer layout or not
 260 */
 261 bool LwpVirtualLayout::IsFooter()
 262 {
 263     return (GetLayoutType() == LWP_FOOTER_LAYOUT);
 264 }
 265 /**
 266  * @descr:  Whether this layout is frame layout or not
 267 */
 268 bool LwpVirtualLayout::IsFrame()
 269 {
 270     return (GetLayoutType() == LWP_FRAME_LAYOUT);
 271 }
 272
 273 /**
 274  * @descr:  Whether this layout is cell layout or not
 275 */
 276 bool LwpVirtualLayout::IsCell()
 277 {
 278     return (GetLayoutType() == LWP_CELL_LAYOUT
 279         || GetLayoutType() == LWP_CONNECTED_CELL_LAYOUT
 280         || GetLayoutType() == LWP_HIDDEN_CELL_LAYOUT);
 281 }
 282 /**
 283  * @descr:  Whether this layout is supertable layout or not
 284 */
 285 bool LwpVirtualLayout::IsSuperTable()
 286 {
 287     return (GetLayoutType() == LWP_SUPERTABLE_LAYOUT);
 288 }
 289 /**
 290  * @descr:  Whether this layout is group layout or not
 291 */
 292 bool LwpVirtualLayout::IsGroupHead()
 293 {
 294     return (GetLayoutType() == LWP_GROUP_LAYOUT);
 295 }
 296 /**
 297  * @descr:  get the relative type
 298 */
 299 sal_uInt8 LwpVirtualLayout::GetRelativeType()
 300 {
 301     return LwpLayoutRelativityGuts::LAY_PARENT_RELATIVE;
 302 }
 303 /**
 304  * @descr:  whether it is relative anchored layout
 305 */
 306 bool LwpVirtualLayout::IsRelativeAnchored()
 307 {
 308     sal_uInt8 nType;
 309
 310     nType = GetRelativeType();
 311     return (nType == LwpLayoutRelativityGuts::LAY_PARA_RELATIVE) || (nType == LwpLayoutRelativityGuts::LAY_INLINE)
 312     || (nType == LwpLayoutRelativityGuts::LAY_INLINE_NEWLINE) || (nType == LwpLayoutRelativityGuts::LAY_INLINE_VERTICAL);
 313 }
 314 /**
 315  * @descr:  whether it is MinimumHeight layout
 316 */
 317 bool LwpVirtualLayout::IsMinimumHeight()
 318 {
 319     return ((m_nAttributes3& STYLE3_MINHEIGHTVALID) != 0);
 320 }
 321
 322 /**
 323 * @descr:   Get parent layout
 324 *
 325 */
 326 rtl::Reference<LwpVirtualLayout> LwpVirtualLayout::GetParentLayout()
 327 {
 328     return rtl::Reference<LwpVirtualLayout>(dynamic_cast<LwpVirtualLayout*>(GetParent().obj().get()));
 329 }
 330
 331 /**
 332 * @descr:   Register child layout style
 333 *
 334 */
 335 void LwpVirtualLayout::RegisterChildStyle()
 336 {
 337     //Register all children styles
 338     rtl::Reference<LwpVirtualLayout> xLayout(dynamic_cast<LwpVirtualLayout*>(GetChildHead().obj().get()));
 339     while (xLayout.is())
 340     {
 341         xLayout->SetFoundry(m_pFoundry);
 342         xLayout->RegisterStyle();
 343         xLayout.set(dynamic_cast<LwpVirtualLayout*>(xLayout->GetNext().obj().get()));
 344     }
 345 }
 346
 347 bool LwpVirtualLayout::NoContentReference()
 348 {
 349     return (m_nAttributes2 & STYLE2_NOCONTENTREFERENCE) != 0;
 350 }
 351
 352 bool LwpVirtualLayout::IsStyleLayout()
 353 {
 354     if (m_nAttributes3 & STYLE3_STYLELAYOUT)
 355         return true;
 356
 357     rtl::Reference<LwpVirtualLayout> xParent(dynamic_cast<LwpVirtualLayout*>(GetParent().obj().get()));
 358     if (xParent.is())
 359         return xParent->IsStyleLayout();
 360     return false;
 361 }
 362
 363 /**
 364 * @descr:   Find child layout by layout type
 365 *
 366 */
 367 LwpVirtualLayout* LwpVirtualLayout::FindChildByType(LWP_LAYOUT_TYPE eType)
 368 {
 369     LwpObjectID& rID = GetChildHead();
 370
 371     while(!rID.IsNull())
 372     {
 373         LwpVirtualLayout * pLayout = dynamic_cast<LwpVirtualLayout *>(rID.obj().get());
 374         if(!pLayout)
 375         {
 376             break;
 377         }
 378
 379         if (pLayout && pLayout->GetLayoutType() == eType)
 380         {
 381             return pLayout;
 382         }
 383         rID = pLayout->GetNext();
 384     }
 385
 386     return nullptr;
 387 }
 388
 389 /**
 390 * @descr:   Whether the size of layout is fit the graphic
 391 *
 392 */
 393 bool LwpVirtualLayout::IsFitGraphic()
 394 {
 395     return IsAutoGrowRight() && !IsAutoGrowLeft() && GetIsAutoGrowDown();
 396 }
 397
 398 /**
 399 * @descr:   Whether the width of layout is auto grow
 400 *
 401 */
 402 bool LwpVirtualLayout::IsAutoGrowWidth()
 403 {
 404     return IsAutoGrowLeft() || IsAutoGrowRight();
 405 }
 406
 407 /**
 408 * @descr:   Determine whether the layout width is to margin
 409 *
 410 */
 411 bool LwpVirtualLayout::IsInlineToMargin()
 412 {
 413     return (m_nAttributes3 & STYLE3_INLINETOMARGIN) != 0;
 414 }
 415
 416 void LwpAssociatedLayouts::Read(LwpObjectStream* pStrm)
 417 {
 418     m_OnlyLayout.ReadIndexed(pStrm);
 419     m_Layouts.Read(pStrm);
 420     pStrm->SkipExtra();
 421 }
 422
 423 /**
 424 * @descr:   Looking for the layout which follows the pStartLayout
 425 * @param:   pStartLayout - the layout which is used for looking for its following layout
 426 */
 427 rtl::Reference<LwpVirtualLayout> LwpAssociatedLayouts::GetLayout(LwpVirtualLayout *pStartLayout)
 428 {
 429     if (!pStartLayout && !m_OnlyLayout.IsNull())
 430         /* Looking for the first layout and there's only one layout in  the list.*/
 431         return rtl::Reference<LwpVirtualLayout>(dynamic_cast<LwpVirtualLayout*>(m_OnlyLayout.obj().get()));
 432
 433     rtl::Reference<LwpObjectHolder> xObjHolder(dynamic_cast<LwpObjectHolder*>(m_Layouts.GetHead().obj().get()));
 434     if (xObjHolder.is())
 435     {
 436         rtl::Reference<LwpVirtualLayout> xLayout(dynamic_cast<LwpVirtualLayout*>(xObjHolder->GetObject().obj().get()));
 437         if (!pStartLayout)
 438             return xLayout;
 439
 440         while (xObjHolder.is() && pStartLayout != xLayout.get())
 441         {
 442             xObjHolder.set(dynamic_cast<LwpObjectHolder*>(xObjHolder->GetNext().obj().get()));
 443             if (xObjHolder.is())
 444             {
 445                 xLayout.set(dynamic_cast<LwpVirtualLayout*>(xObjHolder->GetObject().obj().get()));
 446             }
 447         }
 448
 449         if (xObjHolder.is())
 450         {
 451             xObjHolder.set(dynamic_cast<LwpObjectHolder*>(xObjHolder->GetNext().obj().get()));
 452             if (xObjHolder.is())
 453             {
 454                 xLayout.set(dynamic_cast<LwpVirtualLayout*>(xObjHolder->GetObject().obj().get()));
 455                 return xLayout;
 456             }
 457         }
 458     }
 459
 460     return rtl::Reference<LwpVirtualLayout>();
 461 }
 462
 463 LwpHeadLayout::LwpHeadLayout(LwpObjectHeader &objHdr, LwpSvStream* pStrm)
 464     : LwpVirtualLayout(objHdr, pStrm)
 465 {}
 466
 467 void LwpHeadLayout::Read()
 468 {
 469     LwpVirtualLayout::Read();
 470     //For PermissiveLayout
 471     m_pObjStrm->SkipExtra();
 472     //For me
 473     m_pObjStrm->SkipExtra();
 474 }
 475
 476 void LwpHeadLayout::RegisterStyle()
 477 {
 478     //Register all children styles
 479     rtl::Reference<LwpVirtualLayout> xLayout(dynamic_cast<LwpVirtualLayout*>(GetChildHead().obj().get()));
 480     while (xLayout.is())
 481     {
 482         xLayout->SetFoundry(m_pFoundry);
 483         //if the layout is relative to para, the layout will be registered in para
 484         if (!xLayout->IsRelativeAnchored())
 485         {
 486             if (xLayout.get() == this)
 487             {
 488                 OSL_FAIL("Layout points to itself");
 489                 break;
 490             }
 491             xLayout->DoRegisterStyle();
 492         }
 493         rtl::Reference<LwpVirtualLayout> xNext(dynamic_cast<LwpVirtualLayout*>(xLayout->GetNext().obj().get()));
 494         if (xNext.get() == xLayout.get())
 495         {
 496             OSL_FAIL("Layout points to itself");
 497             break;
 498         }
 499         xLayout = xNext;
 500     }
 501 }
 502
 503 /**
 504  * @descr   find endnote supertable layout from the child layout list. Suppose that there is only one endnote supertablelayout in one division
 505  * @return pointer to endnote supertable layout
 506  */
 507 rtl::Reference<LwpVirtualLayout> LwpHeadLayout::FindEnSuperTableLayout()
 508 {
 509     rtl::Reference<LwpVirtualLayout> xLayout(dynamic_cast<LwpVirtualLayout*>(GetChildHead().obj().get()));
 510     while (xLayout.get())
 511     {
 512         if (xLayout->GetLayoutType() == LWP_ENDNOTE_SUPERTABLE_LAYOUT)
 513         {
 514             return xLayout;
 515         }
 516         xLayout.set(dynamic_cast<LwpVirtualLayout*>(xLayout->GetNext().obj().get()));
 517     }
 518     return rtl::Reference<LwpVirtualLayout>();
 519 }
 520
 521 LwpLayoutStyle::LwpLayoutStyle()
 522     : m_nStyleDefinition(0)
 523     , m_pDescription(new LwpAtomHolder)
 524     , m_nKey(0)
 525 {
 526 }
 527
 528 LwpLayoutStyle::~LwpLayoutStyle()
 529 {
 530 }
 531
 532 void LwpLayoutStyle::Read(LwpObjectStream* pStrm)
 533 {
 534     m_nStyleDefinition = pStrm->QuickReaduInt32();
 535     m_pDescription->Read(pStrm);
 536     if (pStrm->CheckExtra())
 537     {
 538         m_nKey = pStrm->QuickReaduInt16();
 539         pStrm->SkipExtra();
 540     }
 541 }
 542
 543 LwpLayoutMisc::LwpLayoutMisc() :
 544 m_nGridDistance(0), m_nGridType(0),
 545 m_pContentStyle(new LwpAtomHolder)
 546 {
 547 }
 548
 549 LwpLayoutMisc::~LwpLayoutMisc()
 550 {
 551     if (m_pContentStyle)
 552     {
 553         delete m_pContentStyle;
 554     }
 555 }
 556
 557 void LwpLayoutMisc::Read(LwpObjectStream* pStrm)
 558 {
 559     m_nGridType = pStrm->QuickReaduInt16();
 560     m_nGridDistance = pStrm->QuickReadInt32();
 561     m_pContentStyle->Read(pStrm);
 562     pStrm->SkipExtra();
 563 }
 564
 565 LwpMiddleLayout::LwpMiddleLayout( LwpObjectHeader &objHdr, LwpSvStream* pStrm )
 566     : LwpVirtualLayout(objHdr, pStrm)
 567     , m_pStyleStuff(new LwpLayoutStyle)
 568     , m_pMiscStuff(new LwpLayoutMisc)
 569     , m_bGettingGeometry(false)
 570 {
 571 }
 572
 573 LwpMiddleLayout::~LwpMiddleLayout()
 574 {
 575     if (m_pStyleStuff)
 576     {
 577         delete m_pStyleStuff;
 578     }
 579     if (m_pMiscStuff)
 580     {
 581         delete m_pMiscStuff;
 582     }
 583 }
 584 void LwpMiddleLayout::Read()
 585 {
 586     LwpObjectStream* pStrm = m_pObjStrm.get();
 587
 588     LwpVirtualLayout::Read();
 589
 590     //skip CLiteLayout data;
 591     LwpAtomHolder ContentClass;
 592     ContentClass.Read(pStrm);
 593     pStrm->SkipExtra();
 594
 595     // before layout hierarchy rework
 596     if(LwpFileHeader::m_nFileRevision < 0x000B)
 597         return;
 598
 599     m_Content.ReadIndexed(pStrm);
 600
 601     // 01/20/2005
 602     m_BasedOnStyle.ReadIndexed(pStrm);
 603     m_TabPiece.ReadIndexed(pStrm);
 604
 605     sal_uInt8 nWhatsItGot = pStrm->QuickReaduInt8();
 606
 607     if (nWhatsItGot & DISK_GOT_STYLE_STUFF)
 608     {
 609         m_pStyleStuff->Read(pStrm);
 610     }
 611     if (nWhatsItGot & DISK_GOT_MISC_STUFF)
 612     {
 613         m_pMiscStuff->Read(pStrm);
 614     }
 615
 616     m_LayGeometry.ReadIndexed(pStrm);
 617     m_LayScale.ReadIndexed(pStrm);
 618     m_LayMargins.ReadIndexed(pStrm);
 619     m_LayBorderStuff.ReadIndexed(pStrm);
 620     m_LayBackgroundStuff.ReadIndexed(pStrm);
 621
 622     if (pStrm->CheckExtra())
 623     {
 624         m_LayExtBorderStuff.ReadIndexed(pStrm);
 625         pStrm->SkipExtra();
 626     }
 627 }
 628
 629 rtl::Reference<LwpObject> LwpMiddleLayout::GetBasedOnStyle()
 630 {
 631     rtl::Reference<LwpObject> xRet(m_BasedOnStyle.obj());
 632     if (xRet.get() == this)
 633     {
 634         SAL_WARN("lwp", "style based on itself");
 635         return rtl::Reference<LwpObject>();
 636     }
 637     return xRet;
 638 }
 639
 640 /**
 641 * @descr:   Get the geometry of current layout
 642 *
 643 */
 644 LwpLayoutGeometry* LwpMiddleLayout::Geometry()
 645 {
 646     if( !m_LayGeometry.IsNull() )
 647     {
 648         return ( dynamic_cast<LwpLayoutGeometry*> (m_LayGeometry.obj().get()) );
 649     }
 650     else
 651     {
 652         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 653         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
 654         {
 655             return pLay->GetGeometry();
 656         }
 657     }
 658     return nullptr;
 659 }
 660
 661 /**
 662 * @descr:   Get layout height, measured by "cm"
 663 *
 664 */
 665 double LwpMiddleLayout::GetGeometryHeight()
 666 {
 667     LwpLayoutGeometry* pGeo = GetGeometry();
 668     if(pGeo)
 669     {
 670         return ( LwpTools::ConvertFromUnitsToMetric( pGeo->GetHeight() ) );
 671     }
 672     else
 673         return -1;
 674 }
 675
 676 /**
 677 * @descr:   Get layout width, measured by "cm"
 678 *
 679 */
 680 double LwpMiddleLayout::GetGeometryWidth()
 681 {
 682     LwpLayoutGeometry* pGeo = GetGeometry();
 683     if(pGeo)
 684     {
 685         return ( LwpTools::ConvertFromUnitsToMetric( pGeo->GetWidth() ) );
 686     }
 687     else
 688         return -1;
 689 }
 690
 691 /**
 692 * @descr:   Whether the margins is same as parent layout
 693 *
 694 */
 695 bool LwpMiddleLayout::MarginsSameAsParent()
 696 {
 697     if(m_nOverrideFlag & OVER_MARGINS)
 698     {
 699         return LwpVirtualLayout::MarginsSameAsParent();
 700     }
 701     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 702     if (LwpVirtualLayout* pLay = dynamic_cast<LwpVirtualLayout*>(xBase.get()))
 703     {
 704         pLay->GetMarginsSameAsParent();
 705     }
 706     return LwpVirtualLayout::MarginsSameAsParent();
 707 }
 708
 709 /**
 710 * @descr:   Get margin
 711 * @param:   nWhichSide - 0: left, 1: right, 2:top, 3: bottom
 712 */
 713 double LwpMiddleLayout::MarginsValue(sal_uInt8 nWhichSide)
 714 {
 715     double fValue = 0;
 716     if((nWhichSide==MARGIN_LEFT)||(nWhichSide==MARGIN_RIGHT))
 717     {
 718         if ( GetMarginsSameAsParent() )
 719         {
 720             rtl::Reference<LwpVirtualLayout> xParent(dynamic_cast<LwpVirtualLayout*>(GetParent().obj().get()));
 721             if (xParent.is() && !xParent->IsHeader())
 722             {
 723                 fValue = xParent->GetMarginsValue(nWhichSide);
 724                 return fValue;
 725             }
 726         }
 727     }
 728
 729     if(m_nOverrideFlag & OVER_MARGINS)
 730     {
 731         LwpLayoutMargins* pMar1 = dynamic_cast<LwpLayoutMargins*> (m_LayMargins.obj().get());
 732         if(pMar1)
 733         {
 734             fValue = pMar1->GetMargins().GetMarginsValue(nWhichSide);
 735             return fValue;
 736         }
 737     }
 738     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 739     LwpVirtualLayout* pStyle = dynamic_cast<LwpVirtualLayout*>(xBase.get());
 740     if (pStyle)
 741     {
 742         fValue = pStyle->GetMarginsValue(nWhichSide);
 743         return fValue;
 744     }
 745     return LwpVirtualLayout::MarginsValue(nWhichSide);
 746 }
 747 /**
 748  * @descr:  Get extmargin value
 749  * @param:  nWhichSide - 0: left, 1: right, 2:top, 3: bottom
 750  * @param:
 751  * @return:
 752 */
 753 double LwpMiddleLayout::ExtMarginsValue(sal_uInt8 nWhichSide)
 754 {
 755     double fValue = 0;
 756     if(m_nOverrideFlag & OVER_MARGINS)
 757     {
 758         LwpLayoutMargins* pMar1 = dynamic_cast<LwpLayoutMargins*> (m_LayMargins.obj().get());
 759         if(pMar1)
 760         {
 761             fValue = pMar1->GetExtMargins().GetMarginsValue(nWhichSide);
 762             return fValue;
 763         }
 764     }
 765     LwpVirtualLayout* pStyle = dynamic_cast<LwpVirtualLayout*>(GetBasedOnStyle().get());
 766     if(pStyle)
 767     {
 768         fValue = pStyle->GetExtMarginsValue(nWhichSide);
 769         return fValue;
 770     }
 771     return LwpVirtualLayout::ExtMarginsValue(nWhichSide);
 772 }
 773 /**
 774  * @descr:  Get the LwpBorderStuff object according to m_LayBorderStuff id.
 775 */
 776 LwpBorderStuff* LwpMiddleLayout::GetBorderStuff()
 777 {
 778     if(m_nOverrideFlag & OVER_BORDERS)
 779     {
 780         LwpLayoutBorder* pLayoutBorder = dynamic_cast<LwpLayoutBorder*>(m_LayBorderStuff.obj().get());
 781         return pLayoutBorder ? &pLayoutBorder->GetBorderStuff() : nullptr;
 782     }
 783     else
 784     {
 785         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 786         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
 787         {
 788             return pLay->GetBorderStuff();
 789         }
 790     }
 791     return nullptr;
 792 }
 793
 794 /**
 795  * @descr:  Get LwpBackgroundStuff object according to m_LayBackgroundStuff id;
 796 */
 797 LwpBackgroundStuff* LwpMiddleLayout::GetBackgroundStuff()
 798 {
 799     if(m_nOverrideFlag & OVER_BACKGROUND)
 800     {
 801         LwpLayoutBackground* pLayoutBackground = dynamic_cast<LwpLayoutBackground*>(m_LayBackgroundStuff.obj().get());
 802         return pLayoutBackground ? &pLayoutBackground->GetBackgoudStuff() : nullptr;
 803     }
 804     else
 805     {
 806         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 807         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
 808         {
 809             return pLay->GetBackgroundStuff();
 810         }
 811     }
 812     return nullptr;
 813 }
 814 /**
 815  * @descr:  create xfborder.
 816 */
 817 XFBorders* LwpMiddleLayout::GetXFBorders()
 818 {
 819     LwpBorderStuff* pBorderStuff = GetBorderStuff();
 820     if(pBorderStuff&&pBorderStuff->GetSide() != 0)
 821     {
 822         //copy from lwpparastyle.
 823         XFBorders   *pXFBorders = new XFBorders();
 824         // apply 4 borders respectively
 825         LwpBorderStuff::BorderType pType[] = { LwpBorderStuff::LEFT, LwpBorderStuff::RIGHT,
 826             LwpBorderStuff::TOP, LwpBorderStuff::BOTTOM };
 827
 828         for (LwpBorderStuff::BorderType & nC : pType)
 829         {
 830             if (pBorderStuff->HasSide(nC))
 831             {
 832                 LwpParaStyle::ApplySubBorder(pBorderStuff, nC, pXFBorders);
 833             }
 834         }
 835         return pXFBorders;
 836     }
 837     return nullptr;
 838 }
 839
 840 /**
 841  * @descr:  Get text direction settings.
 842 */
 843 enumXFTextDir LwpMiddleLayout::GetTextDirection()
 844 {
 845     enumXFTextDir eTextDir = enumXFTextDirNone;
 846     sal_uInt8 nDirection = GetContentOrientation();
 847     switch(nDirection)
 848     {
 849         case TEXT_ORIENT_LRTB:
 850         {
 851             eTextDir = enumXFTextDirLR_TB;
 852             break;
 853         }
 854         case TEXT_ORIENT_TBRL:
 855         {
 856             eTextDir = enumXFTextDirTB_RL;
 857             break;
 858         }
 859         case TEXT_ORIENT_RLBT: // not supported now
 860         {
 861             eTextDir = enumXFTextDirNone;
 862             break;
 863         }
 864         case TEXT_ORIENT_BTLR: // not supported now
 865         {
 866             eTextDir = enumXFTextDirNone;
 867             break;
 868         }
 869         default:
 870             break;
 871     }
 872     return eTextDir;
 873 }
 874 /**
 875  * @descr: Get back ground color.
 876 */
 877 LwpColor* LwpMiddleLayout::GetBackColor()
 878 {
 879     LwpBackgroundStuff* pBackgroundStuff = GetBackgroundStuff();
 880     if(pBackgroundStuff && !pBackgroundStuff->IsTransparent())
 881     {
 882         LwpColor* pColor = pBackgroundStuff->GetFillColor();
 883         if(pColor->IsValidColor())
 884         {
 885             return pColor;
 886         }
 887     }
 888     return nullptr;
 889 }
 890
 891 /**
 892  * @descr:  Add back color settings into xfpagemaster.
 893 */
 894 LwpTabOverride* LwpMiddleLayout::GetTabOverride()
 895 {
 896     if(m_nAttributes & OVER_TABS)
 897     {
 898         if(!m_TabPiece.IsNull())
 899         {
 900             LwpTabPiece *pPiece = dynamic_cast<LwpTabPiece*>(m_TabPiece.obj().get());
 901             return static_cast<LwpTabOverride*>(pPiece ? pPiece->GetOverride() : nullptr);
 902         }
 903         return nullptr;
 904     }
 905     else
 906     {
 907         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 908         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
 909         {
 910             return pLay->GetTabOverride();
 911         }
 912     }
 913     return nullptr;
 914 }
 915
 916 /**
 917  * @descr:   Layscale for graphic & watermark
 918 */
 919 sal_uInt16 LwpMiddleLayout::GetScaleMode()
 920 {
 921     if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj().is() && GetLayoutScale())
 922         return GetLayoutScale()->GetScaleMode();
 923     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 924     if (xBase.is())
 925         return dynamic_cast<LwpMiddleLayout&>(*xBase.get()).GetScaleMode();
 926     else
 927         return (LwpLayoutScale::FIT_IN_FRAME | LwpLayoutScale::MAINTAIN_ASPECT_RATIO);
 928 }
 929
 930 sal_uInt16 LwpMiddleLayout::GetScaleTile()
 931 {
 932     if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj().is() && GetLayoutScale())
 933         return (GetLayoutScale()->GetPlacement() & LwpLayoutScale::TILED)
 934             ? 1 : 0;
 935     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 936     if (xBase.is())
 937         return dynamic_cast<LwpMiddleLayout&>(*xBase.get()).GetScaleTile();
 938     else
 939         return 0;
 940 }
 941
 942 sal_uInt16 LwpMiddleLayout::GetScaleCenter()
 943 {
 944     if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj().is() && GetLayoutScale())
 945     {
 946         return (GetLayoutScale()->GetPlacement() & LwpLayoutScale::CENTERED)
 947             ? 1 : 0;
 948     }
 949     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 950     if (xBase.is())
 951         return dynamic_cast<LwpMiddleLayout&>(*xBase.get()).GetScaleCenter();
 952     else
 953         return 0;
 954 }
 955
 956 sal_uInt32 LwpMiddleLayout::GetScalePercentage()
 957 {
 958     if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj().is() && GetLayoutScale())
 959         return GetLayoutScale()->GetScalePercentage()/10;//m_nScalePercentage 1000 = 100%
 960     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 961     if (xBase.is())
 962         return dynamic_cast<LwpMiddleLayout&>(*xBase.get()).GetScalePercentage();
 963     else
 964         return 100;
 965 }
 966
 967 double LwpMiddleLayout::GetScaleWidth()
 968 {
 969     if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj().is() && GetLayoutScale())
 970         return LwpTools::ConvertFromUnits(GetLayoutScale()->GetScaleWidth());
 971     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 972     if (xBase.is())
 973         return dynamic_cast<LwpMiddleLayout&>(*xBase.get()).GetScaleWidth();
 974     else
 975         return 0;
 976 }
 977
 978 double LwpMiddleLayout::GetScaleHeight()
 979 {
 980     if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj().is() && GetLayoutScale())
 981         return LwpTools::ConvertFromUnits(GetLayoutScale()->GetScaleHeight());
 982     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 983     if (xBase.is())
 984         return dynamic_cast<LwpMiddleLayout&>(*xBase.get()).GetScaleHeight();
 985     else
 986         return 0;
 987 }
 988 bool LwpMiddleLayout::CanSizeRight()
 989 {
 990     sal_uInt8 RelType = GetRelativeType();
 991
 992     if (RelType == LwpLayoutRelativityGuts::LAY_INLINE || RelType == LwpLayoutRelativityGuts::LAY_PARA_RELATIVE
 993     || RelType == LwpLayoutRelativityGuts::LAY_INLINE_VERTICAL)
 994     {
 995         return false;
 996     }
 997     return true;
 998 }
 999 sal_Int32 LwpMiddleLayout::GetMinimumWidth()
1000 {
1001     if (((m_nAttributes3 & STYLE3_WIDTHVALID) != 0) && GetGeometry())
1002     {
1003         return GetGeometry()->GetWidth();
1004     }
1005     else if (m_nOverrideFlag & OVER_SIZE)
1006     {
1007         return DetermineWidth();
1008     }
1009     return 0;
1010 }
1011 sal_Int32 LwpMiddleLayout::DetermineWidth()
1012 {
1013     if (IsSizeRightToContent())
1014     {
1015         assert(false);
1016     }
1017     else if (IsSizeRightToContainer())
1018     {
1019         assert(false);
1020     }
1021     else if (LwpLayoutGeometry* pGeo = GetGeometry())
1022     {
1023         m_nAttributes3 |= STYLE3_WIDTHVALID;
1024         return pGeo->GetWidth();
1025     }
1026     return 0;
1027 }
1028 bool LwpMiddleLayout::IsSizeRightToContainer()
1029 {
1030     if (!CanSizeRight())
1031         return false;
1032
1033     if (m_nOverrideFlag & OVER_SIZE)
1034     {
1035         return (m_nDirection & ((LAY_USEDIRECTION|LAY_AUTOSIZE|LAY_TOCONTAINER)
1036                         << SHIFT_RIGHT))
1037         == ((LAY_USEDIRECTION | LAY_TOCONTAINER | LAY_AUTOSIZE) << SHIFT_RIGHT);
1038     }
1039     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1040     if (xBase.is())
1041     {
1042         LwpMiddleLayout * pLayout = dynamic_cast<LwpMiddleLayout *>(xBase.get());
1043         return pLayout && pLayout->IsSizeRightToContainer();
1044     }
1045     else
1046         return false;
1047 }
1048 bool LwpMiddleLayout::IsSizeRightToContent()
1049 {
1050     if (!CanSizeRight())
1051         return false;
1052
1053     if (m_nOverrideFlag & OVER_SIZE)
1054     {
1055         return (m_nDirection & ((LAY_USEDIRECTION|LAY_AUTOSIZE|LAY_TOCONTAINER)
1056                             << SHIFT_RIGHT))
1057                 == ((LAY_USEDIRECTION | LAY_AUTOSIZE) << SHIFT_RIGHT);
1058     }
1059     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1060     if (xBase.is())
1061     {
1062         LwpMiddleLayout * pLayout = dynamic_cast<LwpMiddleLayout *>(xBase.get());
1063         return pLayout && pLayout->IsSizeRightToContent();
1064     }
1065     else
1066         return false;
1067 }
1068
1069 /**
1070 * @descr:   Get layout height
1071 *
1072 */
1073 double LwpMiddleLayout::GetHeight()
1074 {
1075     return GetGeometryHeight();
1076 }
1077
1078 /**
1079 * @descr:   Get layout height
1080 *
1081 */
1082 double LwpMiddleLayout::GetWidth()
1083 {
1084     return GetGeometryWidth();
1085 }
1086 /**
1087 * @descr:   Get layout origin point
1088 *
1089 */
1090 LwpPoint LwpMiddleLayout::GetOrigin()
1091 {
1092     LwpLayoutGeometry* pGeo = GetGeometry();
1093     if(pGeo)
1094     {
1095         sal_uInt8 nType = GetRelativeType();
1096         if(nType == LwpLayoutRelativityGuts::LAY_INLINE
1097             || nType == LwpLayoutRelativityGuts::LAY_INLINE_NEWLINE )
1098         {
1099             return pGeo->GetAbsoluteOrigin();
1100         }
1101         else
1102             return pGeo->GetOrigin();
1103
1104     }
1105
1106     return LwpPoint();
1107 }
1108
1109 /**
1110 * @descr:   Whether the fill is pattern fill or not
1111 * @return:  True if yes, false if not.
1112 */
1113 bool LwpMiddleLayout::IsPatternFill()
1114 {
1115     LwpBackgroundStuff* pBackgroundStuff = GetBackgroundStuff();
1116     if (pBackgroundStuff)
1117     {
1118         return pBackgroundStuff->IsPatternFill();
1119     }
1120
1121     return false;
1122 }
1123
1124 /**
1125 * @descr:   Get the fill pattern style. Data are saved in a XFBGImage object
1126 * @return:  the fill pattern style.
1127 */
1128 XFBGImage* LwpMiddleLayout::GetFillPattern()
1129 {
1130     LwpBackgroundStuff* pBackgroundStuff = GetBackgroundStuff();
1131     if (pBackgroundStuff)
1132     {
1133         return pBackgroundStuff->GetFillPattern();
1134     }
1135
1136     return nullptr;
1137
1138 }
1139
1140 /**
1141 * @descr:   Whether the height and width of layout is auto grow
1142 *
1143 */
1144 bool LwpMiddleLayout::IsAutoGrow()
1145 {
1146     if(m_nOverrideFlag & OVER_SIZE)
1147     {
1148         return (m_nDirection &
1149             ((LAY_AUTOGROW << SHIFT_UP) | (LAY_AUTOGROW << SHIFT_DOWN) |
1150             (LAY_AUTOGROW << SHIFT_RIGHT) | (LAY_AUTOGROW << SHIFT_LEFT))) != 0;
1151     }
1152     else
1153     {
1154         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1155         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1156         {
1157             return pLay->IsAutoGrow();
1158         }
1159     }
1160     return LwpVirtualLayout::IsAutoGrow();
1161 }
1162
1163 /**
1164 * @descr:   Whether the height of layout is auto grow down
1165 *
1166 */
1167 bool LwpMiddleLayout::IsAutoGrowDown()
1168 {
1169     if(m_nOverrideFlag & OVER_SIZE)
1170     {
1171         return (m_nDirection & (LAY_AUTOGROW << SHIFT_DOWN)) != 0;
1172     }
1173     else
1174     {
1175         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1176         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1177         {
1178             return pLay->GetIsAutoGrowDown();
1179         }
1180     }
1181     return LwpVirtualLayout::IsAutoGrowDown();
1182 }
1183
1184 /**
1185 * @descr:   Whether the height of layout is auto grow up
1186 *
1187 */
1188 bool LwpMiddleLayout::IsAutoGrowUp()
1189 {
1190     if(m_nOverrideFlag & OVER_SIZE)
1191     {
1192         return (m_nDirection & (LAY_AUTOGROW << SHIFT_UP)) != 0;
1193     }
1194     else
1195     {
1196         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1197         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1198         {
1199             return pLay->IsAutoGrowUp();
1200         }
1201     }
1202     return LwpVirtualLayout::IsAutoGrowUp();
1203 }
1204
1205 /**
1206 * @descr:   Whether the height of layout is auto grow down
1207 *
1208 */
1209 bool LwpMiddleLayout::IsAutoGrowLeft()
1210 {
1211     if(m_nOverrideFlag & OVER_SIZE)
1212     {
1213         return (m_nDirection & (LAY_AUTOGROW << SHIFT_LEFT)) != 0;
1214     }
1215     else
1216     {
1217         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1218         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1219         {
1220             return pLay->IsAutoGrowLeft();
1221         }
1222     }
1223     return LwpVirtualLayout::IsAutoGrowLeft();
1224 }
1225
1226 /**
1227 * @descr:   Whether the height of layout is auto grow down
1228 *
1229 */
1230 bool LwpMiddleLayout::IsAutoGrowRight()
1231 {
1232     if(m_nOverrideFlag & OVER_SIZE)
1233     {
1234         return (m_nDirection & (LAY_AUTOGROW << SHIFT_RIGHT)) != 0;
1235     }
1236     else
1237     {
1238         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1239         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1240         {
1241             return pLay->IsAutoGrowRight();
1242         }
1243     }
1244     return LwpVirtualLayout::IsAutoGrowRight();
1245 }
1246
1247 /**
1248 * @descr:   Get contents orientation
1249 *
1250 */
1251 sal_uInt8 LwpMiddleLayout::GetContentOrientation()
1252 {
1253     //content orientation in Graphic objects and OLE objects not supported now
1254     if((m_nOverrideFlag & OVER_ROTATION)&& !m_LayGeometry.IsNull())
1255     {
1256         LwpLayoutGeometry* pLayGeometry = dynamic_cast<LwpLayoutGeometry*> (m_LayGeometry.obj().get());
1257         if (pLayGeometry)
1258             return pLayGeometry->GetContentOrientation();
1259     }
1260     else
1261     {
1262         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1263         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1264         {
1265             return pLay->GetContentOrientation();
1266         }
1267     }
1268     return LwpVirtualLayout::GetContentOrientation();
1269 }
1270
1271 /**
1272 * @descr:   Whether it is honoring protection
1273 *
1274 */
1275 bool LwpMiddleLayout::HonorProtection()
1276 {
1277     if(m_nOverrideFlag & OVER_MISC)
1278     {
1279         if(!(m_nAttributes2 & STYLE2_HONORPROTECTION))
1280             return false;
1281
1282         rtl::Reference<LwpVirtualLayout> xParent(dynamic_cast<LwpVirtualLayout*>(GetParent().obj().get()));
1283         if (xParent.is() && !xParent->IsHeader())
1284         {
1285             return xParent->GetHonorProtection();
1286         }
1287
1288         if(m_pFoundry)//is null now
1289         {
1290             LwpDocument* pDoc = m_pFoundry->GetDocument();
1291             if (pDoc)
1292             {
1293                 return pDoc->GetHonorProtection();
1294             }
1295         }
1296     }
1297     else
1298     {
1299         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1300         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1301         {
1302             return pLay->GetHonorProtection();
1303         }
1304     }
1305
1306     return LwpVirtualLayout::HonorProtection();
1307 }
1308
1309 /**
1310 * @descr:   Whether it is protected
1311 *
1312 */
1313 bool LwpMiddleLayout::IsProtected()
1314 {
1315     bool bProtected = false;
1316     if(m_nOverrideFlag & OVER_MISC)
1317     {
1318         bProtected = (m_nAttributes & STYLE_PROTECTED)!=0;
1319     }
1320     else
1321     {
1322         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1323         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1324         {
1325             bProtected = pLay->GetIsProtected();
1326         }
1327         else
1328             bProtected = LwpVirtualLayout::IsProtected();
1329     }
1330
1331     rtl::Reference<LwpVirtualLayout> xParent(dynamic_cast<LwpVirtualLayout*>(GetParent().obj().get()));
1332     if (xParent.is() && !xParent->IsHeader())
1333     {
1334         /* If a parent's protected then none of its children can be accessed. */
1335         if (xParent->GetIsProtected())
1336             return true;
1337
1338         if (xParent->GetHonorProtection())
1339             return bProtected;
1340
1341         /* If our parent isn't honoring protection then we aren't protected. */
1342         return false;
1343
1344     }
1345     if(m_pFoundry)//is null now
1346     {
1347         LwpDocument* pDoc = m_pFoundry->GetDocument();
1348         if(pDoc)
1349         {
1350             if (pDoc->GetHonorProtection())
1351                 return bProtected;
1352
1353             /* If the document isn't honoring protection then we aren't protected.*/
1354             return false;
1355         }
1356     }
1357
1358     return bProtected;
1359 }
1360
1361 /**
1362 * @descr:   Get watermark layout
1363 *
1364 */
1365 rtl::Reference<LwpVirtualLayout> LwpMiddleLayout::GetWaterMarkLayout()
1366 {
1367     rtl::Reference<LwpVirtualLayout> xLay(dynamic_cast<LwpVirtualLayout*>(GetChildHead().obj().get()));
1368     while (xLay.is())
1369     {
1370         if (xLay->IsForWaterMark())
1371         {
1372             return xLay;
1373         }
1374         xLay.set(dynamic_cast<LwpVirtualLayout*>(xLay->GetNext().obj().get()));
1375     }
1376     return rtl::Reference<LwpVirtualLayout>();
1377 }
1378
1379 /**
1380 * @descr:   Create and reture xfbgimage object for watermark
1381 *
1382 */
1383 XFBGImage* LwpMiddleLayout::GetXFBGImage()
1384 {
1385     rtl::Reference<LwpVirtualLayout> xWaterMarkLayout(GetWaterMarkLayout());
1386     LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xWaterMarkLayout.get());
1387     if(pLay)
1388     {
1389         //test BGImage
1390         LwpGraphicObject* pGrfObj = dynamic_cast<LwpGraphicObject*>(pLay->GetContent().obj().get());
1391         if(pGrfObj)
1392         {
1393             XFBGImage* pXFBGImage = new XFBGImage();
1394
1395             if(pGrfObj->IsLinked())
1396             {
1397                 //set file link
1398                 OUString linkedfilepath = pGrfObj->GetLinkedFilePath();
1399                 OUString fileURL = LwpTools::convertToFileUrl(OUStringToOString(linkedfilepath, osl_getThreadTextEncoding()));
1400                 pXFBGImage->SetFileLink(fileURL);
1401             }
1402             else
1403             {
1404                 sal_uInt8* pGrafData = nullptr;
1405                 sal_uInt32 nDataLen = pGrfObj->GetRawGrafData(pGrafData);
1406                 pXFBGImage->SetImageData(pGrafData, nDataLen);
1407                 if(pGrafData)
1408                 {
1409                     delete[] pGrafData;
1410                     pGrafData = nullptr;
1411                 }
1412             }
1413
1414             //automatic, top left
1415             pXFBGImage->SetPosition(enumXFAlignStart,enumXFAlignTop);
1416             if(pLay->GetScaleCenter())
1417             {
1418                 //center
1419                 pXFBGImage->SetPosition();
1420             }
1421             else if(pLay->GetScaleTile())
1422             {
1423                 //tile
1424                 pXFBGImage->SetRepeate();
1425             }
1426             //fit type, area type
1427             if((pLay->GetScaleMode()& LwpLayoutScale::FIT_IN_FRAME)!=0)
1428             {
1429                 if((pLay->GetScaleMode()& LwpLayoutScale::MAINTAIN_ASPECT_RATIO)==0)
1430                 {
1431                     pXFBGImage->SetStretch();
1432                 }
1433             }
1434             return pXFBGImage;
1435         }
1436     }
1437     return nullptr;
1438 }
1439
1440 /**
1441 * @descr:   Whether the page uses the printer setting
1442 *
1443 */
1444 bool LwpMiddleLayout::GetUsePrinterSettings()
1445 {
1446     if(m_nOverrideFlag & OVER_SIZE)
1447     {
1448         return (m_nAttributes3 & STYLE3_USEPRINTERSETTINGS) != 0;
1449     }
1450     else
1451     {
1452         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1453         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1454         {
1455             return pLay->GetUsePrinterSettings();
1456         }
1457     }
1458     return false;
1459 }
1460
1461 //Check whether there are contents in the layout
1462 bool LwpMiddleLayout::HasContent()
1463 {
1464     rtl::Reference<LwpObject> content = m_Content.obj();
1465     if(content.is())
1466         return true;
1467     return false;
1468 }
1469
1470 LwpLayout::LwpLayout( LwpObjectHeader &objHdr, LwpSvStream* pStrm ) :
1471     LwpMiddleLayout(objHdr, pStrm), m_pUseWhen(new LwpUseWhen)
1472 {}
1473
1474 LwpLayout::~LwpLayout()
1475 {
1476     if (m_pUseWhen)
1477     {
1478         delete m_pUseWhen;
1479     }
1480 }
1481
1482 void LwpLayout::Read()
1483 {
1484     LwpObjectStream* pStrm = m_pObjStrm.get();
1485
1486     LwpMiddleLayout::Read();
1487     if (LwpFileHeader::m_nFileRevision < 0x000B)
1488     {
1489         // read PreRevBLayout...
1490     }
1491     else
1492     {
1493         sal_uInt16 nSimple = pStrm->QuickReaduInt16();
1494
1495         if (!nSimple)
1496         {
1497             m_pUseWhen->Read(pStrm);
1498
1499             sal_uInt8 nFlag = pStrm->QuickReaduInt8();
1500             if (nFlag)
1501                 m_Position.ReadIndexed(pStrm);
1502         }
1503
1504         m_LayColumns.ReadIndexed(pStrm);
1505         m_LayGutterStuff.ReadIndexed(pStrm);
1506         m_LayJoinStuff.ReadIndexed(pStrm);
1507         m_LayShadow.ReadIndexed(pStrm);
1508
1509         if (pStrm->CheckExtra())
1510         {
1511             m_LayExtJoinStuff.ReadIndexed(pStrm);
1512             pStrm->SkipExtra();
1513         }
1514     }
1515 }
1516
1517 /**
1518 * @descr:   Get columns number
1519 *
1520 */
1521 sal_uInt16 LwpLayout::GetNumCols()
1522 {
1523     if(m_nOverrideFlag & OVER_COLUMNS)
1524     {
1525         LwpLayoutColumns* pLayColumns = dynamic_cast<LwpLayoutColumns*>(m_LayColumns.obj().get());
1526         if(pLayColumns)
1527         {
1528             return pLayColumns->GetNumCols();
1529         }
1530     }
1531
1532     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1533     LwpVirtualLayout* pStyle = dynamic_cast<LwpVirtualLayout*>(xBase.get());
1534     if (pStyle)
1535     {
1536         return pStyle->GetNumCols();
1537     }
1538
1539     return LwpVirtualLayout::GetNumCols();
1540
1541 }
1542
1543 /**
1544 * @descr:   Get column width
1545 * @param:   the order of column
1546 */
1547 double LwpLayout::GetColWidth(sal_uInt16 nIndex)
1548 {
1549     if((m_nOverrideFlag & OVER_COLUMNS)||(m_nAttributes2 & STYLE2_LOCALCOLUMNINFO))
1550     {
1551         LwpLayoutColumns* pLayColumns = dynamic_cast<LwpLayoutColumns*>(m_LayColumns.obj().get());
1552         if(pLayColumns)
1553         {
1554             return pLayColumns->GetColWidth(nIndex);
1555         }
1556     }
1557
1558     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1559     LwpVirtualLayout* pStyle = dynamic_cast<LwpVirtualLayout*>(xBase.get());
1560     if (pStyle)
1561     {
1562         return pStyle->GetColWidth(nIndex);
1563     }
1564
1565     return LwpVirtualLayout::GetColWidth(nIndex);
1566
1567 }
1568
1569 /**
1570 * @descr:   Get gap between columns
1571 * @param:   the order of column
1572 */
1573 double LwpLayout::GetColGap(sal_uInt16 nIndex)
1574 {
1575     if((m_nOverrideFlag & OVER_COLUMNS)||(m_nAttributes2 & STYLE2_LOCALCOLUMNINFO))
1576     {
1577         LwpLayoutColumns* pLayColumns = dynamic_cast<LwpLayoutColumns*>(m_LayColumns.obj().get());
1578         if(pLayColumns)
1579         {
1580             return pLayColumns->GetColGap(nIndex);
1581         }
1582     }
1583
1584     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1585     LwpVirtualLayout* pStyle = dynamic_cast<LwpVirtualLayout*>(xBase.get());
1586     if (pStyle)
1587     {
1588         return pStyle->GetColGap(nIndex);
1589     }
1590
1591     return LwpVirtualLayout::GetColGap(nIndex);
1592 }
1593
1594 /**
1595 * @descr:   Create and return XFColumns object
1596 *
1597 */
1598 XFColumns* LwpLayout::GetXFColumns()
1599 {
1600     //if there is only one column, do not need insert columns
1601     sal_uInt16 nCols = GetNumCols();
1602     if(nCols==1)
1603     {
1604         return nullptr;
1605     }
1606
1607     XFColumns* pColumns = new XFColumns();
1608     //set XFColumnSep
1609     std::unique_ptr<XFColumnSep> pColumnSep(GetColumnSep());
1610     if(pColumnSep)
1611     {
1612         pColumns->SetSeparator(*pColumnSep);
1613     }
1614
1615     //set column count and column gap
1616     pColumns->SetCount(nCols);
1617     double fGap = GetColGap(0);
1618     pColumns->SetGap(fGap);
1619
1620     //set xfcolumn
1621     for(sal_uInt16 nIndex = 0; nIndex<nCols; nIndex++)
1622     {
1623         XFColumn aColumn;
1624         sal_Int32 nWidth = 8305/nCols;  //relative width
1625         aColumn.SetRelWidth(nWidth);
1626
1627         //the left and right margins is 0;
1628         double nGap = GetColGap(nIndex)/2;
1629         aColumn.SetMargins(nGap,nGap);
1630         if(nIndex==0)
1631         {
1632             aColumn.SetMargins(0,nGap);
1633         }
1634         if(nIndex==(nCols-1))
1635         {
1636             aColumn.SetMargins(nGap,0);
1637         }
1638         pColumns->AddColumn(aColumn);
1639     }
1640
1641     return pColumns;
1642 }
1643
1644 /**
1645 * @descr:   Create and return XFColumnSep object
1646 *
1647 */
1648 XFColumnSep* LwpLayout::GetColumnSep()
1649 {
1650
1651     //Get LwpLayoutGutters
1652     LwpLayoutGutters* pLayoutGutters = dynamic_cast<LwpLayoutGutters*>(m_LayGutterStuff.obj().get());
1653     if(!pLayoutGutters)
1654     {
1655         return nullptr;
1656     }
1657
1658     LwpBorderStuff& rBorderStuff = pLayoutGutters->GetBorderStuff();
1659
1660     LwpBorderStuff::BorderType eType = LwpBorderStuff::LEFT;
1661     LwpColor    aColor = rBorderStuff.GetSideColor(eType);
1662     double  fWidth = rBorderStuff.GetSideWidth(eType);
1663     //sal_uInt16    nType = rBorderStuff->GetSideType(eType);
1664
1665     XFColumnSep* pColumnSep = new XFColumnSep();
1666     XFColor aXFColor(aColor.To24Color());
1667     pColumnSep->SetColor(aXFColor);
1668     pColumnSep->SetWidth(fWidth);
1669     pColumnSep->SetRelHeight(100);
1670     pColumnSep->SetVerticalAlign(enumXFAlignTop);
1671
1672     return pColumnSep;
1673 }
1674
1675 /**
1676 * @descr:   Get use when type
1677 *
1678 */
1679 LwpLayout::UseWhenType LwpLayout::GetUseWhenType()
1680 {
1681     UseWhenType eType = StartWithinPage;
1682     LwpUseWhen* pUseWhen = GetUseWhen();
1683     if(pUseWhen)
1684     {
1685         if(pUseWhen->IsStartOnThisHF())
1686         {
1687             eType =  StartWithinColume;
1688         }
1689         else if(pUseWhen->IsStartOnThisPage())
1690         {
1691             eType =  StartWithinPage;
1692         }
1693         else if(pUseWhen->IsStartOnNextPage())
1694         {
1695             eType = StartOnNextPage;
1696         }
1697         else if(pUseWhen->IsStartOnNextOddPage())
1698         {
1699             eType =  StartOnOddPage;
1700         }
1701         else if(pUseWhen->IsStartOnNextEvenPage())
1702         {
1703             eType =   StartOnEvenPage;
1704         }
1705
1706     }
1707     else
1708     {
1709         eType =   StartOnNextPage;
1710     }
1711     return eType;
1712 }
1713
1714 /**
1715 * @descr:   Get use page
1716 *
1717 */
1718 sal_uInt16 LwpLayout::GetUsePage()
1719 {
1720     if(m_nOverrideFlag & OVER_PLACEMENT)
1721     {
1722         LwpUseWhen* pUseWhen = GetUseWhen();
1723         if(pUseWhen)
1724             return pUseWhen->GetUsePage();
1725         else
1726             return 0;
1727     }
1728     else
1729     {
1730         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1731         if (LwpLayout* pLay = dynamic_cast<LwpLayout*>(xBase.get()))
1732         {
1733             return pLay->GetUsePage();
1734         }
1735     }
1736     return 0;
1737 }
1738
1739 /**
1740 * @descr:   Get usewhen pointer
1741 *
1742 */
1743 LwpUseWhen* LwpLayout::VirtualGetUseWhen()
1744 {
1745     if(m_nOverrideFlag & OVER_PLACEMENT)
1746     {
1747         return m_pUseWhen;
1748     }
1749     else
1750     {
1751         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1752         if (LwpLayout* pLay = dynamic_cast<LwpLayout*>(xBase.get()))
1753         {
1754             return pLay->VirtualGetUseWhen();
1755         }
1756     }
1757     return LwpVirtualLayout::VirtualGetUseWhen();
1758 }
1759
1760 /**
1761 * @descr:   Whether it is use on all pages
1762 *
1763 */
1764 bool LwpLayout::IsUseOnAllPages()
1765 {
1766     if(m_nOverrideFlag & OVER_PLACEMENT)
1767     {
1768         LwpUseWhen* pUseWhen = GetUseWhen();
1769         if(pUseWhen)
1770             return pUseWhen->IsUseOnAllPages();
1771         else
1772             return false;
1773     }
1774     else
1775     {
1776         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1777         if (LwpLayout* pLay = dynamic_cast<LwpLayout*>(xBase.get()))
1778         {
1779             return pLay->IsUseOnAllPages();
1780         }
1781     }
1782     return LwpVirtualLayout::IsUseOnAllPages();
1783 }
1784
1785 /**
1786 * @descr:   Whether it is use on all even pages
1787 *
1788 */
1789 bool LwpLayout::IsUseOnAllEvenPages()
1790 {
1791     if(m_nOverrideFlag & OVER_PLACEMENT)
1792     {
1793         LwpUseWhen* pUseWhen = GetUseWhen();
1794         if(pUseWhen)
1795             return pUseWhen->IsUseOnAllEvenPages();
1796         else
1797             return false;
1798     }
1799     else
1800     {
1801         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1802         if (LwpLayout* pLay = dynamic_cast<LwpLayout*>(xBase.get()))
1803         {
1804             return pLay->IsUseOnAllEvenPages();
1805         }
1806     }
1807     return LwpVirtualLayout::IsUseOnAllEvenPages();
1808 }
1809
1810 /**
1811 * @descr:   Whether it is use on all odd pages
1812 *
1813 */
1814 bool LwpLayout::IsUseOnAllOddPages()
1815 {
1816     if(m_nOverrideFlag & OVER_PLACEMENT)
1817     {
1818         LwpUseWhen* pUseWhen = GetUseWhen();
1819         if(pUseWhen)
1820             return pUseWhen->IsUseOnAllOddPages();
1821         else
1822             return false;
1823     }
1824     else
1825     {
1826         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1827         if (LwpLayout* pLay = dynamic_cast<LwpLayout*>(xBase.get()))
1828         {
1829             return pLay->IsUseOnAllOddPages();
1830         }
1831     }
1832     return LwpVirtualLayout::IsUseOnAllOddPages();
1833 }
1834
1835 /**
1836 * @descr:   Whether it is use on current page
1837 *
1838 */
1839 bool LwpLayout::IsUseOnPage()
1840 {
1841     if(m_nOverrideFlag & OVER_PLACEMENT)
1842     {
1843         LwpUseWhen* pUseWhen = GetUseWhen();
1844         if(pUseWhen)
1845             return pUseWhen->IsUseOnPage();
1846         else
1847             return false;
1848     }
1849     else
1850     {
1851         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1852         if (LwpLayout* pLay = dynamic_cast<LwpLayout*>(xBase.get()))
1853         {
1854             return pLay->IsUseOnPage();
1855         }
1856     }
1857     return LwpVirtualLayout::IsUseOnPage();
1858 }
1859
1860 /**
1861  * @descr:  Get the LwpShadow object according to m_LayShadow id.
1862 */
1863 LwpShadow* LwpLayout::GetShadow()
1864 {
1865     if(m_nOverrideFlag & OVER_SHADOW)
1866     {
1867         LwpLayoutShadow* pLayoutShadow = dynamic_cast<LwpLayoutShadow*>(m_LayShadow.obj().get());
1868         return pLayoutShadow ? &pLayoutShadow->GetShadow() : nullptr;
1869     }
1870     else
1871     {
1872         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1873         if (LwpLayout* pLay = dynamic_cast<LwpLayout*>(xBase.get()))
1874         {
1875             return pLay->GetShadow();
1876         }
1877     }
1878     return nullptr;
1879 }
1880
1881 /**
1882  * @descr:  create xfshadow
1883 */
1884 XFShadow* LwpLayout::GetXFShadow()
1885 {
1886     LwpShadow* pShadow = GetShadow();
1887     if( pShadow )
1888     {
1889         LwpColor color = pShadow->GetColor();
1890         double  offsetX = pShadow->GetOffsetX();
1891         double  offsetY = pShadow->GetOffsetY();
1892
1893         if( offsetX && offsetY && color.IsValidColor() )
1894         {
1895             XFShadow* pXFShadow = new XFShadow();
1896             enumXFShadowPos eXFShadowPos = enumXFShadowLeftTop;
1897             double fOffset = 0;
1898
1899             bool left = false;
1900             bool top = false;
1901             if( offsetX < 0 )
1902                 left = true;
1903             if( offsetY < 0 )
1904                 top = true;
1905             if( left )
1906             {
1907                 fOffset = -offsetX;
1908                 if( top )
1909                     eXFShadowPos = enumXFShadowLeftTop;
1910                 else
1911                     eXFShadowPos = enumXFShadowLeftBottom;
1912             }
1913             else
1914             {
1915                 fOffset = offsetX;
1916                 if( top )
1917                     eXFShadowPos = enumXFShadowRightTop;
1918                 else
1919                     eXFShadowPos = enumXFShadowRightBottom;
1920             }
1921
1922             pXFShadow->SetPosition(eXFShadowPos);
1923             pXFShadow->SetOffset(fOffset);
1924             pXFShadow->SetColor(XFColor(color.To24Color()));
1925
1926             return pXFShadow;
1927         }
1928     }
1929     return nullptr;
1930 }
1931
1932 /**
1933  * @descr get the layout that containers the current frame layout
1934  *
1935  */
1936 rtl::Reference<LwpVirtualLayout> LwpLayout::GetContainerLayout()
1937 {
1938     if(IsRelativeAnchored())
1939     {
1940         //get position
1941         LwpPara* pPara = dynamic_cast<LwpPara*>(GetPosition().obj().get());
1942         if(pPara)
1943         {
1944             LwpStory* pStory = pPara->GetStory();
1945             return pStory ? pStory->GetTabLayout() : nullptr;
1946         }
1947     }
1948     return GetParentLayout();
1949 }
1950
1951 LwpPlacableLayout::LwpPlacableLayout( LwpObjectHeader &objHdr, LwpSvStream* pStrm )
1952     : LwpLayout(objHdr, pStrm)
1953     , m_nWrapType(0)
1954     , m_nBuoyancy(0)
1955     , m_nBaseLineOffset(0)
1956 {}
1957
1958 LwpPlacableLayout::~LwpPlacableLayout()
1959 {}
1960
1961 void LwpPlacableLayout::Read()
1962 {
1963     LwpObjectStream* pStrm = m_pObjStrm.get();
1964     LwpLayout::Read();
1965     if(LwpFileHeader::m_nFileRevision < 0x000B)
1966     {
1967         assert(false);
1968     }
1969     else
1970     {
1971         sal_uInt16 simple = pStrm->QuickReaduInt16();
1972         if(!simple)
1973         {
1974             m_nWrapType = pStrm->QuickReaduInt8();
1975             m_nBuoyancy = pStrm->QuickReaduInt8();
1976             m_nBaseLineOffset = pStrm->QuickReadInt32();
1977             m_Script.Read( pStrm);
1978         }
1979         else
1980         {
1981             m_nWrapType = LAY_WRAP_AROUND;
1982             m_nBuoyancy = LAY_BUOYNEUTRAL;
1983             m_nBaseLineOffset    = 0;
1984         }
1985         m_LayRelativity.ReadIndexed( pStrm);
1986         if(pStrm->CheckExtra())
1987         {
1988             sal_uInt16 count = pStrm->QuickReaduInt16();
1989             if(count)
1990             {
1991                 // temporily added by  to avoid assertion
1992                 while (count)
1993                 {
1994                     LwpPoint aPoint;
1995                     aPoint.Read(pStrm);
1996                     count--;
1997                 }
1998             }
1999             pStrm->SkipExtra();
2000         }
2001     }
2002 }
2003 /**
2004  * @descr:  get wrap type
2005 */
2006 sal_uInt8 LwpPlacableLayout::GetWrapType()
2007 {
2008     if(m_nOverrideFlag & OVER_PLACEMENT)
2009     {
2010         return m_nWrapType;
2011     }
2012     else
2013     {
2014         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
2015         if (LwpPlacableLayout* pLay = dynamic_cast<LwpPlacableLayout*>(xBase.get()))
2016         {
2017             return pLay->GetWrapType();
2018         }
2019     }
2020     return LAY_WRAP_AROUND;
2021 }
2022 /**
2023  * @descr:  get LayoutRelativity
2024 */
2025 LwpLayoutRelativity* LwpPlacableLayout::GetRelativityPiece()
2026 {
2027     if(!m_LayRelativity.IsNull())
2028     {
2029         if(m_nOverrideFlag & OVER_PLACEMENT)
2030         {
2031             return dynamic_cast<LwpLayoutRelativity*>(m_LayRelativity.obj().get());
2032         }
2033     }
2034     else
2035     {
2036         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
2037         if (LwpPlacableLayout* pLay = dynamic_cast<LwpPlacableLayout*>(xBase.get()))
2038         {
2039             return pLay->GetRelativityPiece();
2040         }
2041     }
2042     return nullptr;
2043 }
2044 /**
2045 * @descr:   Get relative type
2046 *
2047 */
2048 sal_uInt8 LwpPlacableLayout::GetRelativeType()
2049 {
2050     LwpLayoutRelativity* pLayRel = GetRelativityPiece();
2051     if(pLayRel)
2052     {
2053         return pLayRel->GetRelGuts().GetRelativeType();
2054     }
2055     return LwpVirtualLayout::GetRelativeType();
2056 }
2057 /**
2058 * @descr:   Get offset from the baseline
2059 *
2060 */
2061 sal_Int32 LwpPlacableLayout::GetBaseLineOffset()
2062 {
2063     /* The baseline is only valid if this is flow-with-text */
2064     if(GetRelativeType()!=LwpLayoutRelativityGuts::LAY_INLINE)
2065     {
2066         return 0;
2067     }
2068
2069     // First, ask our content if it has a baseline, ignore now
2070     /*
2071     if (Content && Content->GetBaseLineOffset(&Baseline))
2072         return Baseline;
2073     */
2074
2075     if(m_nOverrideFlag & OVER_PLACEMENT)
2076     {
2077         return m_nBaseLineOffset;
2078     }
2079     else
2080     {
2081         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
2082         if (LwpPlacableLayout* pLay = dynamic_cast<LwpPlacableLayout*>(xBase.get()))
2083         {
2084             return pLay->GetBaseLineOffset();
2085         }
2086     }
2087     return 0;
2088
2089 }
2090 /**
2091 * @descr:   whether the parent layout is page layout
2092 *
2093 */
2094 bool LwpPlacableLayout::IsAnchorPage()
2095 {
2096     if(IsRelativeAnchored())
2097         return false;
2098
2099     rtl::Reference<LwpVirtualLayout> xLayout = GetParentLayout();
2100     if (xLayout.is() && (xLayout->IsPage() || xLayout->IsHeader() || xLayout->IsFooter()))
2101     {
2102         return true;
2103     }
2104     return false;
2105 }
2106 /**
2107 * @descr:   whether the parent layout is frame layout
2108 *
2109 */
2110 bool LwpPlacableLayout::IsAnchorFrame()
2111 {
2112     if(IsRelativeAnchored())
2113         return false;
2114
2115     rtl::Reference<LwpVirtualLayout> xLayout = GetParentLayout();
2116     if (xLayout.is() && (xLayout->IsFrame() || xLayout->IsGroupHead()))
2117     {
2118         return true;
2119     }
2120     return false;
2121 }
2122 /**
2123 * @descr:   whether the parent layout is cell layout
2124 *
2125 */
2126 bool LwpPlacableLayout::IsAnchorCell()
2127 {
2128     if(IsRelativeAnchored())
2129         return false;
2130
2131     rtl::Reference<LwpVirtualLayout> xLayout = GetParentLayout();
2132     if (xLayout.is() && xLayout->IsCell())
2133     {
2134         return true;
2135     }
2136     return false;
2137 }
2138
2139 /**
2140 * @descr:   Set font style for setting position of frame
2141 *
2142 */
2143 void LwpPlacableLayout::SetFont(rtl::Reference<XFFont> const & pFont)
2144 {
2145     m_pFont = pFont;
2146 }
2147
2148 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */