lotuswordpro/source/filter/lwplayout.cxx

   1 /*************************************************************************
   2  *
   3  *  The Contents of this file are made available subject to the terms of
   4  *  either of the following licenses
   5  *
   6  *         - GNU Lesser General Public License Version 2.1
   7  *         - Sun Industry Standards Source License Version 1.1
   8  *
   9  *  Sun Microsystems Inc., October, 2000
  10  *
  11  *  GNU Lesser General Public License Version 2.1
  12  *  =============================================
  13  *  Copyright 2000 by Sun Microsystems, Inc.
  14  *  901 San Antonio Road, Palo Alto, CA 94303, USA
  15  *
  16  *  This library is free software; you can redistribute it and/or
  17  *  modify it under the terms of the GNU Lesser General Public
  18  *  License version 2.1, as published by the Free Software Foundation.
  19  *
  20  *  This library is distributed in the hope that it will be useful,
  21  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23  *  Lesser General Public License for more details.
  24  *
  25  *  You should have received a copy of the GNU Lesser General Public
  26  *  License along with this library; if not, write to the Free Software
  27  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  28  *  MA  02111-1307  USA
  29  *
  30  *
  31  *  Sun Industry Standards Source License Version 1.1
  32  *  =================================================
  33  *  The contents of this file are subject to the Sun Industry Standards
  34  *  Source License Version 1.1 (the "License"); You may not use this file
  35  *  except in compliance with the License. You may obtain a copy of the
  36  *  License at http://www.openoffice.org/license.html.
  37  *
  38  *  Software provided under this License is provided on an "AS IS" basis,
  39  *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  40  *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
  41  *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
  42  *  See the License for the specific provisions governing your rights and
  43  *  obligations concerning the Software.
  44  *
  45  *  The Initial Developer of the Original Code is: IBM Corporation
  46  *
  47  *  Copyright: 2008 by IBM Corporation
  48  *
  49  *  All Rights Reserved.
  50  *
  51  *  Contributor(s): _______________________________________
  52  *
  53  *
  54  ************************************************************************/
  55 /*************************************************************************
  56  * @file
  57  *  For LWP filter architecture prototype
  58  ************************************************************************/
  59 /*************************************************************************
  60  * Change History
  61  Jan 2005                       Created
  62  Feb 2005                       Process gemotry, margins
  63  ************************************************************************/
  64
  65 #include "lwplayout.hxx"
  66 #include "lwpusewhen.hxx"
  67 #include "lwptools.hxx"
  68 #include "xfilter/xfcolumns.hxx"
  69 #include "lwpstory.hxx"
  70 #include "lwpparastyle.hxx"
  71 #include "lwpholder.hxx"
  72 #include "lwpdoc.hxx"
  73 #include "lwppagehint.hxx"
  74 #include "lwpdivinfo.hxx"
  75 #include "lwpgrfobj.hxx"
  76 #ifndef _OSL_THREAD_H_
  77 #include <osl/thread.h>
  78 #endif
  79
  80 LwpVirtualLayout::LwpVirtualLayout(LwpObjectHeader &objHdr, LwpSvStream* pStrm)
  81         : LwpDLNFPVList(objHdr, pStrm)
  82 {}
  83
  84 void LwpVirtualLayout::Read()
  85 {
  86         LwpDLNFPVList::Read();
  87
  88         LwpObjectStream* pStrm = m_pObjStrm;
  89         pStrm->QuickRead(&m_nAttributes, sizeof(m_nAttributes));
  90         pStrm->QuickRead(&m_nAttributes2, sizeof(m_nAttributes2));
  91         pStrm->QuickRead(&m_nAttributes3, sizeof(m_nAttributes3));
  92         pStrm->QuickRead(&m_nOverrideFlag, sizeof(m_nOverrideFlag));
  93         pStrm->QuickRead(&m_nDirection, sizeof(m_nDirection));
  94
  95         //Note that two bytes is read into m_nEditorID instead of one byte.
  96         pStrm->QuickRead(&m_nEditorID, sizeof(m_nEditorID));
  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 = static_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 = static_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 = static_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 = static_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 static_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 = static_cast<LwpVirtualLayout*>(GetChildHead()->obj());
 354         while(pLayout)
 355         {
 356                 pLayout->SetFoundry(m_pFoundry);
 357                 pLayout->RegisterStyle();
 358                 pLayout = static_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 =static_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 = static_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 static_cast<LwpVirtualLayout*>(m_OnlyLayout.obj());
 449
 450         LwpObjectHolder* pObjHolder =static_cast<LwpObjectHolder*>(m_Layouts.GetHead()->obj());
 451         if(pObjHolder)
 452         {
 453                 pLayout = static_cast<LwpVirtualLayout*>(pObjHolder->GetObject()->obj());
 454                 if(!pStartLayout )
 455                         return pLayout;
 456
 457                 while(pObjHolder && pStartLayout != pLayout)
 458                 {
 459                         pObjHolder = static_cast<LwpObjectHolder*>(pObjHolder->GetNext()->obj());
 460                         if(pObjHolder)
 461                         {
 462                                 pLayout = static_cast<LwpVirtualLayout*>(pObjHolder->GetObject()->obj());
 463                         }
 464                 }
 465
 466                 if(pObjHolder)
 467                 {
 468                         pObjHolder = static_cast<LwpObjectHolder*>(pObjHolder->GetNext()->obj());
 469                         if(pObjHolder)
 470                         {
 471                                 pLayout = static_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 = static_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                         pLayout->RegisterStyle();
 506                 }
 507                 pLayout = static_cast<LwpVirtualLayout*>(pLayout->GetNext()->obj());
 508         }
 509 }
 510
 511 /**
 512  * @descr   find endnote supertable layout from the child layout list. Suppose that there is only one endnote supertablelayout in one division
 513  * @return pointer to endnote supertable layout
 514  */
 515 LwpVirtualLayout* LwpHeadLayout::FindEnSuperTableLayout()
 516 {
 517         LwpVirtualLayout* pLayout = static_cast<LwpVirtualLayout*>(GetChildHead()->obj());
 518         while(pLayout)
 519         {
 520                 if(pLayout->GetLayoutType() == LWP_ENDNOTE_SUPERTABLE_LAYOUT)
 521                 {
 522                         return pLayout;
 523                 }
 524                 pLayout = static_cast<LwpVirtualLayout*>(pLayout->GetNext()->obj());
 525         }
 526         return NULL;
 527 }
 528
 529 LwpLayoutStyle::LwpLayoutStyle() :
 530 m_nStyleDefinition(0), m_nKey(0),
 531 m_pDescription(new LwpAtomHolder)
 532 {
 533 }
 534
 535 LwpLayoutStyle::~LwpLayoutStyle()
 536 {
 537         if (m_pDescription)
 538         {
 539                 delete m_pDescription;
 540         }
 541 }
 542
 543 void LwpLayoutStyle::Read(LwpObjectStream* pStrm)
 544 {
 545         pStrm->QuickRead(&m_nStyleDefinition, sizeof(m_nStyleDefinition));
 546         m_pDescription->Read(pStrm);
 547         if (pStrm->CheckExtra())
 548         {
 549                 pStrm->QuickRead(&m_nKey, 2);
 550                 pStrm->SkipExtra();
 551         }
 552 }
 553
 554 LwpLayoutMisc::LwpLayoutMisc() :
 555 m_nGridDistance(0), m_nGridType(0),
 556 m_pContentStyle(new LwpAtomHolder)
 557 {
 558 }
 559
 560 LwpLayoutMisc::~LwpLayoutMisc()
 561 {
 562         if (m_pContentStyle)
 563         {
 564                 delete m_pContentStyle;
 565         }
 566 }
 567
 568 void LwpLayoutMisc::Read(LwpObjectStream* pStrm)
 569 {
 570         pStrm->QuickRead(&m_nGridType, 2);
 571         pStrm->QuickRead(&m_nGridDistance, 4);
 572         m_pContentStyle->Read(pStrm);
 573         pStrm->SkipExtra();
 574 }
 575
 576 LwpMiddleLayout::LwpMiddleLayout( LwpObjectHeader &objHdr, LwpSvStream* pStrm )
 577         : LwpVirtualLayout(objHdr, pStrm),
 578           m_pStyleStuff(new LwpLayoutStyle), m_pMiscStuff(new LwpLayoutMisc)
 579 {}
 580
 581 LwpMiddleLayout::~LwpMiddleLayout()
 582 {
 583         if (m_pStyleStuff)
 584         {
 585                 delete m_pStyleStuff;
 586         }
 587         if (m_pMiscStuff)
 588         {
 589                 delete m_pMiscStuff;
 590         }
 591 }
 592 void LwpMiddleLayout::Read()
 593 {
 594         LwpObjectStream* pStrm = m_pObjStrm;
 595
 596         LwpVirtualLayout::Read();
 597
 598         //skip CLiteLayout data;
 599         LwpAtomHolder ContentClass;
 600         ContentClass.Read(pStrm);
 601         pStrm->SkipExtra();
 602
 603         // before layout hierarchy rework
 604         if(LwpFileHeader::m_nFileRevision < 0x000B)
 605                 return;
 606
 607         m_Content.ReadIndexed(pStrm);
 608
 609         // 01/20/2005
 610         m_BasedOnStyle.ReadIndexed(pStrm);
 611         m_TabPiece.ReadIndexed(pStrm);
 612
 613         sal_uInt8 nWhatsItGot = 0;
 614         pStrm->QuickRead(&nWhatsItGot, 1);
 615
 616         if (nWhatsItGot & DISK_GOT_STYLE_STUFF)
 617         {
 618                 m_pStyleStuff->Read(pStrm);
 619         }
 620         if (nWhatsItGot & DISK_GOT_MISC_STUFF)
 621         {
 622                 m_pMiscStuff->Read(pStrm);
 623         }
 624
 625         m_LayGeometry.ReadIndexed(pStrm);
 626         m_LayScale.ReadIndexed(pStrm);
 627         m_LayMargins.ReadIndexed(pStrm);
 628         m_LayBorderStuff.ReadIndexed(pStrm);
 629         m_LayBackgroundStuff.ReadIndexed(pStrm);
 630
 631         if (pStrm->CheckExtra())
 632         {
 633                 m_LayExtBorderStuff.ReadIndexed(pStrm);
 634                 pStrm->SkipExtra();
 635         }
 636         //end
 637 }
 638
 639 #include "lwplaypiece.hxx"
 640
 641 /**
 642 * @descr:       Get the geometry of current layout
 643 *
 644 */
 645 LwpLayoutGeometry* LwpMiddleLayout::GetGeometry()
 646 {
 647         if( !m_LayGeometry.IsNull() )
 648         {
 649                 return ( static_cast<LwpLayoutGeometry*> (m_LayGeometry.obj()) );
 650         }
 651         else if( !m_BasedOnStyle.IsNull() )
 652         {
 653                 LwpMiddleLayout* pLay = static_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj() );
 654                 return pLay->GetGeometry();
 655         }
 656         return NULL;
 657 }
 658
 659 /**
 660 * @descr:       Get layout height, measured by "cm"
 661 *
 662 */
 663 double LwpMiddleLayout::GetGeometryHeight()
 664 {
 665         LwpLayoutGeometry* pGeo = GetGeometry();
 666         if(pGeo)
 667         {
 668                 return ( LwpTools::ConvertFromUnitsToMetric( pGeo->GetHeight() ) );
 669         }
 670         else
 671                 return -1;
 672 }
 673
 674 /**
 675 * @descr:       Get layout width, measured by "cm"
 676 *
 677 */
 678 double LwpMiddleLayout::GetGeometryWidth()
 679 {
 680         LwpLayoutGeometry* pGeo = GetGeometry();
 681         if(pGeo)
 682         {
 683                 return ( LwpTools::ConvertFromUnitsToMetric( pGeo->GetWidth() ) );
 684         }
 685         else
 686                 return -1;
 687 }
 688
 689 /**
 690 * @descr:       Whether the margins is same as parent layout
 691 *
 692 */
 693 BOOL LwpMiddleLayout::MarginsSameAsParent()
 694 {
 695         if(m_nOverrideFlag & OVER_MARGINS)
 696         {
 697                 return LwpVirtualLayout::MarginsSameAsParent();
 698         }
 699         if(!m_BasedOnStyle.IsNull())
 700         {
 701                 LwpVirtualLayout* play = static_cast<LwpVirtualLayout*> (m_BasedOnStyle.obj());
 702                 play->MarginsSameAsParent();
 703         }
 704         return LwpVirtualLayout::MarginsSameAsParent();
 705
 706 }
 707
 708 /**
 709 * @descr:       Get margin
 710 * @param:       nWhichSide - 0: left, 1: right, 2:top, 3: bottom
 711 */
 712 double LwpMiddleLayout::GetMarginsValue(const sal_uInt8 &nWhichSide)
 713 {
 714         double fValue = 0;
 715         if((nWhichSide==MARGIN_LEFT)||(nWhichSide==MARGIN_RIGHT))
 716         {
 717                 if ( MarginsSameAsParent() )
 718                 {
 719                         LwpVirtualLayout* pParent = static_cast<LwpVirtualLayout*> (GetParent()->obj());
 720                         if(pParent && !pParent->IsHeader())
 721                         {
 722                                 fValue = pParent->GetMarginsValue(nWhichSide);
 723                                 return fValue;
 724                         }
 725                 }
 726         }
 727
 728         if(m_nOverrideFlag & OVER_MARGINS)
 729         {
 730                 LwpLayoutMargins* pMar1 = static_cast<LwpLayoutMargins*> (m_LayMargins.obj());
 731                 if(pMar1)
 732                 {
 733                         fValue = pMar1->GetMargins()->GetMarginsValue(nWhichSide);
 734                         return fValue;
 735                 }
 736         }
 737         LwpVirtualLayout* pStyle = static_cast<LwpVirtualLayout*> (m_BasedOnStyle.obj());
 738         if(pStyle)
 739         {
 740                 fValue = pStyle->GetMarginsValue(nWhichSide);
 741                 return fValue;
 742         }
 743         return LwpVirtualLayout::GetMarginsValue(nWhichSide);
 744 }
 745 /**
 746  * @descr:      Get extmargin value
 747  * @param:      nWhichSide - 0: left, 1: right, 2:top, 3: bottom
 748  * @param:
 749  * @return:
 750 */
 751 double LwpMiddleLayout::GetExtMarginsValue(const sal_uInt8 &nWhichSide)
 752 {
 753         double fValue = 0;
 754         if(m_nOverrideFlag & OVER_MARGINS)
 755         {
 756                 LwpLayoutMargins* pMar1 = static_cast<LwpLayoutMargins*> (m_LayMargins.obj());
 757                 if(pMar1)
 758                 {
 759                         fValue = pMar1->GetExtMargins()->GetMarginsValue(nWhichSide);
 760                         return fValue;
 761                 }
 762         }
 763         LwpVirtualLayout* pStyle = static_cast<LwpVirtualLayout*> (m_BasedOnStyle.obj());
 764         if(pStyle)
 765         {
 766                 fValue = pStyle->GetExtMarginsValue(nWhichSide);
 767                 return fValue;
 768         }
 769         return LwpVirtualLayout::GetExtMarginsValue(nWhichSide);
 770 }
 771 /**
 772  * @descr:  Get the LwpBorderStuff object according to m_LayBorderStuff id.
 773  * @param:
 774  * @param:
 775  * @return:
 776 */
 777 LwpBorderStuff* LwpMiddleLayout::GetBorderStuff()
 778 {
 779         if(m_nOverrideFlag & OVER_BORDERS)
 780         {
 781                 LwpLayoutBorder* pLayoutBorder = static_cast<LwpLayoutBorder*>(m_LayBorderStuff.obj());
 782                 return pLayoutBorder->GetBorderStuff();
 783         }
 784         else if( !m_BasedOnStyle.IsNull() )
 785         {
 786                 LwpMiddleLayout* pLay = static_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj() );
 787                 return pLay->GetBorderStuff();
 788         }
 789         return NULL;
 790 }
 791
 792 /**
 793  * @descr:  Get LwpBackgroundStuff object according to m_LayBackgroundStuff id;
 794  * @param:
 795  * @param:
 796  * @return:
 797 */
 798 LwpBackgroundStuff* LwpMiddleLayout::GetBackgroundStuff()
 799 {
 800         if(m_nOverrideFlag & OVER_BACKGROUND)
 801         {
 802                 LwpLayoutBackground* pLayoutBackground = static_cast<LwpLayoutBackground*>(m_LayBackgroundStuff.obj());
 803                 return pLayoutBackground->GetBackgoudStuff();
 804         }
 805         else if( !m_BasedOnStyle.IsNull() )
 806         {
 807                 LwpMiddleLayout* pLay = static_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj() );
 808                 return pLay->GetBackgroundStuff();
 809         }
 810         return NULL;
 811 }
 812 /**
 813  * @descr:  create xfborder.
 814  * @param:
 815  * @param:
 816  * @return:
 817 */
 818 XFBorders* LwpMiddleLayout::GetXFBorders()
 819 {
 820         LwpBorderStuff* pBorderStuff = GetBorderStuff();
 821         if(pBorderStuff&&pBorderStuff->GetSide() != 0)
 822         {
 823                 //copy from lwpparastyle.
 824                 XFBorders       *pXFBorders = new XFBorders();
 825                 // apply 4 borders respectively
 826                 LwpBorderStuff::BorderType pType[] = { LwpBorderStuff::LEFT, LwpBorderStuff::RIGHT,
 827                         LwpBorderStuff::TOP, LwpBorderStuff::BOTTOM };
 828
 829                 for (sal_uInt8 nC = 0; nC < 4; nC++)
 830                 {
 831                         if (pBorderStuff->HasSide(pType[nC]))
 832                         {
 833                                 LwpParaStyle::ApplySubBorder(pBorderStuff, pType[nC], pXFBorders);
 834                         }
 835                 }
 836                 return pXFBorders;
 837         }
 838         return NULL;
 839 }
 840
 841 /**
 842  * @descr:  Get text direction settings.
 843  * @param:
 844  * @param:
 845  * @return:
 846 */
 847 enumXFTextDir LwpMiddleLayout::GetTextDirection()
 848 {
 849         enumXFTextDir eTextDir = enumXFTextDirNone;
 850         sal_uInt8 nDirection = GetContentOrientation();
 851         switch(nDirection)
 852         {
 853                 case TEXT_ORIENT_LRTB:
 854                 {
 855                         eTextDir = enumXFTextDirLR_TB;
 856                         break;
 857                 }
 858                 case TEXT_ORIENT_TBRL:
 859                 {
 860                         eTextDir = enumXFTextDirTB_RL;
 861                         break;
 862                 }
 863                 case TEXT_ORIENT_RLBT: // not supported now
 864                 {
 865                         eTextDir = enumXFTextDirNone;
 866                         break;
 867                 }
 868                 case TEXT_ORIENT_BTLR: // not supported now
 869                 {
 870                         eTextDir = enumXFTextDirNone;
 871                         break;
 872                 }
 873                 default:
 874                         break;
 875         }
 876         return eTextDir;
 877 }
 878 /**
 879  * @descr: Get back ground color.
 880  * @param:
 881  * @param:
 882  * @return:
 883 */
 884 LwpColor* LwpMiddleLayout::GetBackColor()
 885 {
 886         LwpBackgroundStuff* pBackgroundStuff = GetBackgroundStuff();
 887         if(pBackgroundStuff && !pBackgroundStuff->IsTransparent())
 888         {
 889                 LwpColor* pColor = pBackgroundStuff->GetFillColor();
 890                 if(pColor->IsValidColor())
 891                 {
 892                         return pColor;
 893                 }
 894         }
 895         return NULL;
 896 }
 897
 898 /**
 899  * @descr:  Add back color settings into xfpagemaster.
 900  * @param:
 901  * @param:
 902  * @return:
 903 */
 904 LwpTabOverride* LwpMiddleLayout::GetTabOverride()
 905 {
 906         if(m_nAttributes & OVER_TABS)
 907         {
 908                 if(!m_TabPiece.IsNull())
 909                         return (LwpTabOverride*)static_cast<LwpTabPiece*>(m_TabPiece.obj())->GetOverride();
 910                 return NULL;
 911         }
 912         else if( !m_BasedOnStyle.IsNull() )
 913         {
 914                 LwpMiddleLayout* pLay = static_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj() );
 915                 return pLay->GetTabOverride();
 916         }
 917         return NULL;
 918 }
 919
 920 /**
 921  * @descr:   Layscale for graphic & watermark
 922  * @param:
 923  * @param:
 924  * @return:
 925 */
 926 sal_uInt16 LwpMiddleLayout::GetScaleMode(void)
 927 {
 928         if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj())
 929                 return GetLayoutScale()->GetScaleMode();
 930         else if (m_BasedOnStyle.obj())
 931                 return static_cast<LwpMiddleLayout*>(m_BasedOnStyle.obj())->GetScaleMode();
 932         else
 933                 return (LwpLayoutScale::FIT_IN_FRAME | LwpLayoutScale::MAINTAIN_ASPECT_RATIO);
 934 }
 935
 936 void LwpMiddleLayout::SetScaleMode(sal_uInt16 nVal)
 937 {
 938         m_nOverrideFlag |= OVER_SCALING;
 939 //      nVal |= LwpLayoutScale::MAINTAIN_ASPECT_RATIO;
 940         GetLayoutScale()->SetScaleMode(nVal);
 941 }
 942
 943 sal_uInt16 LwpMiddleLayout::GetScaleTile(void)
 944 {
 945         if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj())
 946                 return (GetLayoutScale()->GetPlacement() & LwpLayoutScale::TILED)
 947                         ? 1 : 0;
 948         else if (m_BasedOnStyle.obj())
 949                 return static_cast<LwpMiddleLayout*>(m_BasedOnStyle.obj())->GetScaleTile();
 950         else
 951                 return 0;
 952 }
 953
 954 void LwpMiddleLayout::SetScaleTile(sal_uInt16 nVal)
 955 {
 956         m_nOverrideFlag |= OVER_SCALING;
 957         if (nVal)
 958                 GetLayoutScale()->SetPlacement(GetLayoutScale()->GetPlacement() | LwpLayoutScale::TILED);
 959         else
 960                 GetLayoutScale()->SetPlacement(GetLayoutScale()->GetPlacement() & ~LwpLayoutScale::TILED);
 961 }
 962
 963 sal_uInt16 LwpMiddleLayout::GetScaleCenter(void)
 964 {
 965         if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj())
 966                 return (GetLayoutScale()->GetPlacement() & LwpLayoutScale::CENTERED)
 967                         ? 1 : 0;
 968         else if (m_BasedOnStyle.obj())
 969                 return static_cast<LwpMiddleLayout*>(m_BasedOnStyle.obj())->GetScaleCenter();
 970         else
 971                 return 0;
 972 }
 973
 974 void LwpMiddleLayout::SetScaleCenter(sal_uInt16 nVal)
 975 {
 976         m_nOverrideFlag |= OVER_SCALING;
 977         if (nVal)
 978                 GetLayoutScale()->SetPlacement(GetLayoutScale()->GetPlacement() | LwpLayoutScale::CENTERED);
 979         else
 980                 GetLayoutScale()->SetPlacement(GetLayoutScale()->GetPlacement() & ~LwpLayoutScale::CENTERED);
 981 }
 982
 983 sal_uInt32 LwpMiddleLayout::GetScalePercentage(void)
 984 {
 985         if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj())
 986                 return GetLayoutScale()->GetScalePercentage()/10;//m_nScalePercentage 1000 = 100%
 987         else if (m_BasedOnStyle.obj())
 988                 return static_cast<LwpMiddleLayout*>(m_BasedOnStyle.obj())->GetScalePercentage();
 989         else
 990                 return 100;
 991 }
 992
 993 void LwpMiddleLayout::SetScalePercentage(sal_uInt32 nVal)
 994 {
 995         m_nOverrideFlag |= OVER_SCALING;
 996         GetLayoutScale()->SetScalePercentage(nVal*10);
 997 }
 998
 999 double LwpMiddleLayout::GetScaleWidth(void)
1000 {
1001         if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj())
1002                 return LwpTools::ConvertFromUnits(GetLayoutScale()->GetScaleWidth());
1003         else if (m_BasedOnStyle.obj())
1004                 return static_cast<LwpMiddleLayout*>(m_BasedOnStyle.obj())->GetScaleWidth();
1005         else
1006                 return 0;
1007 }
1008
1009 void LwpMiddleLayout::SetScaleWidth(double fVal)
1010 {
1011         m_nOverrideFlag |= OVER_SCALING;
1012         GetLayoutScale()->SetScaleWidth(LwpTools::ConvertToUnits(fVal));
1013 }
1014
1015 double LwpMiddleLayout::GetScaleHeight(void)
1016 {
1017         if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj())
1018                 return LwpTools::ConvertFromUnits(GetLayoutScale()->GetScaleHeight());
1019         else if (m_BasedOnStyle.obj())
1020                 return static_cast<LwpMiddleLayout*>(m_BasedOnStyle.obj())->GetScaleHeight();
1021         else
1022                 return 0;
1023 }
1024 sal_Bool LwpMiddleLayout::CanSizeRight(void)
1025 {
1026         sal_uInt8 RelType = GetRelativeType();
1027
1028         if (RelType == LwpLayoutRelativityGuts::LAY_INLINE || RelType == LwpLayoutRelativityGuts::LAY_PARA_RELATIVE
1029         || RelType == LwpLayoutRelativityGuts::LAY_INLINE_VERTICAL)
1030         {
1031                 return sal_False;
1032         }
1033         return sal_True;
1034 }
1035 sal_Int32 LwpMiddleLayout::GetMinimumWidth()
1036 {
1037         if (((m_nAttributes3 & STYLE3_WIDTHVALID) != 0) && GetGeometry())
1038         {
1039                 return GetGeometry()->GetWidth();
1040         }
1041         else if (m_nOverrideFlag & OVER_SIZE)
1042         {
1043                 return DetermineWidth();
1044         }
1045         return 0;
1046 }
1047 sal_Int32 LwpMiddleLayout::DetermineWidth()
1048 {
1049         if (IsSizeRightToContent())
1050         {
1051                 assert(sal_False);
1052         }
1053         else if (IsSizeRightToContainer())
1054         {
1055                 assert(sal_False);
1056         }
1057         else
1058         {
1059                 m_nAttributes3 |= STYLE3_WIDTHVALID;
1060                 return GetGeometry()->GetWidth();
1061         }
1062         return 0;
1063 }
1064 sal_Bool LwpMiddleLayout::IsSizeRightToContainer(void)
1065 {
1066         if (!CanSizeRight())
1067                 return sal_False;
1068
1069         if (m_nOverrideFlag & OVER_SIZE)
1070         {
1071                 return (m_nDirection & ((LAY_USEDIRECTION|LAY_AUTOSIZE|LAY_TOCONTAINER)
1072                                                 << SHIFT_RIGHT))
1073                 == ((LAY_USEDIRECTION | LAY_TOCONTAINER | LAY_AUTOSIZE) << SHIFT_RIGHT);
1074         }
1075         else if (m_BasedOnStyle.obj())
1076         {
1077                 LwpMiddleLayout * pLayout = static_cast<LwpMiddleLayout *>(m_BasedOnStyle.obj());
1078                 return pLayout->IsSizeRightToContainer();
1079         }
1080         else
1081                 return sal_False;
1082 }
1083 sal_Bool LwpMiddleLayout::IsSizeRightToContent(void)
1084 {
1085         if (!CanSizeRight())
1086                 return sal_False;
1087
1088         if (m_nOverrideFlag & OVER_SIZE)
1089         {
1090                 return (m_nDirection & ((LAY_USEDIRECTION|LAY_AUTOSIZE|LAY_TOCONTAINER)
1091                                                         << SHIFT_RIGHT))
1092                                 == ((LAY_USEDIRECTION | LAY_AUTOSIZE) << SHIFT_RIGHT);
1093         }
1094         else if (m_BasedOnStyle.obj())
1095         {
1096                 LwpMiddleLayout * pLayout = static_cast<LwpMiddleLayout *>(m_BasedOnStyle.obj());
1097                 return pLayout->IsSizeRightToContent();
1098         }
1099         else
1100                 return sal_False;
1101 }
1102
1103 /**
1104 * @descr:       Get layout height
1105 *
1106 */
1107 double LwpMiddleLayout::GetHeight()
1108 {
1109         return GetGeometryHeight();
1110 }
1111
1112 /**
1113 * @descr:       Get layout height
1114 *
1115 */
1116 double LwpMiddleLayout::GetWidth()
1117 {
1118         return GetGeometryWidth();
1119 }
1120 /**
1121 * @descr:       Get layout orgin point
1122 *
1123 */
1124 LwpPoint LwpMiddleLayout::GetOrigin()
1125 {
1126         LwpLayoutGeometry* pGeo = GetGeometry();
1127         if(pGeo)
1128         {
1129                 sal_uInt8 nType = GetRelativeType();
1130                 if(nType == LwpLayoutRelativityGuts::LAY_INLINE
1131                         || nType == LwpLayoutRelativityGuts::LAY_INLINE_NEWLINE )
1132                 {
1133                         return pGeo->GetAbsoluteOrigin();
1134                 }
1135                 else
1136                         return pGeo->GetOrigin();
1137
1138         }
1139
1140         return LwpPoint();
1141 }
1142
1143 void LwpMiddleLayout::SetScaleHeight(double fVal)
1144 {
1145         m_nOverrideFlag |= OVER_SCALING;
1146         GetLayoutScale()->SetScaleHeight(LwpTools::ConvertToUnits(fVal));
1147 }
1148
1149 /**
1150 * @descr:       Whether the fill is pattern fill or not
1151 * @return:      True if yes, false if not.
1152 */
1153 sal_Bool LwpMiddleLayout::IsPatternFill()
1154 {
1155         LwpBackgroundStuff* pBackgroundStuff = GetBackgroundStuff();
1156         if (pBackgroundStuff)
1157         {
1158                 return pBackgroundStuff->IsPatternFill();
1159         }
1160
1161         return sal_False;
1162 }
1163
1164 /**
1165 * @descr:       Get the fill pattern style. Data are saved in a XFBGImage object
1166 * @return:      the fill pattern style.
1167 */
1168 XFBGImage* LwpMiddleLayout::GetFillPattern()
1169 {
1170         LwpBackgroundStuff* pBackgroundStuff = GetBackgroundStuff();
1171         if (pBackgroundStuff)
1172         {
1173                 return pBackgroundStuff->GetFillPattern();
1174         }
1175
1176         return NULL;
1177
1178 }
1179
1180 /**
1181 * @descr:       Whether the height and width of layout is auto grow
1182 *
1183 */
1184 sal_Bool LwpMiddleLayout::IsAutoGrow()
1185 {
1186         if(m_nOverrideFlag & OVER_SIZE)
1187         {
1188                 return m_nDirection &
1189                         ((LAY_AUTOGROW << SHIFT_UP) | (LAY_AUTOGROW << SHIFT_DOWN) |
1190                         (LAY_AUTOGROW << SHIFT_RIGHT) | (LAY_AUTOGROW << SHIFT_LEFT))
1191                         ? sal_True : sal_False;
1192         }
1193         else if( !m_BasedOnStyle.IsNull() )
1194         {
1195                 LwpMiddleLayout* pLay = static_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj() );
1196                 return pLay->IsAutoGrow();
1197         }
1198         return LwpVirtualLayout::IsAutoGrow();
1199 }
1200
1201 /**
1202 * @descr:       Whether the height of layout is auto grow down
1203 *
1204 */
1205 sal_Bool LwpMiddleLayout::IsAutoGrowDown()
1206 {
1207         if(m_nOverrideFlag & OVER_SIZE)
1208         {
1209                 return m_nDirection & (LAY_AUTOGROW << SHIFT_DOWN) ? sal_True : sal_False;
1210         }
1211         else if( !m_BasedOnStyle.IsNull() )
1212         {
1213                 LwpMiddleLayout* pLay = static_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj() );
1214                 return pLay->IsAutoGrowDown();
1215         }
1216         return LwpVirtualLayout::IsAutoGrowDown();
1217 }
1218
1219 /**
1220 * @descr:       Whether the height of layout is auto grow up
1221 *
1222 */
1223 sal_Bool LwpMiddleLayout::IsAutoGrowUp()
1224 {
1225         if(m_nOverrideFlag & OVER_SIZE)
1226         {
1227                 return m_nDirection & (LAY_AUTOGROW << SHIFT_UP) ? sal_True : sal_False;
1228         }
1229         else if( !m_BasedOnStyle.IsNull() )
1230         {
1231                 LwpMiddleLayout* pLay = static_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj() );
1232                 return pLay->IsAutoGrowUp();
1233         }
1234         return LwpVirtualLayout::IsAutoGrowUp();
1235 }
1236
1237 /**
1238 * @descr:       Whether the height of layout is auto grow down
1239 *
1240 */
1241 sal_Bool LwpMiddleLayout::IsAutoGrowLeft()
1242 {
1243         if(m_nOverrideFlag & OVER_SIZE)
1244         {
1245                 return m_nDirection & (LAY_AUTOGROW << SHIFT_LEFT) ? sal_True : sal_False;
1246         }
1247         else if( !m_BasedOnStyle.IsNull() )
1248         {
1249                 LwpMiddleLayout* pLay = static_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj() );
1250                 return pLay->IsAutoGrowLeft();
1251         }
1252         return LwpVirtualLayout::IsAutoGrowLeft();
1253 }
1254
1255 /**
1256 * @descr:       Whether the height of layout is auto grow down
1257 *
1258 */
1259 sal_Bool LwpMiddleLayout::IsAutoGrowRight()
1260 {
1261         if(m_nOverrideFlag & OVER_SIZE)
1262         {
1263                 return m_nDirection & (LAY_AUTOGROW << SHIFT_RIGHT) ? sal_True : sal_False;
1264         }
1265         else if( !m_BasedOnStyle.IsNull() )
1266         {
1267                 LwpMiddleLayout* pLay = static_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj() );
1268                 return pLay->IsAutoGrowRight();
1269         }
1270         return LwpVirtualLayout::IsAutoGrowRight();
1271 }
1272
1273
1274 /**
1275 * @descr:       Get contents orientation
1276 *
1277 */
1278 sal_uInt8 LwpMiddleLayout::GetContentOrientation()
1279 {
1280         //content orientation in Graphic objects and OLE objects not supported now
1281         if((m_nOverrideFlag & OVER_ROTATION)&& !m_LayGeometry.IsNull())
1282         {
1283                 LwpLayoutGeometry* pLayGeometry = static_cast<LwpLayoutGeometry*> (m_LayGeometry.obj());
1284                 return pLayGeometry->GetContentOrientation();
1285         }
1286         else if( !m_BasedOnStyle.IsNull() )
1287         {
1288                 LwpMiddleLayout* pLay = static_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj() );
1289                 return pLay->GetContentOrientation();
1290         }
1291         return LwpVirtualLayout::GetContentOrientation();
1292 }
1293
1294 /**
1295 * @descr:       Whether it is honoring protection
1296 *
1297 */
1298 sal_Bool LwpMiddleLayout::HonorProtection()
1299 {
1300         if(m_nOverrideFlag & OVER_MISC)
1301         {
1302                 if(!(m_nAttributes2 & STYLE2_HONORPROTECTION))
1303                         return sal_False;
1304
1305                 LwpVirtualLayout* pParent = static_cast<LwpVirtualLayout*> (GetParent()->obj());
1306                 if(pParent && !pParent->IsHeader())
1307                 {
1308                         return pParent->HonorProtection();
1309                 }
1310
1311                 if(m_pFoundry)//is null now
1312                 {
1313                         LwpDocument* pDoc = m_pFoundry->GetDocument();
1314                         if(pDoc)
1315                         {
1316                                 return pDoc->HonorProtection();
1317                         }
1318                 }
1319         }
1320         else if( !m_BasedOnStyle.IsNull() )
1321         {
1322                 LwpMiddleLayout* pLay = static_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj() );
1323                 return pLay->HonorProtection();
1324         }
1325
1326         return LwpVirtualLayout::HonorProtection();
1327 }
1328
1329 /**
1330 * @descr:       Whether it is pretected
1331 *
1332 */
1333 sal_Bool LwpMiddleLayout::IsProtected()
1334 {
1335         sal_Bool bProtected = sal_False;
1336         if(m_nOverrideFlag & OVER_MISC)
1337         {
1338                 bProtected = (m_nAttributes & STYLE_PROTECTED)!=0;
1339         }
1340         else if( !m_BasedOnStyle.IsNull() )
1341         {
1342                 LwpMiddleLayout* pLay = static_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj() );
1343                 bProtected = pLay->IsProtected();
1344         }
1345         else
1346                 bProtected = LwpVirtualLayout::IsProtected();
1347
1348         LwpVirtualLayout* pParent = static_cast<LwpVirtualLayout*> (GetParent()->obj());
1349         if(pParent && !pParent->IsHeader())
1350         {
1351                 /* If a parent's protected then none of its children can be accessed. */
1352                 if(pParent->IsProtected())
1353                         return sal_True;
1354
1355                 if(pParent->HonorProtection())
1356                         return bProtected;
1357
1358                 /* If our parent isn't honoring protection then we aren't protected. */
1359                 return sal_False;
1360
1361         }
1362         if(m_pFoundry)//is null now
1363         {
1364                 LwpDocument* pDoc = m_pFoundry->GetDocument();
1365                 if(pDoc)
1366                 {
1367                         if (pDoc->HonorProtection())
1368                                 return bProtected;
1369
1370                         /* If the document isn't honoring protection then we aren't protected.*/
1371                         return sal_False;
1372                 }
1373         }
1374
1375         return bProtected;
1376 }
1377
1378 /**
1379 * @descr:       Get watermark layout
1380 *
1381 */
1382 LwpVirtualLayout* LwpMiddleLayout::GetWaterMarkLayout()
1383 {
1384         LwpVirtualLayout* pLay = static_cast<LwpVirtualLayout*>(GetChildHead()->obj());
1385         while(pLay)
1386         {
1387                 if( pLay->IsForWaterMark())
1388                 {
1389                         return pLay;
1390                 }
1391                 pLay = static_cast<LwpVirtualLayout*> (pLay->GetNext()->obj());
1392         }
1393         return NULL;
1394 }
1395
1396 /**
1397 * @descr:       Create and reture xfbgimage object for watermark
1398 *
1399 */
1400 XFBGImage* LwpMiddleLayout::GetXFBGImage()
1401 {
1402         LwpMiddleLayout* pLay = static_cast<LwpMiddleLayout*>(GetWaterMarkLayout());
1403         if(pLay)
1404         {
1405                 //test BGImage
1406                 LwpGraphicObject* pGrfObj = static_cast<LwpGraphicObject*>(pLay->GetContent()->obj());
1407                 if(pGrfObj)
1408                 {
1409                         XFBGImage* pXFBGImage = new XFBGImage();
1410
1411                         if(pGrfObj->IsLinked())
1412                         {
1413                                 //set file link
1414                                 OUString linkedfilepath = pGrfObj->GetLinkedFilePath();
1415                                 OUString fileURL = LwpTools::convertToFileUrl(OUStringToOString(linkedfilepath, osl_getThreadTextEncoding()));
1416                                 pXFBGImage->SetFileLink(fileURL);
1417                         }
1418                         else
1419                         {
1420                                 sal_uInt8* pGrafData = NULL;
1421                                 sal_uInt32 nDataLen = pGrfObj->GetRawGrafData(pGrafData);
1422                                 pXFBGImage->SetImageData(pGrafData, nDataLen);
1423                                 if(pGrafData)
1424                                 {
1425                                         delete pGrafData;
1426                                         pGrafData = NULL;
1427                                 }
1428                         }
1429
1430
1431                         //automatic, top left
1432                         pXFBGImage->SetPosition(enumXFAlignStart,enumXFAlignTop);
1433                         if(pLay->GetScaleCenter())
1434                         {
1435                                 //center
1436                                 pXFBGImage->SetPosition(enumXFAlignCenter,enumXFAlignCenter);
1437                         }
1438                         else if(pLay->GetScaleTile())
1439                         {
1440                                 //tile
1441                                 pXFBGImage->SetRepeate();
1442                         }
1443                         //fit type, area type
1444                         if((pLay->GetScaleMode()& LwpLayoutScale::FIT_IN_FRAME)!=0)
1445                         {
1446                                 if((pLay->GetScaleMode()& LwpLayoutScale::MAINTAIN_ASPECT_RATIO)==0)
1447                                 {
1448                                         pXFBGImage->SetStretch();
1449                                 }
1450                         }
1451                         return pXFBGImage;
1452                 }
1453         }
1454         return NULL;
1455 }
1456
1457 /**
1458 * @descr:       Whether the page uses the printer setting
1459 *
1460 */
1461 sal_Bool LwpMiddleLayout::GetUsePrinterSettings()
1462 {
1463         if(m_nOverrideFlag & OVER_SIZE)
1464         {
1465                 return (m_nAttributes3 & STYLE3_USEPRINTERSETTINGS) != 0;
1466         }
1467         else if( !m_BasedOnStyle.IsNull() )
1468         {
1469                 LwpMiddleLayout* pLay = static_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj() );
1470                 return pLay->GetUsePrinterSettings();
1471         }
1472         return sal_False;
1473 }
1474
1475
1476 //Check whether there are contents in the layout
1477 sal_Bool LwpMiddleLayout::HasContent()
1478 {
1479         LwpObject* content = m_Content.obj();
1480         if(content)
1481                 return sal_True;
1482         return sal_False;
1483 }
1484 //End by
1485
1486 LwpLayout::LwpLayout( LwpObjectHeader &objHdr, LwpSvStream* pStrm ) :
1487         LwpMiddleLayout(objHdr, pStrm), m_pUseWhen(new LwpUseWhen)
1488 {}
1489
1490 LwpLayout::~LwpLayout()
1491 {
1492         if (m_pUseWhen)
1493         {
1494                 delete m_pUseWhen;
1495         }
1496 }
1497
1498 void LwpLayout::Read()
1499 {
1500         LwpObjectStream* pStrm = m_pObjStrm;
1501
1502         LwpMiddleLayout::Read();
1503         if (LwpFileHeader::m_nFileRevision < 0x000B)
1504         {
1505                 // read PreRevBLayout...
1506         }
1507         else
1508         {
1509                 sal_uInt16 nSimple;
1510                 pStrm->QuickRead(&nSimple, 2);
1511
1512                 if (!nSimple)
1513                 {
1514                         m_pUseWhen->Read(pStrm);
1515
1516                         sal_uInt8 nFlag;
1517                         pStrm->QuickRead(&nFlag, 1);
1518                         if (nFlag)
1519                         {
1520                                 m_Positon.ReadIndexed(pStrm);
1521                         }
1522                 }
1523
1524                 m_LayColumns.ReadIndexed(pStrm);
1525                 m_LayGutterStuff.ReadIndexed(pStrm);
1526                 m_LayJoinStuff.ReadIndexed(pStrm);
1527                 m_LayShadow.ReadIndexed(pStrm);
1528
1529                 if (pStrm->CheckExtra())
1530                 {
1531                         m_LayExtJoinStuff.ReadIndexed(pStrm);
1532                         pStrm->SkipExtra();
1533                 }
1534         }
1535 }
1536
1537 /**
1538 * @descr:       Get columns number
1539 *
1540 */
1541 sal_uInt16 LwpLayout::GetNumCols()
1542 {
1543         if(m_nOverrideFlag & OVER_COLUMNS)
1544         {
1545                 LwpLayoutColumns* pLayColumns = static_cast<LwpLayoutColumns*>(m_LayColumns.obj());
1546                 if(pLayColumns)
1547                 {
1548                         return pLayColumns->GetNumCols();
1549                 }
1550         }
1551
1552         LwpVirtualLayout* pStyle = static_cast<LwpVirtualLayout*> (m_BasedOnStyle.obj());
1553         if(pStyle)
1554         {
1555                 return pStyle->GetNumCols();
1556         }
1557
1558         return LwpVirtualLayout::GetNumCols();
1559
1560 }
1561
1562 /**
1563 * @descr:       Get column width
1564 * @param:       the order of column
1565 */
1566 double LwpLayout::GetColWidth(sal_uInt16 nIndex)
1567 {
1568         if((m_nOverrideFlag & OVER_COLUMNS)||(m_nAttributes2 & STYLE2_LOCALCOLUMNINFO))
1569         {
1570                 LwpLayoutColumns* pLayColumns = static_cast<LwpLayoutColumns*>(m_LayColumns.obj());
1571                 if(pLayColumns)
1572                 {
1573                         return pLayColumns->GetColWidth(nIndex);
1574                 }
1575         }
1576
1577         LwpVirtualLayout* pStyle = static_cast<LwpVirtualLayout*> (m_BasedOnStyle.obj());
1578         if(pStyle)
1579         {
1580                 return pStyle->GetColWidth(nIndex);
1581         }
1582
1583         return LwpVirtualLayout::GetColWidth(nIndex);
1584
1585 }
1586
1587 /**
1588 * @descr:       Get gap between columns
1589 * @param:       the order of column
1590 */
1591 double LwpLayout::GetColGap(sal_uInt16 nIndex)
1592 {
1593         if((m_nOverrideFlag & OVER_COLUMNS)||(m_nAttributes2 & STYLE2_LOCALCOLUMNINFO))
1594         {
1595                 LwpLayoutColumns* pLayColumns = static_cast<LwpLayoutColumns*>(m_LayColumns.obj());
1596                 if(pLayColumns)
1597                 {
1598                         return pLayColumns->GetColGap(nIndex);
1599                 }
1600         }
1601
1602         LwpVirtualLayout* pStyle = static_cast<LwpVirtualLayout*> (m_BasedOnStyle.obj());
1603         if(pStyle)
1604         {
1605                 return pStyle->GetColGap(nIndex);
1606         }
1607
1608         return LwpVirtualLayout::GetColGap(nIndex);
1609 }
1610
1611 /**
1612 * @descr:       Create and return XFColumns object
1613 *
1614 */
1615 XFColumns* LwpLayout::GetXFColumns()
1616 {
1617         //if there is only one column, do not need insert columns
1618         sal_uInt16 nCols = GetNumCols();
1619         if(nCols==1)
1620         {
1621                 return NULL;
1622         }
1623
1624         XFColumns* pColumns = new XFColumns();
1625         //set XFColumnSep
1626         XFColumnSep* pColumnSep = GetColumnSep();
1627         if(pColumnSep)
1628         {
1629                 pColumns->SetSeperator(*pColumnSep);
1630         }
1631
1632         //set column count and column gap
1633         pColumns->SetCount(nCols);
1634         double fGap = GetColGap(0);
1635         pColumns->SetGap(fGap);
1636
1637         //set xfcolumn
1638         for(sal_uInt16 nIndex = 0; nIndex<nCols; nIndex++)
1639         {
1640                 XFColumn* pColumn = new XFColumn();
1641                 sal_Int32 nWidth = static_cast<sal_Int32>(GetColWidth(nIndex));
1642                 nWidth=8305/nCols;      //relative width
1643                 pColumn->SetRelWidth(nWidth);
1644
1645                 //the left and right margins is 0;
1646                 double nGap = GetColGap(nIndex)/2;
1647                 //nGap=0;
1648                 pColumn->SetMargins(nGap,nGap);
1649                 if(nIndex==0)
1650                 {
1651                         pColumn->SetMargins(0,nGap);
1652                 }
1653                 if(nIndex==(nCols-1))
1654                 {
1655                         pColumn->SetMargins(nGap,0);
1656                 }
1657                 pColumns->AddColumn(*pColumn);
1658         }
1659
1660         return pColumns;
1661 }
1662
1663 /**
1664 * @descr:       Create and return XFColumnSep object
1665 *
1666 */
1667 XFColumnSep* LwpLayout::GetColumnSep()
1668 {
1669
1670         //Get LwpLayoutGutters
1671         LwpLayoutGutters* pLayoutGutters = static_cast<LwpLayoutGutters*>(m_LayGutterStuff.obj());
1672         if(!pLayoutGutters)
1673         {
1674                 return NULL;
1675         }
1676
1677         LwpBorderStuff* pBorderStuff = pLayoutGutters->GetBorderStuff();
1678
1679         if(pBorderStuff)
1680         {
1681                 LwpBorderStuff::BorderType eType = LwpBorderStuff::LEFT;
1682                 LwpColor        aColor = pBorderStuff->GetSideColor(eType);
1683                 double  fWidth = pBorderStuff->GetSideWidth(eType);
1684                 //sal_uInt16    nType = pBorderStuff->GetSideType(eType);
1685
1686                 XFColumnSep* pColumnSep = new XFColumnSep();
1687                 XFColor aXFColor(aColor.To24Color());
1688                 pColumnSep->SetColor(aXFColor);
1689                 pColumnSep->SetWidth(fWidth);
1690                 pColumnSep->SetRelHeight(100);
1691                 pColumnSep->SetVerticalAlign(enumXFAlignTop);
1692
1693                 return pColumnSep;
1694         }
1695         return NULL;
1696
1697 }
1698
1699 /**
1700 * @descr:       Get use when type
1701 *
1702 */
1703 LwpLayout::UseWhenType LwpLayout::GetUseWhenType()
1704 {
1705         UseWhenType eType = StartWithinPage;
1706         LwpUseWhen* pUseWhen = GetUseWhen();
1707         if(pUseWhen)
1708         {
1709                 if(pUseWhen->IsStartOnThisHF())
1710                 {
1711                         eType =  StartWithinColume;
1712                 }
1713                 else if(pUseWhen->IsStartOnThisPage())
1714                 {
1715                         eType =  StartWithinPage;
1716                 }
1717                 else if(pUseWhen->IsStartOnNextPage())
1718                 {
1719                         eType = StartOnNextPage;
1720                 }
1721                 else if(pUseWhen->IsStartOnNextOddPage())
1722                 {
1723                         eType =  StartOnOddPage;
1724                 }
1725                 else if(pUseWhen->IsStartOnNextEvenPage())
1726                 {
1727                         eType =   StartOnEvenPage;
1728                 }
1729
1730         }
1731         else
1732         {
1733                 eType =   StartOnNextPage;
1734         }
1735         return eType;
1736 }
1737
1738 /**
1739 * @descr:       Get use page
1740 *
1741 */
1742 sal_uInt16 LwpLayout::GetUsePage()
1743 {
1744         if(m_nOverrideFlag & OVER_PLACEMENT)
1745         {
1746                 LwpUseWhen* pUseWhen = GetUseWhen();
1747                 if(pUseWhen)
1748                         return pUseWhen->GetUsePage();
1749                 else
1750                         return NULL;
1751         }
1752         else if( !m_BasedOnStyle.IsNull() )
1753         {
1754                 LwpLayout* pLay = static_cast<LwpLayout*> ( m_BasedOnStyle.obj() );
1755                 return pLay->GetUsePage();
1756         }
1757         return 0;
1758 }
1759
1760 /**
1761 * @descr:       Get usewhen pointer
1762 *
1763 */
1764 LwpUseWhen* LwpLayout::VirtualGetUseWhen()
1765 {
1766         if(m_nOverrideFlag & OVER_PLACEMENT)
1767         {
1768                 return m_pUseWhen;
1769         }
1770         else if( !m_BasedOnStyle.IsNull() )
1771         {
1772                 LwpLayout* pLay = static_cast<LwpLayout*> ( m_BasedOnStyle.obj() );
1773                 return pLay->VirtualGetUseWhen();
1774         }
1775         return LwpVirtualLayout::VirtualGetUseWhen();
1776 }
1777
1778 /**
1779 * @descr:       Whether it is use on all pages
1780 *
1781 */
1782 sal_Bool LwpLayout::IsUseOnAllPages()
1783 {
1784         if(m_nOverrideFlag & OVER_PLACEMENT)
1785         {
1786                 LwpUseWhen* pUseWhen = GetUseWhen();
1787                 if(pUseWhen)
1788                         return pUseWhen->IsUseOnAllPages();
1789                 else
1790                         return NULL;
1791         }
1792         else if( !m_BasedOnStyle.IsNull() )
1793         {
1794                 LwpLayout* pLay = static_cast<LwpLayout*> ( m_BasedOnStyle.obj() );
1795                 return pLay->IsUseOnAllPages();
1796         }
1797         return LwpVirtualLayout::IsUseOnAllPages();
1798 }
1799
1800 /**
1801 * @descr:       Whether it is use on all even pages
1802 *
1803 */
1804 sal_Bool LwpLayout::IsUseOnAllEvenPages()
1805 {
1806         if(m_nOverrideFlag & OVER_PLACEMENT)
1807         {
1808                 LwpUseWhen* pUseWhen = GetUseWhen();
1809                 if(pUseWhen)
1810                         return pUseWhen->IsUseOnAllEvenPages();
1811                 else
1812                         return NULL;
1813         }
1814         else if( !m_BasedOnStyle.IsNull() )
1815         {
1816                 LwpLayout* pLay = static_cast<LwpLayout*> ( m_BasedOnStyle.obj() );
1817                 return pLay->IsUseOnAllEvenPages();
1818         }
1819         return LwpVirtualLayout::IsUseOnAllEvenPages();
1820 }
1821
1822 /**
1823 * @descr:       Whether it is use on all odd pages
1824 *
1825 */
1826 sal_Bool LwpLayout::IsUseOnAllOddPages()
1827 {
1828         if(m_nOverrideFlag & OVER_PLACEMENT)
1829         {
1830                 LwpUseWhen* pUseWhen = GetUseWhen();
1831                 if(pUseWhen)
1832                         return pUseWhen->IsUseOnAllOddPages();
1833                 else
1834                         return NULL;
1835         }
1836         else if( !m_BasedOnStyle.IsNull() )
1837         {
1838                 LwpLayout* pLay = static_cast<LwpLayout*> ( m_BasedOnStyle.obj() );
1839                 return pLay->IsUseOnAllOddPages();
1840         }
1841         return LwpVirtualLayout::IsUseOnAllOddPages();
1842 }
1843
1844 /**
1845 * @descr:       Whether it is use on current page
1846 *
1847 */
1848 sal_Bool LwpLayout::IsUseOnPage()
1849 {
1850         if(m_nOverrideFlag & OVER_PLACEMENT)
1851         {
1852                 LwpUseWhen* pUseWhen = GetUseWhen();
1853                 if(pUseWhen)
1854                         return pUseWhen->IsUseOnPage();
1855                 else
1856                         return NULL;
1857         }
1858         else if( !m_BasedOnStyle.IsNull() )
1859         {
1860                 LwpLayout* pLay = static_cast<LwpLayout*> ( m_BasedOnStyle.obj() );
1861                 return pLay->IsUseOnPage();
1862         }
1863         return LwpVirtualLayout::IsUseOnPage();
1864 }
1865
1866 /**
1867  * @descr:  Get the LwpShadow object according to m_LayShadow id.
1868  * @param:
1869  * @param:
1870  * @return:
1871 */
1872 LwpShadow* LwpLayout::GetShadow()
1873 {
1874         if(m_nOverrideFlag & OVER_SHADOW)
1875         {
1876                 LwpLayoutShadow* pLayoutShadow = static_cast<LwpLayoutShadow*>(m_LayShadow.obj());
1877                 return pLayoutShadow->GetShadow();
1878         }
1879         else if( !m_BasedOnStyle.IsNull() )
1880         {
1881                 LwpLayout* pLay = static_cast<LwpLayout*> ( m_BasedOnStyle.obj() );
1882                 return pLay->GetShadow();
1883         }
1884         return NULL;
1885 }
1886
1887 /**
1888  * @descr:  create xfshadow
1889  * @param:
1890  * @param:
1891  * @return:
1892 */
1893 XFShadow* LwpLayout::GetXFShadow()
1894 {
1895         LwpShadow* pShadow = GetShadow();
1896         if( pShadow )
1897         {
1898                 LwpColor color = pShadow->GetColor();
1899                 double  offsetX = pShadow->GetOffsetX();
1900                 double  offsetY = pShadow->GetOffsetY();
1901
1902                 if( offsetX && offsetY && color.IsValidColor() )
1903                 {
1904                         XFShadow* pXFShadow = new XFShadow();
1905                         enumXFShadowPos eXFShadowPos = enumXFShadowLeftTop;
1906                         double fOffset = 0;
1907
1908                         sal_Bool left = sal_False;
1909                         sal_Bool top = sal_False;
1910                         if( offsetX < 0 )
1911                                 left = sal_True;
1912                         if( offsetY < 0 )
1913                                 top = sal_True;
1914                         if( left )
1915                         {
1916                                 fOffset = -offsetX;
1917                                 if( top )
1918                                         eXFShadowPos = enumXFShadowLeftTop;
1919                                 else
1920                                         eXFShadowPos = enumXFShadowLeftBottom;
1921                         }
1922                         else
1923                         {
1924                                 fOffset = offsetX;
1925                                 if( top )
1926                                         eXFShadowPos = enumXFShadowRightTop;
1927                                 else
1928                                         eXFShadowPos = enumXFShadowRightBottom;
1929                         }
1930
1931                         pXFShadow->SetPosition(eXFShadowPos);
1932                         pXFShadow->SetOffset(fOffset);
1933                         pXFShadow->SetColor(XFColor(color.To24Color()));
1934
1935                         return pXFShadow;
1936                 }
1937         }
1938         return NULL;
1939 }
1940
1941 /**
1942  * @descr get the layout that containers the current frame layout
1943  *
1944  */
1945 LwpVirtualLayout* LwpLayout::GetContainerLayout()
1946 {
1947         if(IsRelativeAnchored())
1948         {
1949                 //get position
1950                 LwpPara* pPara = static_cast<LwpPara*>(GetPosition()->obj());
1951                 if(pPara)
1952                 {
1953                         LwpStory* pStory = pPara->GetStory();
1954                         return pStory->GetTabLayout();
1955                 }
1956         }
1957         return GetParentLayout();
1958 }
1959
1960 LwpPlacableLayout::LwpPlacableLayout( LwpObjectHeader &objHdr, LwpSvStream* pStrm )
1961         : LwpLayout(objHdr, pStrm),m_pFont(NULL)
1962 {}
1963
1964 LwpPlacableLayout::~LwpPlacableLayout()
1965 {}
1966
1967 void LwpPlacableLayout::Read()
1968 {
1969         LwpObjectStream* pStrm = m_pObjStrm;
1970         LwpLayout::Read();
1971         if(LwpFileHeader::m_nFileRevision < 0x000B)
1972         {
1973                 assert(false);
1974         }
1975         else
1976         {
1977                 sal_uInt16 simple;
1978                 pStrm->QuickRead(&simple, sizeof(simple));
1979                 if(!simple)
1980                 {
1981                         pStrm->QuickRead(&m_nWrapType, sizeof(m_nWrapType));
1982                         pStrm->QuickRead(&m_nBuoyancy, sizeof(m_nBuoyancy));
1983                         pStrm->QuickRead(&m_nBaseLineOffset, sizeof(m_nBaseLineOffset));
1984                         m_Script.Read( pStrm);
1985                 }
1986                 else
1987                 {
1988                         m_nWrapType = LAY_WRAP_AROUND;
1989                         m_nBuoyancy = LAY_BUOYNEUTRAL;
1990                         m_nBaseLineOffset        = 0;
1991                 }
1992                 m_LayRelativity.ReadIndexed( pStrm);
1993                 if(pStrm->CheckExtra())
1994                 {
1995                         sal_uInt16 count;
1996                         pStrm->QuickRead(&count, sizeof(count));
1997                         if(count)
1998                         {
1999                                 // temporily added by  to avoid assertion
2000                                 while (count)
2001                                 {
2002                                         LwpPoint aPoint;
2003                                         aPoint.Read(pStrm);
2004                                         count--;
2005                                 }
2006                                 // end added by
2007                         }
2008                         pStrm->SkipExtra();
2009                 }
2010         }
2011 }
2012 /**
2013  * @descr:  get wrap type
2014  * @param:
2015  * @param:
2016  * @return:
2017 */
2018 sal_uInt8 LwpPlacableLayout::GetWrapType()
2019 {
2020         if(m_nOverrideFlag & OVER_PLACEMENT)
2021         {
2022                 return m_nWrapType;
2023         }
2024         else if( !m_BasedOnStyle.IsNull() )
2025         {
2026                 LwpPlacableLayout* pLay = static_cast<LwpPlacableLayout*> ( m_BasedOnStyle.obj() );
2027                 return pLay->GetWrapType();
2028         }
2029         return LAY_WRAP_AROUND;
2030 }
2031 /**
2032  * @descr:  get LayoutRelativity
2033  * @param:
2034  * @param:
2035  * @return:
2036 */
2037 LwpLayoutRelativity* LwpPlacableLayout::GetRelativityPiece()
2038 {
2039         if(!m_LayRelativity.IsNull())
2040         {
2041                 if(m_nOverrideFlag & OVER_PLACEMENT)
2042                 {
2043                         return static_cast<LwpLayoutRelativity*>(m_LayRelativity.obj());
2044                 }
2045         }
2046         else if( !m_BasedOnStyle.IsNull() )
2047         {
2048                 LwpPlacableLayout* pLay = static_cast<LwpPlacableLayout*> ( m_BasedOnStyle.obj() );
2049                 return pLay->GetRelativityPiece();
2050         }
2051         return NULL;
2052 }
2053 /**
2054 * @descr:       Get relative type
2055 *
2056 */
2057 sal_uInt8 LwpPlacableLayout::GetRelativeType()
2058 {
2059         LwpLayoutRelativity* pLayRel = GetRelativityPiece();
2060         if(pLayRel)
2061         {
2062                 return pLayRel->GetRelGuts()->GetRelativeType();
2063         }
2064         return LwpVirtualLayout::GetRelativeType();
2065 }
2066 /**
2067 * @descr:       Get relative from where type
2068 *
2069 */
2070 sal_uInt8 LwpPlacableLayout::GetRelativeFromWhere()
2071 {
2072         LwpLayoutRelativity* pLayRel = GetRelativityPiece();
2073         if(pLayRel)
2074         {
2075                 return pLayRel->GetRelGuts()->GetRelativeFromWhere();
2076         }
2077         return 0;
2078 }
2079 /**
2080 * @descr:       Get relative distance
2081 *
2082 */
2083 LwpPoint LwpPlacableLayout::GetRelativeDistance()
2084 {
2085         LwpPoint aPoint;
2086         LwpLayoutRelativity* pLayRel = GetRelativityPiece();
2087         if(pLayRel)
2088         {
2089                 aPoint = pLayRel->GetRelGuts()->GetRelativeDistance();
2090         }
2091         return aPoint;
2092 }
2093 /**
2094 * @descr:       Get tether type
2095 *
2096 */
2097 sal_uInt8 LwpPlacableLayout::GetTetherType()
2098 {
2099         LwpLayoutRelativity* pLayRel = GetRelativityPiece();
2100         if(pLayRel)
2101         {
2102                 return pLayRel->GetRelGuts()->GetTetherType();
2103         }
2104         return 0;
2105 }
2106 /**
2107 * @descr:       Get tether where type
2108 *
2109 */
2110 sal_uInt8 LwpPlacableLayout::GetTetherWhere()
2111 {
2112         LwpLayoutRelativity* pLayRel = GetRelativityPiece();
2113         if(pLayRel)
2114         {
2115                 return pLayRel->GetRelGuts()->GetTetherWhere();
2116         }
2117         return 0;
2118 }
2119 /**
2120 * @descr:       Get offset from the baseline
2121 *
2122 */
2123 sal_Int32 LwpPlacableLayout::GetBaseLineOffset()
2124 {
2125         /* The baseline is only valid if this is flow-with-text */
2126         if(GetRelativeType()!=LwpLayoutRelativityGuts::LAY_INLINE)
2127         {
2128                 return 0;
2129         }
2130
2131         // First, ask our content if it has a baseline, ignore now
2132         /*
2133         if (Content && Content->GetBaseLineOffset(&Baseline))
2134                 return Baseline;
2135         */
2136
2137         if(m_nOverrideFlag & OVER_PLACEMENT)
2138         {
2139                 return m_nBaseLineOffset;
2140         }
2141         else if( !m_BasedOnStyle.IsNull() )
2142         {
2143                 LwpPlacableLayout* pLay = static_cast<LwpPlacableLayout*> ( m_BasedOnStyle.obj() );
2144                 return pLay->GetBaseLineOffset();
2145         }
2146         return 0;
2147
2148
2149 }
2150 /**
2151 * @descr:       whether the parent layout is page layout
2152 *
2153 */
2154 sal_Bool LwpPlacableLayout::IsAnchorPage()
2155 {
2156         if(IsRelativeAnchored())
2157                 return sal_False;
2158
2159         LwpVirtualLayout* pLayout = GetParentLayout();
2160         if(pLayout && (pLayout->IsPage() || pLayout->IsHeader() || pLayout->IsFooter()))
2161         //if(pLayout && pLayout->IsPage())
2162         {
2163                 return sal_True;
2164         }
2165         return sal_False;
2166 }
2167 /**
2168 * @descr:       whether the parent layout is frame layout
2169 *
2170 */
2171 sal_Bool LwpPlacableLayout::IsAnchorFrame()
2172 {
2173         if(IsRelativeAnchored())
2174                 return sal_False;
2175
2176         LwpVirtualLayout* pLayout = GetParentLayout();
2177         if(pLayout && (pLayout->IsFrame()||pLayout->IsGroupHead()))
2178         {
2179                 return sal_True;
2180         }
2181         return sal_False;
2182 }
2183 /**
2184 * @descr:       whether the parent layout is cell layout
2185 *
2186 */
2187 sal_Bool LwpPlacableLayout::IsAnchorCell()
2188 {
2189         if(IsRelativeAnchored())
2190                 return sal_False;
2191
2192         LwpVirtualLayout* pLayout = GetParentLayout();
2193         if(pLayout && pLayout->IsCell())
2194         {
2195                 return sal_True;
2196         }
2197         return sal_False;
2198 }
2199
2200 /**
2201 * @descr:       Get font style for setting position of frame
2202 *
2203 */
2204 XFFont* LwpPlacableLayout::GetFont()
2205 {
2206         return m_pFont;
2207 }
2208 /**
2209 * @descr:       Set font style for setting position of frame
2210 *
2211 */
2212 void LwpPlacableLayout::SetFont(XFFont * pFont)
2213 {
2214         m_pFont = pFont;
2215 }