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