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