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