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 LwpTools::ConvertToMetric(0.17);
 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         rtl::Reference<LwpVirtualLayout> xNext(
 502             dynamic_cast<LwpVirtualLayout*>(xLayout->GetNext().obj().get()));
 503         xLayout = xNext;
 504     }
 505 }
 506
 507 /**
 508  * @descr   find endnote supertable layout from the child layout list. Suppose that there is only one endnote supertablelayout in one division
 509  * @return pointer to endnote supertable layout
 510  */
 511 rtl::Reference<LwpVirtualLayout> LwpHeadLayout::FindEnSuperTableLayout()
 512 {
 513     rtl::Reference<LwpVirtualLayout> xLayout(
 514         dynamic_cast<LwpVirtualLayout*>(GetChildHead().obj().get()));
 515     o3tl::sorted_vector<LwpVirtualLayout*> aSeen;
 516     while (xLayout)
 517     {
 518         bool bAlreadySeen = !aSeen.insert(xLayout.get()).second;
 519         if (bAlreadySeen)
 520             throw std::runtime_error("loop in conversion");
 521         if (xLayout->GetLayoutType() == LWP_ENDNOTE_SUPERTABLE_LAYOUT)
 522         {
 523             return xLayout;
 524         }
 525         xLayout.set(dynamic_cast<LwpVirtualLayout*>(xLayout->GetNext().obj().get()));
 526     }
 527     return rtl::Reference<LwpVirtualLayout>();
 528 }
 529
 530 LwpLayoutStyle::LwpLayoutStyle()
 531     : m_nStyleDefinition(0)
 532     , m_nKey(0)
 533 {
 534 }
 535
 536 LwpLayoutStyle::~LwpLayoutStyle() {}
 537
 538 void LwpLayoutStyle::Read(LwpObjectStream* pStrm)
 539 {
 540     m_nStyleDefinition = pStrm->QuickReaduInt32();
 541     m_aDescription.Read(pStrm);
 542     if (pStrm->CheckExtra())
 543     {
 544         m_nKey = pStrm->QuickReaduInt16();
 545         pStrm->SkipExtra();
 546     }
 547 }
 548
 549 LwpLayoutMisc::LwpLayoutMisc()
 550     : m_nGridDistance(0)
 551     , m_nGridType(0)
 552 {
 553 }
 554
 555 LwpLayoutMisc::~LwpLayoutMisc() {}
 556
 557 void LwpLayoutMisc::Read(LwpObjectStream* pStrm)
 558 {
 559     m_nGridType = pStrm->QuickReaduInt16();
 560     m_nGridDistance = pStrm->QuickReadInt32();
 561     m_aContentStyle.Read(pStrm);
 562     pStrm->SkipExtra();
 563 }
 564
 565 LwpMiddleLayout::LwpMiddleLayout(LwpObjectHeader const& objHdr, LwpSvStream* pStrm)
 566     : LwpVirtualLayout(objHdr, pStrm)
 567     , m_bGettingGeometry(false)
 568     , m_bGettingBackgroundStuff(false)
 569 {
 570 }
 571
 572 LwpMiddleLayout::~LwpMiddleLayout() {}
 573
 574 void LwpMiddleLayout::Read()
 575 {
 576     LwpObjectStream* pStrm = m_pObjStrm.get();
 577
 578     LwpVirtualLayout::Read();
 579
 580     //skip CLiteLayout data;
 581     LwpAtomHolder ContentClass;
 582     ContentClass.Read(pStrm);
 583     pStrm->SkipExtra();
 584
 585     // before layout hierarchy rework
 586     if (LwpFileHeader::m_nFileRevision < 0x000B)
 587         return;
 588
 589     m_Content.ReadIndexed(pStrm);
 590
 591     // 01/20/2005
 592     m_BasedOnStyle.ReadIndexed(pStrm);
 593     m_TabPiece.ReadIndexed(pStrm);
 594
 595     sal_uInt8 nWhatsItGot = pStrm->QuickReaduInt8();
 596
 597     if (nWhatsItGot & DISK_GOT_STYLE_STUFF)
 598     {
 599         m_aStyleStuff.Read(pStrm);
 600     }
 601     if (nWhatsItGot & DISK_GOT_MISC_STUFF)
 602     {
 603         m_aMiscStuff.Read(pStrm);
 604     }
 605
 606     m_LayGeometry.ReadIndexed(pStrm);
 607     m_LayScale.ReadIndexed(pStrm);
 608     m_LayMargins.ReadIndexed(pStrm);
 609     m_LayBorderStuff.ReadIndexed(pStrm);
 610     m_LayBackgroundStuff.ReadIndexed(pStrm);
 611
 612     if (pStrm->CheckExtra())
 613     {
 614         m_LayExtBorderStuff.ReadIndexed(pStrm);
 615         pStrm->SkipExtra();
 616     }
 617 }
 618
 619 rtl::Reference<LwpObject> LwpMiddleLayout::GetBasedOnStyle() const
 620 {
 621     rtl::Reference<LwpObject> xRet(m_BasedOnStyle.obj());
 622     if (xRet.get() == this)
 623     {
 624         SAL_WARN("lwp", "style based on itself");
 625         return rtl::Reference<LwpObject>();
 626     }
 627     return xRet;
 628 }
 629
 630 /**
 631 * @descr:   Get the geometry of current layout
 632 *
 633 */
 634 LwpLayoutGeometry* LwpMiddleLayout::GetGeometry()
 635 {
 636     if (m_bGettingGeometry)
 637         throw std::runtime_error("recursion in layout");
 638     m_bGettingGeometry = true;
 639
 640     LwpLayoutGeometry* pRet = nullptr;
 641     if (!m_LayGeometry.IsNull())
 642     {
 643         pRet = dynamic_cast<LwpLayoutGeometry*>(m_LayGeometry.obj().get());
 644     }
 645     else
 646     {
 647         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 648         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
 649         {
 650             pRet = pLay->GetGeometry();
 651         }
 652     }
 653
 654     m_bGettingGeometry = false;
 655     return pRet;
 656 }
 657
 658 /**
 659 * @descr:   Get layout height, measured by "cm"
 660 *
 661 */
 662 double LwpMiddleLayout::GetGeometryHeight()
 663 {
 664     LwpLayoutGeometry* pGeo = GetGeometry();
 665     if (pGeo)
 666     {
 667         return LwpTools::ConvertFromUnitsToMetric(pGeo->GetHeight());
 668     }
 669     else
 670         return -1;
 671 }
 672
 673 /**
 674 * @descr:   Get layout width, measured by "cm"
 675 *
 676 */
 677 double LwpMiddleLayout::GetGeometryWidth()
 678 {
 679     LwpLayoutGeometry* pGeo = GetGeometry();
 680     if (pGeo)
 681     {
 682         return LwpTools::ConvertFromUnitsToMetric(pGeo->GetWidth());
 683     }
 684     else
 685         return -1;
 686 }
 687
 688 /**
 689 * @descr:   Whether the margins is same as parent layout
 690 *
 691 */
 692 bool LwpMiddleLayout::MarginsSameAsParent()
 693 {
 694     if (m_nOverrideFlag & OVER_MARGINS)
 695     {
 696         return LwpVirtualLayout::MarginsSameAsParent();
 697     }
 698     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 699     if (LwpVirtualLayout* pLay = dynamic_cast<LwpVirtualLayout*>(xBase.get()))
 700     {
 701         pLay->GetMarginsSameAsParent();
 702     }
 703     return LwpVirtualLayout::MarginsSameAsParent();
 704 }
 705
 706 /**
 707 * @descr:   Get margin
 708 * @param:   nWhichSide - 0: left, 1: right, 2:top, 3: bottom
 709 */
 710 double LwpMiddleLayout::MarginsValue(sal_uInt8 nWhichSide)
 711 {
 712     double fValue = 0;
 713     if ((nWhichSide == MARGIN_LEFT) || (nWhichSide == MARGIN_RIGHT))
 714     {
 715         if (GetMarginsSameAsParent())
 716         {
 717             rtl::Reference<LwpVirtualLayout> xParent(
 718                 dynamic_cast<LwpVirtualLayout*>(GetParent().obj().get()));
 719             if (xParent.is() && !xParent->IsHeader())
 720             {
 721                 fValue = xParent->GetMarginsValue(nWhichSide);
 722                 return fValue;
 723             }
 724         }
 725     }
 726
 727     if (m_nOverrideFlag & OVER_MARGINS)
 728     {
 729         LwpLayoutMargins* pMar1 = dynamic_cast<LwpLayoutMargins*>(m_LayMargins.obj().get());
 730         if (pMar1)
 731         {
 732             fValue = pMar1->GetMargins().GetMarginsValue(nWhichSide);
 733             return fValue;
 734         }
 735     }
 736     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 737     LwpVirtualLayout* pStyle = dynamic_cast<LwpVirtualLayout*>(xBase.get());
 738     if (pStyle)
 739     {
 740         fValue = pStyle->GetMarginsValue(nWhichSide);
 741         return fValue;
 742     }
 743     return LwpVirtualLayout::MarginsValue(nWhichSide);
 744 }
 745 /**
 746  * @descr:  Get extmargin value
 747  * @param:  nWhichSide - 0: left, 1: right, 2:top, 3: bottom
 748  * @param:
 749  * @return:
 750 */
 751 double LwpMiddleLayout::ExtMarginsValue(sal_uInt8 nWhichSide)
 752 {
 753     double fValue = 0;
 754     if (m_nOverrideFlag & OVER_MARGINS)
 755     {
 756         LwpLayoutMargins* pMar1 = dynamic_cast<LwpLayoutMargins*>(m_LayMargins.obj().get());
 757         if (pMar1)
 758         {
 759             fValue = pMar1->GetExtMargins().GetMarginsValue(nWhichSide);
 760             return fValue;
 761         }
 762     }
 763     LwpVirtualLayout* pStyle = dynamic_cast<LwpVirtualLayout*>(GetBasedOnStyle().get());
 764     if (pStyle)
 765     {
 766         fValue = pStyle->GetExtMarginsValue(nWhichSide);
 767         return fValue;
 768     }
 769     return LwpVirtualLayout::ExtMarginsValue(nWhichSide);
 770 }
 771 /**
 772  * @descr:  Get the LwpBorderStuff object according to m_LayBorderStuff id.
 773 */
 774 LwpBorderStuff* LwpMiddleLayout::GetBorderStuff()
 775 {
 776     if (m_bGettingBorderStuff)
 777         throw std::runtime_error("recursion in layout");
 778     m_bGettingBorderStuff = true;
 779
 780     LwpBorderStuff* pRet = nullptr;
 781
 782     if (m_nOverrideFlag & OVER_BORDERS)
 783     {
 784         LwpLayoutBorder* pLayoutBorder
 785             = dynamic_cast<LwpLayoutBorder*>(m_LayBorderStuff.obj().get());
 786         pRet = pLayoutBorder ? &pLayoutBorder->GetBorderStuff() : nullptr;
 787     }
 788     else
 789     {
 790         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 791         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
 792         {
 793             pRet = pLay->GetBorderStuff();
 794         }
 795     }
 796
 797     m_bGettingBorderStuff = false;
 798     return pRet;
 799 }
 800
 801 /**
 802  * @descr:  Get LwpBackgroundStuff object according to m_LayBackgroundStuff id;
 803 */
 804 LwpBackgroundStuff* LwpMiddleLayout::GetBackgroundStuff()
 805 {
 806     if (m_bGettingBackgroundStuff)
 807         throw std::runtime_error("recursion in layout");
 808     m_bGettingBackgroundStuff = true;
 809
 810     LwpBackgroundStuff* pRet = nullptr;
 811
 812     if (m_nOverrideFlag & OVER_BACKGROUND)
 813     {
 814         LwpLayoutBackground* pLayoutBackground
 815             = dynamic_cast<LwpLayoutBackground*>(m_LayBackgroundStuff.obj().get());
 816         pRet = pLayoutBackground ? &pLayoutBackground->GetBackgoudStuff() : nullptr;
 817     }
 818     else
 819     {
 820         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 821         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
 822         {
 823             pRet = pLay->GetBackgroundStuff();
 824         }
 825     }
 826
 827     m_bGettingBackgroundStuff = false;
 828     return pRet;
 829 }
 830
 831 /**
 832  * @descr:  create xfborder.
 833 */
 834 std::unique_ptr<XFBorders> LwpMiddleLayout::GetXFBorders()
 835 {
 836     LwpBorderStuff* pBorderStuff = GetBorderStuff();
 837     if (pBorderStuff && pBorderStuff->GetSide() != 0)
 838     {
 839         //copy from lwpparastyle.
 840         std::unique_ptr<XFBorders> xXFBorders(new XFBorders);
 841         // apply 4 borders respectively
 842         LwpBorderStuff::BorderType const pType[] = { LwpBorderStuff::LEFT, LwpBorderStuff::RIGHT,
 843                                                      LwpBorderStuff::TOP, LwpBorderStuff::BOTTOM };
 844
 845         for (LwpBorderStuff::BorderType nC : pType)
 846         {
 847             if (pBorderStuff->HasSide(nC))
 848             {
 849                 LwpParaStyle::ApplySubBorder(pBorderStuff, nC, xXFBorders.get());
 850             }
 851         }
 852         return xXFBorders;
 853     }
 854     return nullptr;
 855 }
 856
 857 /**
 858  * @descr:  Get text direction settings.
 859 */
 860 enumXFTextDir LwpMiddleLayout::GetTextDirection()
 861 {
 862     enumXFTextDir eTextDir = enumXFTextDirNone;
 863     sal_uInt8 nDirection = GetContentOrientation();
 864     switch (nDirection)
 865     {
 866         case TEXT_ORIENT_LRTB:
 867         {
 868             eTextDir = enumXFTextDirLR_TB;
 869             break;
 870         }
 871         case TEXT_ORIENT_TBRL:
 872         {
 873             eTextDir = enumXFTextDirTB_RL;
 874             break;
 875         }
 876         case TEXT_ORIENT_RLBT: // not supported now
 877         {
 878             eTextDir = enumXFTextDirNone;
 879             break;
 880         }
 881         case TEXT_ORIENT_BTLR: // not supported now
 882         {
 883             eTextDir = enumXFTextDirNone;
 884             break;
 885         }
 886         default:
 887             break;
 888     }
 889     return eTextDir;
 890 }
 891 /**
 892  * @descr: Get background color.
 893 */
 894 LwpColor* LwpMiddleLayout::GetBackColor()
 895 {
 896     LwpBackgroundStuff* pBackgroundStuff = GetBackgroundStuff();
 897     if (pBackgroundStuff && !pBackgroundStuff->IsTransparent())
 898     {
 899         LwpColor* pColor = pBackgroundStuff->GetFillColor();
 900         if (pColor->IsValidColor())
 901         {
 902             return pColor;
 903         }
 904     }
 905     return nullptr;
 906 }
 907
 908 /**
 909  * @descr:  Add back color settings into xfpagemaster.
 910 */
 911 LwpTabOverride* LwpMiddleLayout::GetTabOverride()
 912 {
 913     if (m_nAttributes & OVER_TABS)
 914     {
 915         if (!m_TabPiece.IsNull())
 916         {
 917             LwpTabPiece* pPiece = dynamic_cast<LwpTabPiece*>(m_TabPiece.obj().get());
 918             return static_cast<LwpTabOverride*>(pPiece ? pPiece->GetOverride() : nullptr);
 919         }
 920         return nullptr;
 921     }
 922     else
 923     {
 924         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 925         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
 926         {
 927             return pLay->GetTabOverride();
 928         }
 929     }
 930     return nullptr;
 931 }
 932
 933 /**
 934  * @descr:   Layscale for graphic & watermark
 935 */
 936 sal_uInt16 LwpMiddleLayout::GetScaleMode()
 937 {
 938     if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj().is() && GetLayoutScale())
 939         return GetLayoutScale()->GetScaleMode();
 940     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 941     if (xBase.is())
 942         return dynamic_cast<LwpMiddleLayout&>(*xBase).GetScaleMode();
 943     else
 944         return (LwpLayoutScale::FIT_IN_FRAME | LwpLayoutScale::MAINTAIN_ASPECT_RATIO);
 945 }
 946
 947 sal_uInt16 LwpMiddleLayout::GetScaleTile()
 948 {
 949     if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj().is() && GetLayoutScale())
 950         return (GetLayoutScale()->GetPlacement() & LwpLayoutScale::TILED) ? 1 : 0;
 951     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 952     if (xBase.is())
 953         return dynamic_cast<LwpMiddleLayout&>(*xBase).GetScaleTile();
 954     else
 955         return 0;
 956 }
 957
 958 sal_uInt16 LwpMiddleLayout::GetScaleCenter()
 959 {
 960     if (m_bGettingScaleCenter)
 961         throw std::runtime_error("recursion in layout");
 962     m_bGettingScaleCenter = true;
 963
 964     sal_uInt16 nRet = 0;
 965
 966     if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj().is() && GetLayoutScale())
 967     {
 968         nRet = (GetLayoutScale()->GetPlacement() & LwpLayoutScale::CENTERED) ? 1 : 0;
 969     }
 970     else
 971     {
 972         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
 973         if (xBase.is())
 974             nRet = dynamic_cast<LwpMiddleLayout&>(*xBase).GetScaleCenter();
 975     }
 976
 977     m_bGettingScaleCenter = false;
 978     return nRet;
 979 }
 980
 981 bool LwpMiddleLayout::CanSizeRight()
 982 {
 983     sal_uInt8 RelType = GetRelativeType();
 984
 985     return !(RelType == LwpLayoutRelativityGuts::LAY_INLINE
 986              || RelType == LwpLayoutRelativityGuts::LAY_PARA_RELATIVE
 987              || RelType == LwpLayoutRelativityGuts::LAY_INLINE_VERTICAL);
 988 }
 989 sal_Int32 LwpMiddleLayout::GetMinimumWidth()
 990 {
 991     if (((m_nAttributes3 & STYLE3_WIDTHVALID) != 0) && GetGeometry())
 992     {
 993         return GetGeometry()->GetWidth();
 994     }
 995     else if (m_nOverrideFlag & OVER_SIZE)
 996     {
 997         return DetermineWidth();
 998     }
 999     return 0;
1000 }
1001 sal_Int32 LwpMiddleLayout::DetermineWidth()
1002 {
1003     if (IsSizeRightToContent())
1004     {
1005         assert(false);
1006     }
1007     else if (IsSizeRightToContainer())
1008     {
1009         assert(false);
1010     }
1011     else if (LwpLayoutGeometry* pGeo = GetGeometry())
1012     {
1013         m_nAttributes3 |= STYLE3_WIDTHVALID;
1014         return pGeo->GetWidth();
1015     }
1016     return 0;
1017 }
1018 bool LwpMiddleLayout::IsSizeRightToContainer()
1019 {
1020     if (!CanSizeRight())
1021         return false;
1022
1023     if (m_nOverrideFlag & OVER_SIZE)
1024     {
1025         return (m_nDirection & ((LAY_USEDIRECTION | LAY_AUTOSIZE | LAY_TOCONTAINER) << SHIFT_RIGHT))
1026                == ((LAY_USEDIRECTION | LAY_TOCONTAINER | LAY_AUTOSIZE) << SHIFT_RIGHT);
1027     }
1028     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1029     if (xBase.is())
1030     {
1031         LwpMiddleLayout* pLayout = dynamic_cast<LwpMiddleLayout*>(xBase.get());
1032         return pLayout && pLayout->IsSizeRightToContainer();
1033     }
1034     else
1035         return false;
1036 }
1037 bool LwpMiddleLayout::IsSizeRightToContent()
1038 {
1039     if (!CanSizeRight())
1040         return false;
1041
1042     if (m_nOverrideFlag & OVER_SIZE)
1043     {
1044         return (m_nDirection & ((LAY_USEDIRECTION | LAY_AUTOSIZE | LAY_TOCONTAINER) << SHIFT_RIGHT))
1045                == ((LAY_USEDIRECTION | LAY_AUTOSIZE) << SHIFT_RIGHT);
1046     }
1047     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1048     if (xBase.is())
1049     {
1050         LwpMiddleLayout* pLayout = dynamic_cast<LwpMiddleLayout*>(xBase.get());
1051         return pLayout && pLayout->IsSizeRightToContent();
1052     }
1053     else
1054         return false;
1055 }
1056
1057 /**
1058 * @descr:   Get layout height
1059 *
1060 */
1061 double LwpMiddleLayout::GetHeight() { return GetGeometryHeight(); }
1062
1063 /**
1064 * @descr:   Get layout height
1065 *
1066 */
1067 double LwpMiddleLayout::GetWidth() { return GetGeometryWidth(); }
1068 /**
1069 * @descr:   Get layout origin point
1070 *
1071 */
1072 LwpPoint LwpMiddleLayout::GetOrigin()
1073 {
1074     LwpLayoutGeometry* pGeo = GetGeometry();
1075     if (pGeo)
1076     {
1077         sal_uInt8 nType = GetRelativeType();
1078         if (nType == LwpLayoutRelativityGuts::LAY_INLINE
1079             || nType == LwpLayoutRelativityGuts::LAY_INLINE_NEWLINE)
1080         {
1081             return pGeo->GetAbsoluteOrigin();
1082         }
1083         else
1084             return pGeo->GetOrigin();
1085     }
1086
1087     return LwpPoint();
1088 }
1089
1090 /**
1091 * @descr:   Whether the fill is pattern fill or not
1092 * @return:  True if yes, false if not.
1093 */
1094 bool LwpMiddleLayout::IsPatternFill()
1095 {
1096     LwpBackgroundStuff* pBackgroundStuff = GetBackgroundStuff();
1097     if (pBackgroundStuff)
1098     {
1099         return pBackgroundStuff->IsPatternFill();
1100     }
1101
1102     return false;
1103 }
1104
1105 /**
1106 * @descr:   Get the fill pattern style. Data are saved in a XFBGImage object
1107 * @return:  the fill pattern style.
1108 */
1109 std::unique_ptr<XFBGImage> LwpMiddleLayout::GetFillPattern()
1110 {
1111     LwpBackgroundStuff* pBackgroundStuff = GetBackgroundStuff();
1112     if (pBackgroundStuff)
1113     {
1114         return pBackgroundStuff->GetFillPattern();
1115     }
1116
1117     return std::unique_ptr<XFBGImage>();
1118 }
1119
1120 /**
1121 * @descr:   Whether the height and width of layout is auto grow
1122 *
1123 */
1124 bool LwpMiddleLayout::IsAutoGrow()
1125 {
1126     if (m_nOverrideFlag & OVER_SIZE)
1127     {
1128         return (m_nDirection
1129                 & ((LAY_AUTOGROW << SHIFT_UP) | (LAY_AUTOGROW << SHIFT_DOWN)
1130                    | (LAY_AUTOGROW << SHIFT_RIGHT) | (LAY_AUTOGROW << SHIFT_LEFT)))
1131                != 0;
1132     }
1133     else
1134     {
1135         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1136         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1137         {
1138             return pLay->IsAutoGrow();
1139         }
1140     }
1141     return LwpVirtualLayout::IsAutoGrow();
1142 }
1143
1144 /**
1145 * @descr:   Whether the height of layout is auto grow down
1146 *
1147 */
1148 bool LwpMiddleLayout::IsAutoGrowDown()
1149 {
1150     if (m_nOverrideFlag & OVER_SIZE)
1151     {
1152         return (m_nDirection & (LAY_AUTOGROW << SHIFT_DOWN)) != 0;
1153     }
1154     else
1155     {
1156         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1157         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1158         {
1159             return pLay->GetIsAutoGrowDown();
1160         }
1161     }
1162     return LwpVirtualLayout::IsAutoGrowDown();
1163 }
1164
1165 /**
1166 * @descr:   Whether the height of layout is auto grow up
1167 *
1168 */
1169 bool LwpMiddleLayout::IsAutoGrowUp()
1170 {
1171     if (m_bGettingAutoGrowUp)
1172         throw std::runtime_error("recursion in layout");
1173     m_bGettingAutoGrowUp = true;
1174
1175     bool bRet;
1176
1177     if (m_nOverrideFlag & OVER_SIZE)
1178     {
1179         bRet = (m_nDirection & (LAY_AUTOGROW << SHIFT_UP)) != 0;
1180     }
1181     else
1182     {
1183         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1184         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1185             bRet = pLay->IsAutoGrowUp();
1186         else
1187             bRet = LwpVirtualLayout::IsAutoGrowUp();
1188     }
1189
1190     m_bGettingAutoGrowUp = false;
1191     return bRet;
1192 }
1193
1194 /**
1195 * @descr:   Whether the height of layout is auto grow down
1196 *
1197 */
1198 bool LwpMiddleLayout::IsAutoGrowLeft()
1199 {
1200     if (m_nOverrideFlag & OVER_SIZE)
1201     {
1202         return (m_nDirection & (LAY_AUTOGROW << SHIFT_LEFT)) != 0;
1203     }
1204     else
1205     {
1206         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1207         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1208         {
1209             return pLay->IsAutoGrowLeft();
1210         }
1211     }
1212     return LwpVirtualLayout::IsAutoGrowLeft();
1213 }
1214
1215 /**
1216 * @descr:   Whether the height of layout is auto grow down
1217 *
1218 */
1219 bool LwpMiddleLayout::IsAutoGrowRight()
1220 {
1221     if (m_nOverrideFlag & OVER_SIZE)
1222     {
1223         return (m_nDirection & (LAY_AUTOGROW << SHIFT_RIGHT)) != 0;
1224     }
1225     else
1226     {
1227         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1228         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1229         {
1230             return pLay->IsAutoGrowRight();
1231         }
1232     }
1233     return LwpVirtualLayout::IsAutoGrowRight();
1234 }
1235
1236 /**
1237 * @descr:   Get contents orientation
1238 *
1239 */
1240 sal_uInt8 LwpMiddleLayout::GetContentOrientation()
1241 {
1242     //content orientation in Graphic objects and OLE objects not supported now
1243     if ((m_nOverrideFlag & OVER_ROTATION) && !m_LayGeometry.IsNull())
1244     {
1245         LwpLayoutGeometry* pLayGeometry
1246             = dynamic_cast<LwpLayoutGeometry*>(m_LayGeometry.obj().get());
1247         if (pLayGeometry)
1248             return pLayGeometry->GetContentOrientation();
1249     }
1250     else
1251     {
1252         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1253         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1254         {
1255             return pLay->GetContentOrientation();
1256         }
1257     }
1258     return LwpVirtualLayout::GetContentOrientation();
1259 }
1260
1261 /**
1262 * @descr:   Whether it is honoring protection
1263 *
1264 */
1265 bool LwpMiddleLayout::HonorProtection()
1266 {
1267     if (m_nOverrideFlag & OVER_MISC)
1268     {
1269         if (!(m_nAttributes2 & STYLE2_HONORPROTECTION))
1270             return false;
1271
1272         rtl::Reference<LwpVirtualLayout> xParent(
1273             dynamic_cast<LwpVirtualLayout*>(GetParent().obj().get()));
1274         if (xParent.is() && !xParent->IsHeader())
1275         {
1276             return xParent->GetHonorProtection();
1277         }
1278
1279         if (m_pFoundry) //is null now
1280         {
1281             LwpDocument* pDoc = m_pFoundry->GetDocument();
1282             if (pDoc)
1283             {
1284                 return pDoc->GetHonorProtection();
1285             }
1286         }
1287     }
1288     else
1289     {
1290         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1291         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1292         {
1293             return pLay->GetHonorProtection();
1294         }
1295     }
1296
1297     return LwpVirtualLayout::HonorProtection();
1298 }
1299
1300 /**
1301 * @descr:   Whether it is protected
1302 *
1303 */
1304 bool LwpMiddleLayout::IsProtected()
1305 {
1306     bool bProtected = false;
1307     if (m_nOverrideFlag & OVER_MISC)
1308     {
1309         bProtected = (m_nAttributes & STYLE_PROTECTED) != 0;
1310     }
1311     else
1312     {
1313         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1314         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1315         {
1316             bProtected = pLay->GetIsProtected();
1317         }
1318         else
1319             bProtected = LwpVirtualLayout::IsProtected();
1320     }
1321
1322     rtl::Reference<LwpVirtualLayout> xParent(
1323         dynamic_cast<LwpVirtualLayout*>(GetParent().obj().get()));
1324     if (xParent.is() && !xParent->IsHeader())
1325     {
1326         /* If a parent's protected then none of its children can be accessed. */
1327         if (xParent->GetIsProtected())
1328             return true;
1329
1330         if (xParent->GetHonorProtection())
1331             return bProtected;
1332
1333         /* If our parent isn't honoring protection then we aren't protected. */
1334         return false;
1335     }
1336     if (m_pFoundry) //is null now
1337     {
1338         LwpDocument* pDoc = m_pFoundry->GetDocument();
1339         if (pDoc)
1340         {
1341             if (pDoc->GetHonorProtection())
1342                 return bProtected;
1343
1344             /* If the document isn't honoring protection then we aren't protected.*/
1345             return false;
1346         }
1347     }
1348
1349     return bProtected;
1350 }
1351
1352 /**
1353 * @descr:   Get watermark layout
1354 *
1355 */
1356 rtl::Reference<LwpVirtualLayout> LwpMiddleLayout::GetWaterMarkLayout()
1357 {
1358     rtl::Reference<LwpVirtualLayout> xLay(
1359         dynamic_cast<LwpVirtualLayout*>(GetChildHead().obj().get()));
1360     o3tl::sorted_vector<LwpVirtualLayout*> aSeen;
1361     while (xLay.is())
1362     {
1363         bool bAlreadySeen = !aSeen.insert(xLay.get()).second;
1364         if (bAlreadySeen)
1365             throw std::runtime_error("loop in conversion");
1366         if (xLay->IsForWaterMark())
1367         {
1368             return xLay;
1369         }
1370         rtl::Reference<LwpVirtualLayout> xNext(
1371             dynamic_cast<LwpVirtualLayout*>(xLay->GetNext().obj().get()));
1372         xLay = xNext;
1373     }
1374     return rtl::Reference<LwpVirtualLayout>();
1375 }
1376
1377 /**
1378 * @descr:   Create and return xfbgimage object for watermark
1379 *
1380 */
1381 std::unique_ptr<XFBGImage> LwpMiddleLayout::GetXFBGImage()
1382 {
1383     std::unique_ptr<XFBGImage> xXFBGImage;
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             xXFBGImage.reset(new XFBGImage);
1394             if (pGrfObj->IsLinked())
1395             {
1396                 //set file link
1397                 OUString linkedfilepath = pGrfObj->GetLinkedFilePath();
1398                 OUString fileURL = LwpTools::convertToFileUrl(
1399                     OUStringToOString(linkedfilepath, osl_getThreadTextEncoding()));
1400                 xXFBGImage->SetFileLink(fileURL);
1401             }
1402             else
1403             {
1404                 std::vector<sal_uInt8> aGrafData = pGrfObj->GetRawGrafData();
1405                 xXFBGImage->SetImageData(aGrafData.data(), aGrafData.size());
1406             }
1407
1408             //automatic, top left
1409             xXFBGImage->SetPosition(enumXFAlignStart, enumXFAlignTop);
1410             if (pLay->GetScaleCenter())
1411             {
1412                 //center
1413                 xXFBGImage->SetPosition();
1414             }
1415             else if (pLay->GetScaleTile())
1416             {
1417                 //tile
1418                 xXFBGImage->SetRepeate();
1419             }
1420             //fit type, area type
1421             if ((pLay->GetScaleMode() & LwpLayoutScale::FIT_IN_FRAME) != 0)
1422             {
1423                 if ((pLay->GetScaleMode() & LwpLayoutScale::MAINTAIN_ASPECT_RATIO) == 0)
1424                 {
1425                     xXFBGImage->SetStretch();
1426                 }
1427             }
1428         }
1429     }
1430     return xXFBGImage;
1431 }
1432
1433 /**
1434 * @descr:   Whether the page uses the printer setting
1435 *
1436 */
1437 bool LwpMiddleLayout::GetUsePrinterSettings()
1438 {
1439     if (m_bGettingUsePrinterSettings)
1440         throw std::runtime_error("recursion in layout");
1441     m_bGettingUsePrinterSettings = true;
1442
1443     bool bRet = false;
1444
1445     if (m_nOverrideFlag & OVER_SIZE)
1446     {
1447         bRet = (m_nAttributes3 & STYLE3_USEPRINTERSETTINGS) != 0;
1448     }
1449     else
1450     {
1451         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1452         if (LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xBase.get()))
1453         {
1454             bRet = pLay->GetUsePrinterSettings();
1455         }
1456     }
1457
1458     m_bGettingUsePrinterSettings = false;
1459     return bRet;
1460 }
1461
1462 //Check whether there are contents in the layout
1463 bool LwpMiddleLayout::HasContent()
1464 {
1465     rtl::Reference<LwpObject> content = m_Content.obj();
1466     return content.is();
1467 }
1468
1469 LwpLayout::LwpLayout(LwpObjectHeader const& objHdr, LwpSvStream* pStrm)
1470     : LwpMiddleLayout(objHdr, pStrm)
1471     , m_bGettingShadow(false)
1472     , m_bGettingNumCols(false)
1473 {
1474 }
1475
1476 LwpLayout::~LwpLayout() {}
1477
1478 void LwpLayout::Read()
1479 {
1480     LwpObjectStream* pStrm = m_pObjStrm.get();
1481
1482     LwpMiddleLayout::Read();
1483     if (LwpFileHeader::m_nFileRevision < 0x000B)
1484     {
1485         // read PreRevBLayout...
1486     }
1487     else
1488     {
1489         sal_uInt16 nSimple = pStrm->QuickReaduInt16();
1490
1491         if (!nSimple)
1492         {
1493             m_aUseWhen.Read(pStrm);
1494
1495             sal_uInt8 nFlag = pStrm->QuickReaduInt8();
1496             if (nFlag)
1497                 m_Position.ReadIndexed(pStrm);
1498         }
1499
1500         m_LayColumns.ReadIndexed(pStrm);
1501         m_LayGutterStuff.ReadIndexed(pStrm);
1502         m_LayJoinStuff.ReadIndexed(pStrm);
1503         m_LayShadow.ReadIndexed(pStrm);
1504
1505         if (pStrm->CheckExtra())
1506         {
1507             m_LayExtJoinStuff.ReadIndexed(pStrm);
1508             pStrm->SkipExtra();
1509         }
1510     }
1511 }
1512
1513 /**
1514 * @descr:   Get columns number
1515 *
1516 */
1517 sal_uInt16 LwpLayout::GetNumCols()
1518 {
1519     if (m_bGettingNumCols)
1520         throw std::runtime_error("recursion in layout");
1521     m_bGettingNumCols = true;
1522
1523     sal_uInt16 nRet = 0;
1524     LwpLayoutColumns* pLayColumns = (m_nOverrideFlag & OVER_COLUMNS)
1525                                         ? dynamic_cast<LwpLayoutColumns*>(m_LayColumns.obj().get())
1526                                         : nullptr;
1527     if (pLayColumns)
1528     {
1529         nRet = pLayColumns->GetNumCols();
1530     }
1531     else
1532     {
1533         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1534         LwpVirtualLayout* pStyle = dynamic_cast<LwpVirtualLayout*>(xBase.get());
1535         nRet = pStyle ? pStyle->GetNumCols() : LwpVirtualLayout::GetNumCols();
1536     }
1537     m_bGettingNumCols = false;
1538     return nRet;
1539 }
1540
1541 /**
1542 * @descr:   Get gap between columns
1543 * @param:   the order of column
1544 */
1545 double LwpLayout::GetColGap(sal_uInt16 nIndex)
1546 {
1547     if ((m_nOverrideFlag & OVER_COLUMNS) || (m_nAttributes2 & STYLE2_LOCALCOLUMNINFO))
1548     {
1549         LwpLayoutColumns* pLayColumns = dynamic_cast<LwpLayoutColumns*>(m_LayColumns.obj().get());
1550         if (pLayColumns)
1551         {
1552             return pLayColumns->GetColGap(nIndex);
1553         }
1554     }
1555
1556     rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1557     LwpVirtualLayout* pStyle = dynamic_cast<LwpVirtualLayout*>(xBase.get());
1558     if (pStyle)
1559     {
1560         return pStyle->GetColGap(nIndex);
1561     }
1562
1563     return LwpVirtualLayout::GetColGap(nIndex);
1564 }
1565
1566 /**
1567 * @descr:   Create and return XFColumns object
1568 *
1569 */
1570 XFColumns* LwpLayout::GetXFColumns()
1571 {
1572     //if there is only one column, do not need insert columns
1573     sal_uInt16 nCols = GetNumCols();
1574     if (nCols == 1)
1575     {
1576         return nullptr;
1577     }
1578
1579     std::unique_ptr<XFColumns> xColumns(new XFColumns);
1580     //set XFColumnSep
1581     std::unique_ptr<XFColumnSep> xColumnSep(GetColumnSep());
1582     if (xColumnSep)
1583     {
1584         xColumns->SetSeparator(*xColumnSep);
1585     }
1586
1587     //set column count and column gap
1588     xColumns->SetCount(nCols);
1589     double fGap = GetColGap(0);
1590     xColumns->SetGap(fGap);
1591
1592     //set xfcolumn
1593     for (sal_uInt16 nIndex = 0; nIndex < nCols; nIndex++)
1594     {
1595         XFColumn aColumn;
1596         sal_Int32 nWidth = 8305 / nCols; //relative width
1597         aColumn.SetRelWidth(nWidth);
1598
1599         //the left and right margins is 0;
1600         double nGap = GetColGap(nIndex) / 2;
1601         aColumn.SetMargins(nGap, nGap);
1602         if (nIndex == 0)
1603         {
1604             aColumn.SetMargins(0, nGap);
1605         }
1606         if (nIndex == (nCols - 1))
1607         {
1608             aColumn.SetMargins(nGap, 0);
1609         }
1610         xColumns->AddColumn(aColumn);
1611     }
1612
1613     return xColumns.release();
1614 }
1615
1616 /**
1617 * @descr:   Create and return XFColumnSep object
1618 *
1619 */
1620 XFColumnSep* LwpLayout::GetColumnSep()
1621 {
1622     //Get LwpLayoutGutters
1623     LwpLayoutGutters* pLayoutGutters
1624         = dynamic_cast<LwpLayoutGutters*>(m_LayGutterStuff.obj().get());
1625     if (!pLayoutGutters)
1626     {
1627         return nullptr;
1628     }
1629
1630     LwpBorderStuff& rBorderStuff = pLayoutGutters->GetBorderStuff();
1631
1632     LwpBorderStuff::BorderType eType = LwpBorderStuff::LEFT;
1633     LwpColor aColor = rBorderStuff.GetSideColor(eType);
1634     double fWidth = rBorderStuff.GetSideWidth(eType);
1635     //sal_uInt16    nType = rBorderStuff->GetSideType(eType);
1636
1637     XFColumnSep* pColumnSep = new XFColumnSep();
1638     XFColor aXFColor(aColor.To24Color());
1639     pColumnSep->SetColor(aXFColor);
1640     pColumnSep->SetWidth(fWidth);
1641     pColumnSep->SetRelHeight(100);
1642     pColumnSep->SetVerticalAlign(enumXFAlignTop);
1643
1644     return pColumnSep;
1645 }
1646
1647 /**
1648 * @descr:   Get use when type
1649 *
1650 */
1651 LwpLayout::UseWhenType LwpLayout::GetUseWhenType()
1652 {
1653     UseWhenType eType = StartWithinPage;
1654     LwpUseWhen* pUseWhen = GetUseWhen();
1655     if (pUseWhen)
1656     {
1657         if (pUseWhen->IsStartOnThisHF())
1658         {
1659             eType = StartWithinColume;
1660         }
1661         else if (pUseWhen->IsStartOnThisPage())
1662         {
1663             eType = StartWithinPage;
1664         }
1665         else if (pUseWhen->IsStartOnNextPage())
1666         {
1667             eType = StartOnNextPage;
1668         }
1669         else if (pUseWhen->IsStartOnNextOddPage())
1670         {
1671             eType = StartOnOddPage;
1672         }
1673         else if (pUseWhen->IsStartOnNextEvenPage())
1674         {
1675             eType = StartOnEvenPage;
1676         }
1677     }
1678     else
1679     {
1680         eType = StartOnNextPage;
1681     }
1682     return eType;
1683 }
1684
1685 /**
1686 * @descr:   Get use page
1687 *
1688 */
1689 sal_uInt16 LwpLayout::GetUsePage()
1690 {
1691     if (m_nOverrideFlag & OVER_PLACEMENT)
1692     {
1693         LwpUseWhen* pUseWhen = GetUseWhen();
1694         if (pUseWhen)
1695             return pUseWhen->GetUsePage();
1696         else
1697             return 0;
1698     }
1699     else
1700     {
1701         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1702         if (LwpLayout* pLay = dynamic_cast<LwpLayout*>(xBase.get()))
1703         {
1704             return pLay->GetUsePage();
1705         }
1706     }
1707     return 0;
1708 }
1709
1710 /**
1711 * @descr:   Get usewhen pointer
1712 *
1713 */
1714 LwpUseWhen* LwpLayout::VirtualGetUseWhen()
1715 {
1716     if (m_nOverrideFlag & OVER_PLACEMENT)
1717     {
1718         return &m_aUseWhen;
1719     }
1720     else
1721     {
1722         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1723         if (LwpLayout* pLay = dynamic_cast<LwpLayout*>(xBase.get()))
1724         {
1725             return pLay->VirtualGetUseWhen();
1726         }
1727     }
1728     return LwpVirtualLayout::VirtualGetUseWhen();
1729 }
1730
1731 /**
1732 * @descr:   Whether it is use on all pages
1733 *
1734 */
1735 bool LwpLayout::IsUseOnAllPages()
1736 {
1737     if (m_nOverrideFlag & OVER_PLACEMENT)
1738     {
1739         LwpUseWhen* pUseWhen = GetUseWhen();
1740         if (pUseWhen)
1741             return pUseWhen->IsUseOnAllPages();
1742         else
1743             return false;
1744     }
1745     else
1746     {
1747         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1748         if (LwpLayout* pLay = dynamic_cast<LwpLayout*>(xBase.get()))
1749         {
1750             return pLay->IsUseOnAllPages();
1751         }
1752     }
1753     return LwpVirtualLayout::IsUseOnAllPages();
1754 }
1755
1756 /**
1757 * @descr:   Whether it is use on all even pages
1758 *
1759 */
1760 bool LwpLayout::IsUseOnAllEvenPages()
1761 {
1762     if (m_nOverrideFlag & OVER_PLACEMENT)
1763     {
1764         LwpUseWhen* pUseWhen = GetUseWhen();
1765         if (pUseWhen)
1766             return pUseWhen->IsUseOnAllEvenPages();
1767         else
1768             return false;
1769     }
1770     else
1771     {
1772         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1773         if (LwpLayout* pLay = dynamic_cast<LwpLayout*>(xBase.get()))
1774         {
1775             return pLay->IsUseOnAllEvenPages();
1776         }
1777     }
1778     return LwpVirtualLayout::IsUseOnAllEvenPages();
1779 }
1780
1781 /**
1782 * @descr:   Whether it is use on all odd pages
1783 *
1784 */
1785 bool LwpLayout::IsUseOnAllOddPages()
1786 {
1787     if (m_nOverrideFlag & OVER_PLACEMENT)
1788     {
1789         LwpUseWhen* pUseWhen = GetUseWhen();
1790         if (pUseWhen)
1791             return pUseWhen->IsUseOnAllOddPages();
1792         else
1793             return false;
1794     }
1795     else
1796     {
1797         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1798         if (LwpLayout* pLay = dynamic_cast<LwpLayout*>(xBase.get()))
1799         {
1800             return pLay->IsUseOnAllOddPages();
1801         }
1802     }
1803     return LwpVirtualLayout::IsUseOnAllOddPages();
1804 }
1805
1806 /**
1807 * @descr:   Whether it is use on current page
1808 *
1809 */
1810 bool LwpLayout::IsUseOnPage()
1811 {
1812     if (m_nOverrideFlag & OVER_PLACEMENT)
1813     {
1814         LwpUseWhen* pUseWhen = GetUseWhen();
1815         if (pUseWhen)
1816             return pUseWhen->IsUseOnPage();
1817         else
1818             return false;
1819     }
1820     else
1821     {
1822         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1823         if (LwpLayout* pLay = dynamic_cast<LwpLayout*>(xBase.get()))
1824         {
1825             return pLay->IsUseOnPage();
1826         }
1827     }
1828     return LwpVirtualLayout::IsUseOnPage();
1829 }
1830
1831 /**
1832  * @descr:  Get the LwpShadow object according to m_LayShadow id.
1833 */
1834 LwpShadow* LwpLayout::GetShadow()
1835 {
1836     if (m_bGettingShadow)
1837         throw std::runtime_error("recursion in layout");
1838     m_bGettingShadow = true;
1839     LwpShadow* pRet = nullptr;
1840     if (m_nOverrideFlag & OVER_SHADOW)
1841     {
1842         LwpLayoutShadow* pLayoutShadow = dynamic_cast<LwpLayoutShadow*>(m_LayShadow.obj().get());
1843         pRet = pLayoutShadow ? &pLayoutShadow->GetShadow() : nullptr;
1844     }
1845     else
1846     {
1847         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1848         if (LwpLayout* pLay = dynamic_cast<LwpLayout*>(xBase.get()))
1849         {
1850             pRet = pLay->GetShadow();
1851         }
1852     }
1853     m_bGettingShadow = false;
1854     return pRet;
1855 }
1856
1857 /**
1858  * @descr:  create xfshadow
1859 */
1860 XFShadow* LwpLayout::GetXFShadow()
1861 {
1862     LwpShadow* pShadow = GetShadow();
1863     if (!pShadow)
1864         return nullptr;
1865     LwpColor color = pShadow->GetColor();
1866     double offsetX = pShadow->GetOffsetX();
1867     double offsetY = pShadow->GetOffsetY();
1868
1869     if (!offsetX || !offsetY || !color.IsValidColor())
1870         return nullptr;
1871     XFShadow* pXFShadow = new XFShadow();
1872     enumXFShadowPos eXFShadowPos = enumXFShadowLeftTop;
1873     double fOffset = 0;
1874
1875     bool left = false;
1876     bool top = false;
1877     if (offsetX < 0)
1878         left = true;
1879     if (offsetY < 0)
1880         top = true;
1881     if (left)
1882     {
1883         fOffset = -offsetX;
1884         if (top)
1885             eXFShadowPos = enumXFShadowLeftTop;
1886         else
1887             eXFShadowPos = enumXFShadowLeftBottom;
1888     }
1889     else
1890     {
1891         fOffset = offsetX;
1892         if (top)
1893             eXFShadowPos = enumXFShadowRightTop;
1894         else
1895             eXFShadowPos = enumXFShadowRightBottom;
1896     }
1897
1898     pXFShadow->SetPosition(eXFShadowPos);
1899     pXFShadow->SetOffset(fOffset);
1900     pXFShadow->SetColor(XFColor(color.To24Color()));
1901
1902     return pXFShadow;
1903 }
1904
1905 /**
1906  * @descr get the layout that containers the current frame layout
1907  *
1908  */
1909 rtl::Reference<LwpVirtualLayout> LwpLayout::GetContainerLayout()
1910 {
1911     if (IsRelativeAnchored())
1912     {
1913         //get position
1914         LwpPara* pPara = dynamic_cast<LwpPara*>(GetPosition().obj().get());
1915         if (pPara)
1916         {
1917             LwpStory* pStory = pPara->GetStory();
1918             return pStory ? pStory->GetTabLayout() : nullptr;
1919         }
1920     }
1921     return GetParentLayout();
1922 }
1923
1924 LwpPlacableLayout::LwpPlacableLayout(LwpObjectHeader const& objHdr, LwpSvStream* pStrm)
1925     : LwpLayout(objHdr, pStrm)
1926     , m_bGettingWrapType(false)
1927     , m_bGettingLayoutRelativity(false)
1928     , m_nWrapType(0)
1929     , m_nBuoyancy(0)
1930     , m_nBaseLineOffset(0)
1931 {
1932 }
1933
1934 LwpPlacableLayout::~LwpPlacableLayout() {}
1935
1936 void LwpPlacableLayout::Read()
1937 {
1938     LwpObjectStream* pStrm = m_pObjStrm.get();
1939     LwpLayout::Read();
1940     if (LwpFileHeader::m_nFileRevision < 0x000B)
1941     {
1942         assert(false);
1943     }
1944     else
1945     {
1946         sal_uInt16 simple = pStrm->QuickReaduInt16();
1947         if (!simple)
1948         {
1949             m_nWrapType = pStrm->QuickReaduInt8();
1950             m_nBuoyancy = pStrm->QuickReaduInt8();
1951             m_nBaseLineOffset = pStrm->QuickReadInt32();
1952             m_Script.Read(pStrm);
1953         }
1954         else
1955         {
1956             m_nWrapType = LAY_WRAP_AROUND;
1957             m_nBuoyancy = LAY_BUOYNEUTRAL;
1958             m_nBaseLineOffset = 0;
1959         }
1960         m_LayRelativity.ReadIndexed(pStrm);
1961         if (pStrm->CheckExtra())
1962         {
1963             sal_uInt16 count = pStrm->QuickReaduInt16();
1964             if (count)
1965             {
1966                 // temporarily added by  to avoid assertion
1967                 while (count)
1968                 {
1969                     LwpPoint aPoint;
1970                     aPoint.Read(pStrm);
1971                     count--;
1972                 }
1973             }
1974             pStrm->SkipExtra();
1975         }
1976     }
1977 }
1978 /**
1979  * @descr:  get wrap type
1980 */
1981 sal_uInt8 LwpPlacableLayout::GetWrapType()
1982 {
1983     if (m_bGettingWrapType)
1984         throw std::runtime_error("recursion in layout");
1985     m_bGettingWrapType = true;
1986     sal_uInt8 nWrapType = LAY_WRAP_AROUND;
1987     if (m_nOverrideFlag & OVER_PLACEMENT)
1988     {
1989         nWrapType = m_nWrapType;
1990     }
1991     else
1992     {
1993         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
1994         if (LwpPlacableLayout* pLay = dynamic_cast<LwpPlacableLayout*>(xBase.get()))
1995         {
1996             nWrapType = pLay->GetWrapType();
1997         }
1998     }
1999     m_bGettingWrapType = false;
2000     return nWrapType;
2001 }
2002 /**
2003  * @descr:  get LayoutRelativity
2004 */
2005 LwpLayoutRelativity* LwpPlacableLayout::GetRelativityPiece()
2006 {
2007     if (m_bGettingLayoutRelativity)
2008         throw std::runtime_error("recursion in layout");
2009     m_bGettingLayoutRelativity = true;
2010     LwpLayoutRelativity* pRet = nullptr;
2011     if (!m_LayRelativity.IsNull())
2012     {
2013         if (m_nOverrideFlag & OVER_PLACEMENT)
2014         {
2015             pRet = dynamic_cast<LwpLayoutRelativity*>(m_LayRelativity.obj().get());
2016         }
2017     }
2018     else
2019     {
2020         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
2021         if (LwpPlacableLayout* pLay = dynamic_cast<LwpPlacableLayout*>(xBase.get()))
2022         {
2023             pRet = pLay->GetRelativityPiece();
2024         }
2025     }
2026     m_bGettingLayoutRelativity = false;
2027     return pRet;
2028 }
2029 /**
2030 * @descr:   Get relative type
2031 *
2032 */
2033 sal_uInt8 LwpPlacableLayout::GetRelativeType()
2034 {
2035     LwpLayoutRelativity* pLayRel = GetRelativityPiece();
2036     if (pLayRel)
2037     {
2038         return pLayRel->GetRelGuts().GetRelativeType();
2039     }
2040     return LwpVirtualLayout::GetRelativeType();
2041 }
2042 /**
2043 * @descr:   Get offset from the baseline
2044 *
2045 */
2046 sal_Int32 LwpPlacableLayout::GetBaseLineOffset()
2047 {
2048     /* The baseline is only valid if this is flow-with-text */
2049     if (GetRelativeType() != LwpLayoutRelativityGuts::LAY_INLINE)
2050     {
2051         return 0;
2052     }
2053
2054     // First, ask our content if it has a baseline, ignore now
2055     /*
2056     if (Content && Content->GetBaseLineOffset(&Baseline))
2057         return Baseline;
2058     */
2059
2060     if (m_nOverrideFlag & OVER_PLACEMENT)
2061     {
2062         return m_nBaseLineOffset;
2063     }
2064     else
2065     {
2066         rtl::Reference<LwpObject> xBase(GetBasedOnStyle());
2067         if (LwpPlacableLayout* pLay = dynamic_cast<LwpPlacableLayout*>(xBase.get()))
2068         {
2069             return pLay->GetBaseLineOffset();
2070         }
2071     }
2072     return 0;
2073 }
2074 /**
2075 * @descr:   whether the parent layout is page layout
2076 *
2077 */
2078 bool LwpPlacableLayout::IsAnchorPage()
2079 {
2080     if (IsRelativeAnchored())
2081         return false;
2082
2083     rtl::Reference<LwpVirtualLayout> xLayout = GetParentLayout();
2084     return xLayout.is() && (xLayout->IsPage() || xLayout->IsHeader() || xLayout->IsFooter());
2085 }
2086 /**
2087 * @descr:   whether the parent layout is frame layout
2088 *
2089 */
2090 bool LwpPlacableLayout::IsAnchorFrame()
2091 {
2092     if (IsRelativeAnchored())
2093         return false;
2094
2095     rtl::Reference<LwpVirtualLayout> xLayout = GetParentLayout();
2096     return xLayout.is() && (xLayout->IsFrame() || xLayout->IsGroupHead());
2097 }
2098 /**
2099 * @descr:   whether the parent layout is cell layout
2100 *
2101 */
2102 bool LwpPlacableLayout::IsAnchorCell()
2103 {
2104     if (IsRelativeAnchored())
2105         return false;
2106
2107     rtl::Reference<LwpVirtualLayout> xLayout = GetParentLayout();
2108     return xLayout.is() && xLayout->IsCell();
2109 }
2110
2111 /**
2112 * @descr:   Set font style for setting position of frame
2113 *
2114 */
2115 void LwpPlacableLayout::SetFont(rtl::Reference<XFFont> const& pFont) { m_pFont = pFont; }
2116
2117 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */