lotuswordpro/source/filter/lwpframelayout.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  *  the class for VO_FrameLayout
  59  ************************************************************************/
  60
  61 #include "lwpframelayout.hxx"
  62 #include "lwppara.hxx"
  63 #include "xfilter/xfstylemanager.hxx"
  64 #include "xfilter/xfparagraph.hxx"
  65 #include "xfilter/xffloatframe.hxx"
  66 #include "xfilter/xfrubystyle.hxx"
  67 #include "lwppagelayout.hxx"
  68 #include "lwpoleobject.hxx"
  69 #include "lwptablelayout.hxx"
  70 #include "lwpgrfobj.hxx"
  71 #include "lwpglobalmgr.hxx"
  72
  73 LwpFrame::LwpFrame(LwpPlacableLayout* pLayout):m_pLayout(pLayout)
  74 {
  75 }
  76
  77 LwpFrame::~LwpFrame()
  78 {
  79 }
  80 /**
  81 * @descr:  parse frame
  82 * @param:  register frame style
  83 * @param:  pFrameStyle - Frame Style object
  84 *
  85 */
  86 void  LwpFrame::RegisterStyle(XFFrameStyle* pFrameStyle)
  87 {
  88     ApplyWrapType(pFrameStyle);
  89     ApplyMargins(pFrameStyle);
  90     ApplyPadding(pFrameStyle);
  91     ApplyBorders(pFrameStyle);
  92     ApplyColumns(pFrameStyle);
  93     ApplyShadow(pFrameStyle);
  94     ApplyBackGround(pFrameStyle);
  95     ApplyWatermark(pFrameStyle);
  96 //  ApplyBackColor(pFrameStyle);
  97     ApplyProtect(pFrameStyle);
  98     ApplyTextDir(pFrameStyle);
  99     ApplyPosType(pFrameStyle);
 100
 101     pFrameStyle->SetStyleName(m_pLayout->GetName().str());
 102     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
 103     m_StyleName = pXFStyleManager->AddStyle(pFrameStyle).m_pStyle->GetStyleName();
 104     m_pLayout->SetStyleName(m_StyleName);
 105 }
 106 /**
 107 * @descr:  parse frame and set frame properties
 108 * @param:   pXFFrame - XFFrame object
 109 * @param:  nPageNo - the page number that the frame anchors
 110 *
 111 */
 112  void LwpFrame::Parse(XFFrame* pXFFrame, sal_Int32 nPageNo)
 113  {
 114     //set the frame style name
 115     pXFFrame->SetStyleName(m_StyleName);
 116
 117     //SetAnchorType and position,if it's page anchor,set the page number.
 118     ParseAnchorType(pXFFrame);
 119     if(nPageNo>0)
 120     {
 121         pXFFrame->SetAnchorPage(nPageNo);
 122     }
 123
 124     //Set frame Name
 125     OUString aFrameName = m_pLayout->GetName().str();
 126     if(!aFrameName.isEmpty())
 127     {
 128         //cause the bug of SODC, the linkframe name can not be "Frame1", so I change the frame name
 129         /*if(aFrameName.equals("Frame1"))
 130         {
 131             aFrameName = "Frame1_COPY";
 132         }
 133         pXFFrame->SetName(aFrameName);*/
 134         pXFFrame->SetName(m_StyleName);
 135     }
 136
 137     LwpLayoutGeometry* pLayoutGeo = m_pLayout->GetGeometry();
 138     //Set frame Width and height
 139     if(pLayoutGeo)
 140     {
 141         double fWidth = m_pLayout->GetWidth();
 142         double fHeight = m_pLayout->GetHeight();
 143
 144         pXFFrame->SetWidth( fWidth );
 145         pXFFrame->SetHeight( fHeight );
 146
 147         //Get content obj;
 148         /*LwpObject* pObj =*/ m_pLayout->GetContent().obj();
 149         if(m_pLayout->IsGroupHead()&&(m_pLayout->IsMinimumHeight()))
 150         {
 151             //process grouplayout height. there is problems now
 152             pXFFrame->SetHeight( fHeight );
 153         }
 154         /*
 155         else if(m_pLayout->IsFitGraphic() && pObj && pObj->GetTag() == VO_GRAPHIC)
 156         {
 157             //If is graphic, get original size and set it;
 158             LwpGraphicObject* pGrpObj = static_cast<LwpGraphicObject*>(pObj);
 159             long nHeight =0, nWidth =0;
 160             pGrpObj->GetGrafOrgSize(nWidth, nHeight);
 161             //add margins to the width and height;
 162             fWidth = (double)nWidth/TWIPS_PER_CM + m_pLayout->GetMarginsValue(MARGIN_LEFT) + m_pLayout->GetMarginsValue(MARGIN_RIGHT);
 163             fHeight = (double)nHeight/TWIPS_PER_CM + m_pLayout->GetMarginsValue(MARGIN_TOP) + m_pLayout->GetMarginsValue(MARGIN_BOTTOM);
 164             pXFFrame->SetWidth(fWidth);
 165             pXFFrame->SetHeight(fHeight);
 166         }
 167         */
 168         else if(m_pLayout->IsAutoGrow())
 169         {
 170             pXFFrame->SetMinHeight( fHeight );
 171         }
 172     }
 173
 174     if(m_pLayout->IsFrame())
 175     {
 176         //Set frame link. Only frame layout has this feature
 177         LwpFrameLayout* pLayout= static_cast<LwpFrameLayout*>(m_pLayout);
 178         pXFFrame->SetNextLink(pLayout->GetNextLinkName());
 179     }
 180
 181  }
 182 /**
 183 * @descr:  parse frame relative to page, frame or cell
 184 * @param:   pCont - content container which contains the frame
 185 *
 186 */
 187  void LwpFrame::XFConvert(XFContentContainer* pCont)
 188  {
 189     // parse the frame which anchor to page
 190     rtl::Reference<LwpVirtualLayout> xParent = m_pLayout->GetParentLayout();
 191     if (!xParent.is())
 192         throw std::runtime_error("missing Parent Layout");
 193     if (xParent->IsPage() && xParent->GetParentLayout().is() && xParent->GetParentLayout()->IsPage())
 194     {
 195         //for mirror page, problems exist if the parent layout is header or footer layout,
 196         xParent = xParent->GetParentLayout();
 197     }
 198     if(m_pLayout->IsAnchorPage()&& xParent->IsPage())
 199     {
 200         //get parent layout
 201         if(m_pLayout->IsUseOnPage())
 202         {
 203             sal_Int32 nPageNo = xParent->GetPageNumber(m_pLayout->GetUsePage());
 204             if(nPageNo>0)
 205                 m_pLayout->XFConvertFrame(pCont, nPageNo);
 206         }
 207         else if(m_pLayout->IsUseOnAllPages())
 208         {
 209             sal_Int32 nFirst = xParent->GetPageNumber(FIRST_LAYOUTPAGENO);
 210             sal_Int32 nLast = xParent->GetPageNumber(LAST_LAYOUTPAGENO);
 211             if(nLast > 0)
 212                 m_pLayout->XFConvertFrame(pCont, nFirst, nLast, true);
 213
 214         }
 215         else if(m_pLayout->IsUseOnAllOddPages()||m_pLayout->IsUseOnAllEvenPages())
 216         {
 217             sal_Int32 nFirst = xParent->GetPageNumber(FIRST_LAYOUTPAGENO);
 218             sal_Int32 nLast = xParent->GetPageNumber(LAST_LAYOUTPAGENO);
 219             if(nLast > 0)
 220             {
 221                 sal_uInt16 first = static_cast<sal_uInt16>(nFirst);
 222                 if((m_pLayout->IsUseOnAllOddPages() && !LwpTools::IsOddNumber(first))
 223                 || (m_pLayout->IsUseOnAllEvenPages() && !LwpTools::IsEvenNumber(first)))
 224                     nFirst++;
 225                 if(nFirst <= nLast)
 226                 {
 227                     m_pLayout->XFConvertFrame(pCont, nFirst, nLast);
 228                 }
 229             }
 230         }
 231     }
 232     else
 233     {
 234         m_pLayout->XFConvertFrame(pCont);
 235     }
 236
 237  }
 238 /**
 239 * @descr:  set frame wrap type style
 240 * @param:  pFrameStyle - Frame Style object
 241 *
 242 */
 243 void LwpFrame::ApplyWrapType(XFFrameStyle *pFrameStyle)
 244 {
 245     enumXFWrap eWrap = enumXFWrapNone;
 246     switch(m_pLayout->GetWrapType())
 247     {
 248         case LwpPlacableLayout::LAY_WRAP_AROUND:    //fall through
 249         case LwpPlacableLayout::LAY_WRAP_IRREG_BIGGEST:
 250         {
 251             //In SODC, if Optimal wrap type is used and the distance between the frame object
 252             //and page margins is less than 2cm, the text is not wrapped. While there is no this feature in Word Pro
 253             //So the optimal wrap type is translated to left side or right side wrap type according to the distance
 254             //between the frame object and page margins
 255
 256             eWrap = enumXFWrapBest;
 257             rtl::Reference<LwpVirtualLayout> xContainer(m_pLayout->GetContainerLayout());
 258             LwpMiddleLayout* pParent = dynamic_cast<LwpMiddleLayout*>(xContainer.get());
 259             if(pParent)
 260             {
 261                 if(IsLeftWider())
 262                     eWrap = enumXFWrapLeft;
 263                 else
 264                     eWrap = enumXFWrapRight;
 265             }
 266             break;
 267         }
 268         case LwpPlacableLayout::LAY_NO_WRAP_BESIDE:
 269         {
 270             eWrap = enumXFWrapNone;
 271             break;
 272         }
 273         case LwpPlacableLayout::LAY_NO_WRAP_AROUND:
 274         {
 275             eWrap = enumXFWrapRunThrough;
 276             if(!m_pLayout->GetBackColor() && !m_pLayout->GetWaterMarkLayout().is())
 277             {
 278                 //pFrameStyle->SetBackGround(sal_True);
 279                 XFColor aXFColor(0xffffff); //white color
 280                 pFrameStyle->SetBackColor(aXFColor);
 281                 pFrameStyle->SetTransparency(100);  //transparency
 282             }
 283             break;
 284         }
 285         case LwpPlacableLayout::LAY_WRAP_LEFT:      //fall through
 286         case LwpPlacableLayout::LAY_WRAP_IRREG_LEFT:
 287         {
 288             eWrap = enumXFWrapLeft;
 289             break;
 290         }
 291         case LwpPlacableLayout::LAY_WRAP_RIGHT: //fall through
 292         case LwpPlacableLayout::LAY_WRAP_IRREG_RIGHT:
 293         {
 294             eWrap = enumXFWrapRight;
 295             break;
 296         }
 297         case LwpPlacableLayout::LAY_WRAP_BOTH:  //fall through
 298         case LwpPlacableLayout::LAY_WRAP_IRREG_BOTH:
 299         {
 300             eWrap = enumXFWrapParallel;
 301             break;
 302         }
 303         default:
 304             break;
 305     }
 306
 307     //If it is the type of with para above, wrap type is enumXFWrapNone
 308     if(m_pLayout->GetRelativeType()==LwpLayoutRelativityGuts::LAY_INLINE_NEWLINE)
 309     {
 310         eWrap = enumXFWrapNone;
 311     }
 312
 313     pFrameStyle->SetWrapType(eWrap);
 314 }
 315 /**
 316 * @descr:   set frame margins style
 317 * @param:  pFrameStyle - Frame Style object
 318 *
 319 */
 320 void LwpFrame::ApplyMargins(XFFrameStyle *pFrameStyle)
 321 {
 322     double fLeft    = m_pLayout->GetExtMarginsValue(MARGIN_LEFT);
 323     double fRight   = m_pLayout->GetExtMarginsValue(MARGIN_RIGHT);
 324     double fTop = m_pLayout->GetExtMarginsValue(MARGIN_TOP);
 325     double fBottom  = m_pLayout->GetExtMarginsValue(MARGIN_BOTTOM);
 326     pFrameStyle->SetMargins(fLeft,fRight,fTop,fBottom);
 327 }
 328 /**
 329 * @descr:  set padding border style
 330 * @param:  pFrameStyle - Frame Style object
 331 *
 332 */
 333 void LwpFrame::ApplyPadding(XFFrameStyle *pFrameStyle)
 334 {
 335     double fLeft    = m_pLayout->GetMarginsValue(MARGIN_LEFT);
 336     double fRight   = m_pLayout->GetMarginsValue(MARGIN_RIGHT);
 337     double fTop = m_pLayout->GetMarginsValue(MARGIN_TOP);
 338     double fBottom  = m_pLayout->GetMarginsValue(MARGIN_BOTTOM);
 339     pFrameStyle->SetPadding(fLeft,fRight,fTop,fBottom);
 340 }
 341 /**
 342 * @descr:  set frame border style
 343 * @param:  pFrameStyle - Frame Style object
 344 *
 345 */
 346 void LwpFrame::ApplyBorders(XFFrameStyle *pFrameStyle)
 347 {
 348     XFBorders* pBordres = m_pLayout->GetXFBorders();
 349     if(pBordres)
 350     {
 351         pFrameStyle->SetBorders(pBordres);
 352     }
 353 }
 354 /**
 355 * @descr:  set frame columns style
 356 * @param:  pFrameStyle - Frame Style object
 357 *
 358 */
 359 void LwpFrame::ApplyColumns(XFFrameStyle *pFrameStyle)
 360 {
 361     XFColumns* pColumns = m_pLayout->GetXFColumns();
 362     if(pColumns)
 363     {
 364         pFrameStyle->SetColumns(pColumns);
 365     }
 366 }
 367 /**
 368 * @descr:  set frame shadow style
 369 * @param:  pFrameStyle - Frame Style object
 370 *
 371 */
 372 void LwpFrame::ApplyShadow(XFFrameStyle* pFrameStyle)
 373 {
 374     XFShadow* pXFShadow = m_pLayout->GetXFShadow();
 375     if(pXFShadow)
 376     {
 377         pFrameStyle->SetShadow(pXFShadow);
 378     }
 379 }
 380 /**
 381 * @descr:  set frame back color style
 382 * @param:  pFrameStyle - Frame Style object
 383 *
 384 */
 385 void LwpFrame::ApplyBackColor(XFFrameStyle* pFrameStyle)
 386 {
 387     LwpColor* pColor = m_pLayout->GetBackColor();
 388     if(pColor)
 389     {
 390         XFColor aXFColor(pColor->To24Color());
 391         pFrameStyle->SetBackColor(aXFColor);
 392     }
 393 }
 394 /**
 395 * @descr:  set frame protect style
 396 * @param:  pFrameStyle - Frame Style object
 397 *
 398 */
 399 void LwpFrame::ApplyProtect(XFFrameStyle* pFrameStyle)
 400 {
 401     if(m_pLayout->GetIsProtected())
 402     {
 403         pFrameStyle->SetProtect(true,true,true);
 404     }
 405 }
 406 /**
 407 * @descr:  set frame text direction style
 408 * @param:  pFrameStyle - Frame Style object
 409 *
 410 */
 411 void LwpFrame::ApplyTextDir(XFFrameStyle* pFrameStyle)
 412 {
 413     pFrameStyle->SetTextDir(m_pLayout->GetTextDirection());
 414 }
 415 /**
 416 * @descr:  set frame position type style
 417 * @param:  pFrameStyle - Frame Style object
 418 *
 419 */
 420 void LwpFrame::ApplyPosType(XFFrameStyle* pFrameStyle)
 421 {
 422     enumXFFrameXPos eXPos = enumXFFrameXPosCenter;
 423     enumXFFrameXRel eXRel = enumXFFrameXRelPara;
 424     enumXFFrameYPos eYPos = enumXFFrameYPosMiddle;
 425     enumXFFrameYRel eYRel = enumXFFrameYRelPara;
 426     sal_uInt8 nType = m_pLayout->GetRelativeType();
 427     switch(nType)
 428     {
 429         case LwpLayoutRelativityGuts::LAY_PARENT_RELATIVE://fall through
 430         case LwpLayoutRelativityGuts::LAY_CONTENT_RELATIVE:
 431         {
 432             //anchor to page, frame and cell
 433             eXPos = enumXFFrameXPosFromLeft;
 434             eXRel = enumXFFrameXRelPage;
 435             //set vertical position
 436             if(m_pLayout->IsAnchorPage())//in page
 437             {
 438                 rtl::Reference<LwpVirtualLayout> xContainer(m_pLayout->GetContainerLayout());
 439                 if (xContainer.is() && (xContainer->IsHeader() || xContainer->IsFooter()))
 440                 {
 441                     //Only anchor to para, the frame can display in header and footer of each page
 442                     eYPos = enumXFFrameYPosFromTop; //from top
 443                     eYRel = enumXFFrameYRelPara; //from margin
 444                 }
 445                 else
 446                 {
 447                     eYPos = enumXFFrameYPosFromTop;
 448                     eYRel = enumXFFrameYRelPage;
 449                 }
 450             }
 451             if(m_pLayout->IsAnchorFrame()) //in frame
 452             {
 453                 eYPos = enumXFFrameYPosFromTop;
 454                 eYRel = enumXFFrameYRelPage;
 455             }
 456             if(m_pLayout->IsAnchorCell())
 457             {
 458                 //SODC has no this type, simulate this feature
 459                 eYPos = enumXFFrameYPosFromTop; //from top
 460                 eYRel = enumXFFrameYRelPara; //from margin
 461             }
 462             break;
 463         }
 464         case LwpLayoutRelativityGuts::LAY_PARA_RELATIVE:    //same page as text
 465         {
 466             eXPos = enumXFFrameXPosFromLeft;
 467             eXRel = enumXFFrameXRelPage;
 468             //set vertical position
 469             rtl::Reference<LwpVirtualLayout> xContainer(m_pLayout->GetContainerLayout());
 470             if (xContainer.is() && xContainer->IsPage())//in page
 471             {
 472                 //eYPos = enumXFFrameYPosFromTop;
 473                 //eYRel = enumXFFrameYRelPage;
 474                 eYPos = enumXFFrameYPosBelow;
 475                 eYRel = enumXFFrameYRelChar;
 476             }
 477             else if (xContainer.is() && xContainer->IsFrame()) //in frame
 478             {
 479                 eYPos = enumXFFrameYPosFromTop;
 480                 eYRel = enumXFFrameYRelPage;
 481             }
 482             else
 483             {
 484                 eYPos = enumXFFrameYPosFromTop; //from top
 485                 eYRel = enumXFFrameYRelPara; //from margin
 486             }
 487             break;
 488         }
 489         case LwpLayoutRelativityGuts::LAY_INLINE:   //in text
 490         {
 491             eXPos = enumXFFrameXPosFromLeft;    //need not be set
 492             eXRel = enumXFFrameXRelParaContent; //need not be set
 493             eYPos = enumXFFrameYPosTop; //should be from top
 494             eYRel = enumXFFrameYRelBaseLine;
 495             sal_Int32 nOffset = m_pLayout->GetBaseLineOffset();
 496             if(nOffset>0)
 497             {
 498                 eYPos = enumXFFrameYPosFromTop;
 499             }
 500             break;
 501         }
 502         case LwpLayoutRelativityGuts::LAY_INLINE_NEWLINE:   //with para above
 503         {
 504             eXPos = enumXFFrameXPosFromLeft;
 505             eXRel = enumXFFrameXRelParaContent;
 506             //eYPos = enumXFFrameYPosTop;
 507             eYPos = enumXFFrameYPosBottom;
 508             eYRel = enumXFFrameYRelParaContent;
 509             break;
 510         }
 511         case LwpLayoutRelativityGuts::LAY_INLINE_VERTICAL:  //in text - vertical
 512         {
 513             eXPos = enumXFFrameXPosFromLeft;
 514             eXRel = enumXFFrameXRelPage;
 515             eYPos = enumXFFrameYPosFromTop; //should be below position
 516             eYRel = enumXFFrameYRelChar;
 517             break;
 518         }
 519         default:
 520             break;
 521     }
 522
 523     pFrameStyle->SetXPosType(eXPos,eXRel);
 524     pFrameStyle->SetYPosType(eYPos,eYRel);
 525 }
 526 /**
 527 * @descr:  set frame watermark style
 528 * @param:  pFrameStyle - Frame Style object
 529 *
 530 */
 531 void LwpFrame::ApplyWatermark(XFFrameStyle *pFrameStyle)
 532 {
 533     XFBGImage* pBGImage = m_pLayout->GetXFBGImage();
 534     if(pBGImage)
 535     {
 536         pFrameStyle->SetBackImage(pBGImage);
 537         //set watermark transparent
 538         rtl::Reference<LwpVirtualLayout> xWaterMarkLayout(m_pLayout->GetWaterMarkLayout());
 539         LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*>(xWaterMarkLayout.get());
 540         LwpBackgroundStuff* pBackgroundStuff = pLay ? pLay->GetBackgroundStuff() : nullptr;
 541         if(pBackgroundStuff && !pBackgroundStuff->IsTransparent())
 542         {
 543             pFrameStyle->SetTransparency(100);
 544         }
 545      }
 546 }
 547
 548 /**
 549  * @short   Apply pattern fill to frame style
 550  * @param pFrameStyle - pointer of XFFrameStyle
 551  * @return
 552  */
 553 void LwpFrame::ApplyPatternFill(XFFrameStyle* pFrameStyle)
 554 {
 555     XFBGImage* pXFBGImage = m_pLayout->GetFillPattern();
 556     if (pXFBGImage)
 557     {
 558         pFrameStyle->SetBackImage(pXFBGImage);
 559     }
 560 }
 561
 562 /**
 563  * @short   Apply background to frame style
 564  * @param pFrameStyle - pointer of XFFrameStyle
 565  * @return
 566  */
 567 void LwpFrame::ApplyBackGround(XFFrameStyle* pFrameStyle)
 568 {
 569     if (!m_pLayout)
 570     {
 571         return;
 572     }
 573
 574     if (m_pLayout->IsPatternFill())
 575     {
 576         ApplyPatternFill(pFrameStyle);
 577     }
 578     else
 579     {
 580         ApplyBackColor(pFrameStyle);
 581     }
 582 }
 583
 584 /**
 585 * @descr:  set frame size, anchor type, anchored page number
 586 * @param:  pXFFrame - XFFrame  object
 587 *
 588 */
 589 void LwpFrame::ParseAnchorType(XFFrame *pXFFrame)
 590 {
 591     //set position
 592     double fXOffset = 0;
 593     double fYOffset = 0;
 594     //page number
 595     sal_uInt16 nPageNum = 0;
 596     //set anchor type
 597     enumXFAnchor eAnchor = enumXFAnchorNone;
 598
 599     LwpLayoutGeometry* pLayoutGeo = m_pLayout->GetGeometry();
 600     if(pLayoutGeo)
 601     {
 602         LwpPoint aPoint = pLayoutGeo->GetOrigin();
 603         fXOffset = LwpTools::ConvertFromUnitsToMetric(aPoint.GetX());
 604         fYOffset = LwpTools::ConvertFromUnitsToMetric(aPoint.GetY());
 605     }
 606     //set anchor type
 607     eAnchor = enumXFAnchorNone;
 608     sal_uInt8 nType = m_pLayout->GetRelativeType();
 609     switch(nType)
 610     {
 611         case LwpLayoutRelativityGuts::LAY_PARENT_RELATIVE://fall through
 612         case LwpLayoutRelativityGuts::LAY_CONTENT_RELATIVE:
 613         {
 614             //anchor to page, frame and cell
 615             if(m_pLayout->IsAnchorPage())//in page
 616             {
 617                 rtl::Reference<LwpVirtualLayout> xContainer(m_pLayout->GetContainerLayout());
 618                 if (xContainer.is() && (xContainer->IsHeader() || xContainer->IsFooter()))
 619                 {
 620                     eAnchor = enumXFAnchorPara;
 621                     fYOffset -= xContainer->GetMarginsValue(MARGIN_TOP);
 622                 }
 623                 else
 624                     eAnchor = enumXFAnchorPage;
 625             }
 626             if(m_pLayout->IsAnchorFrame()) //in frame
 627             {
 628                 eAnchor = enumXFAnchorFrame;
 629             }
 630             if(m_pLayout->IsAnchorCell())   //in cell
 631             {
 632                 //eAnchor = enumXFAnchorChar;
 633                 eAnchor = enumXFAnchorPara;
 634                 rtl::Reference<LwpVirtualLayout> xContainer(m_pLayout->GetContainerLayout());
 635                 LwpMiddleLayout* pContainer = dynamic_cast<LwpMiddleLayout*>(xContainer.get());
 636                 if (pContainer)
 637                 {
 638                     fYOffset -= pContainer->GetMarginsValue(MARGIN_TOP);
 639                 }
 640             }
 641             break;
 642         }
 643         case LwpLayoutRelativityGuts::LAY_PARA_RELATIVE:    //same page as text
 644         {
 645             eAnchor = enumXFAnchorChar;
 646             rtl::Reference<LwpVirtualLayout> xContainer(m_pLayout->GetContainerLayout());
 647             if (xContainer.is() && xContainer->IsPage())//in page
 648             {
 649                 //eAnchor = enumXFAnchorPage;
 650                 eAnchor = enumXFAnchorChar;// to character
 651             }
 652             else if (xContainer.is() && xContainer->IsFrame()) //in frame
 653             {
 654                 eAnchor = enumXFAnchorFrame;
 655             }
 656             else if (xContainer.is() && xContainer->IsCell()) //in cell
 657             {
 658                 //eAnchor = enumXFAnchorChar;
 659                 eAnchor = enumXFAnchorPara;
 660                 fYOffset -= xContainer->GetMarginsValue(MARGIN_TOP);
 661             }
 662             else if (xContainer.is() && (xContainer->IsHeader() || xContainer->IsFooter()))//in header or footer
 663             {
 664                 eAnchor = enumXFAnchorPara;
 665                 fYOffset -= xContainer->GetMarginsValue(MARGIN_TOP);
 666             }
 667             break;
 668         }
 669         case LwpLayoutRelativityGuts::LAY_INLINE:   //in text
 670         {
 671             eAnchor = enumXFAnchorAsChar;
 672             sal_Int32 nOffset = m_pLayout->GetBaseLineOffset();
 673             if(nOffset>0 && pLayoutGeo)
 674             {
 675                 //experiential value
 676                 fYOffset =-(m_pLayout->GetGeometryHeight()+2*m_pLayout->GetExtMarginsValue(MARGIN_BOTTOM)-LwpTools::ConvertFromUnitsToMetric(nOffset));
 677             }
 678             break;
 679         }
 680         case LwpLayoutRelativityGuts::LAY_INLINE_NEWLINE:   //with para above
 681         {
 682             eAnchor = enumXFAnchorPara;
 683             break;
 684         }
 685         case LwpLayoutRelativityGuts::LAY_INLINE_VERTICAL:  //in text - vertical
 686         {
 687             eAnchor = enumXFAnchorChar;
 688             //set vertical position
 689             double offset = 0;
 690
 691             //because of the different feature between Word Pro and SODC, I simulate the vertical base offset
 692             //between anchor and frame origin using the font height.
 693             rtl::Reference<XFFont> pFont = m_pLayout->GetFont();
 694             if(pFont.is())
 695             {
 696                 offset = (double)(pFont->GetFontSize())*CM_PER_INCH/POINTS_PER_INCH;
 697             }
 698             fYOffset = offset-fYOffset;
 699             break;
 700         }
 701         default:
 702             break;
 703     }
 704
 705     pXFFrame->SetX(fXOffset);
 706     pXFFrame->SetY(fYOffset);
 707     pXFFrame->SetAnchorPage(nPageNum);
 708     pXFFrame->SetAnchorType(eAnchor);
 709 }
 710
 711 /**
 712  * @descr Calculate the distance between the frame object and the page margins.
 713  *       And determine which side(left or right) is wider
 714  */
 715 bool LwpFrame::IsLeftWider()
 716 {
 717     rtl::Reference<LwpVirtualLayout> xLayout(m_pLayout->GetContainerLayout());
 718     LwpVirtualLayout* pParent = dynamic_cast<LwpVirtualLayout*>(xLayout.get());
 719     if (pParent)
 720     {
 721         LwpPoint aPoint = m_pLayout->GetOrigin();
 722         double fXOffset = LwpTools::ConvertFromUnitsToMetric(aPoint.GetX());
 723         double fWidth = m_pLayout->GetWidth();
 724         double fWrapLeft = m_pLayout->GetExtMarginsValue(MARGIN_LEFT);
 725         double fWrapRight = m_pLayout->GetExtMarginsValue(MARGIN_RIGHT);
 726
 727         //LwpPoint aParentPoint = pParent->GetOrigin();
 728         //double fParentXOffset = LwpTools::ConvertFromUnitsToMetric(aParentPoint.GetX());
 729         double fParentWidth = pParent->GetWidth();
 730         if(pParent->IsCell())
 731         {
 732             //Get actual width of this cell layout
 733             fParentWidth = static_cast<LwpCellLayout*>(pParent)->GetActualWidth();
 734         }
 735         double fParentMarginLeft = pParent->GetMarginsValue(MARGIN_LEFT);
 736         double fParentMarginRight = pParent->GetMarginsValue(MARGIN_RIGHT);
 737
 738         double fLeft = fXOffset - fWrapLeft -fParentMarginLeft;
 739         double fRight = fParentWidth - fParentMarginRight -(fXOffset + fWidth + fWrapRight);
 740         if(fLeft > fRight)
 741             return true;
 742     }
 743     return false;
 744 }
 745
 746 LwpFrameLink::LwpFrameLink()
 747 {}
 748
 749 LwpFrameLink::~LwpFrameLink()
 750 {}
 751
 752 /**
 753  * @descr frame link information
 754  *
 755  */
 756 void LwpFrameLink::Read(LwpObjectStream* pStrm)
 757 {
 758     m_PreviousLayout.ReadIndexed(pStrm);
 759     m_NextLayout.ReadIndexed(pStrm);
 760     pStrm->SkipExtra();
 761 }
 762
 763 LwpFrameLayout::LwpFrameLayout(LwpObjectHeader &objHdr, LwpSvStream* pStrm)
 764     : LwpPlacableLayout(objHdr, pStrm), m_pFrame(nullptr)
 765 {
 766 }
 767
 768 LwpFrameLayout::~LwpFrameLayout()
 769 {
 770     delete m_pFrame;
 771 }
 772
 773 /**
 774  * @descr read frame layout object
 775  *
 776  */
 777 void LwpFrameLayout::Read()
 778 {
 779     LwpPlacableLayout::Read();
 780     if(LwpFileHeader::m_nFileRevision >= 0x000B)
 781     {
 782         if(m_pObjStrm->QuickReaduInt16())
 783         {
 784             m_Link.Read(m_pObjStrm);
 785         }
 786     }
 787     m_pObjStrm->SkipExtra();
 788 }
 789
 790 /**
 791  * @descr create a xfframe and add into content container
 792  * @param:  pCont - content container that contains the frame.
 793  *
 794  */
 795  void LwpFrameLayout::XFConvert(XFContentContainer* pCont)
 796  {
 797     if(m_pFrame)
 798     {
 799         //parse the frame which anchor to paragraph
 800         if(IsRelativeAnchored())
 801         {
 802             XFConvertFrame(pCont);
 803         }
 804         else
 805         {
 806             m_pFrame->XFConvert(pCont);
 807         }
 808
 809     }
 810  }
 811 /**
 812  * @descr create a xfframe and add into content container, called by XFConvert
 813  * @param:  pCont - content container that contains the frame.
 814  * @param:  nPageNo - the page number that the frame anchors
 815  *
 816  */
 817 void LwpFrameLayout::XFConvertFrame(XFContentContainer* pCont, sal_Int32 nStart , sal_Int32 nEnd, bool bAll )
 818 {
 819     if(m_pFrame)
 820     {
 821         XFFrame* pXFFrame = nullptr;
 822         if(nEnd < nStart)
 823         {
 824             pXFFrame = new XFFrame();
 825         }
 826         else
 827         {
 828             pXFFrame = new XFFloatFrame(nStart, nEnd, bAll);
 829         }
 830
 831         m_pFrame->Parse(pXFFrame, nStart);
 832         //if it is a link frame, parse contents only once
 833         if(!HasPreviousLinkLayout())
 834         {
 835             rtl::Reference<LwpObject> content = m_Content.obj();
 836             if (content.is())
 837             {
 838                 content->DoXFConvert(pXFFrame);
 839                 //set frame size according to ole size
 840                 ApplyGraphicSize(pXFFrame);
 841             }
 842         }
 843         pCont ->Add(pXFFrame);
 844     }
 845 }
 846 /**
 847  * @descr register frame style
 848  *
 849  */
 850 void  LwpFrameLayout::RegisterStyle()
 851 {
 852     //if it is for water mark, don't register style
 853     if (IsForWaterMark())
 854         return;
 855
 856     if (m_pFrame)
 857         return;
 858
 859     //register frame style
 860     XFFrameStyle* pFrameStyle = new XFFrameStyle();
 861     m_pFrame = new LwpFrame(this);
 862     m_pFrame->RegisterStyle(pFrameStyle);
 863
 864     //register content style
 865     rtl::Reference<LwpObject> content = m_Content.obj();
 866     if (content.is())
 867     {
 868         content->SetFoundry(m_pFoundry);
 869         content->DoRegisterStyle();
 870     }
 871
 872     //register child frame style
 873     RegisterChildStyle();
 874 }
 875
 876 /**
 877  * @descr get the name of the frame that current frame links
 878  *
 879  */
 880 OUString LwpFrameLayout::GetNextLinkName()
 881 {
 882     OUString aName;
 883     LwpObjectID& rObjectID = m_Link.GetNextLayout();
 884     if(!rObjectID.IsNull())
 885     {
 886         LwpLayout* pLayout = dynamic_cast<LwpLayout*>(rObjectID.obj().get());
 887         if (pLayout)
 888         {
 889             LwpAtomHolder& rHolder = pLayout->GetName();
 890             aName = rHolder.str();
 891             //for division name conflict
 892             if(!pLayout->GetStyleName().isEmpty())
 893                 aName = pLayout->GetStyleName();
 894         }
 895     }
 896     return aName;
 897 }
 898 /**
 899  * @descr whether current frame is linked by other frame
 900  *
 901  */
 902 bool LwpFrameLayout::HasPreviousLinkLayout()
 903 {
 904     LwpObjectID& rObjectID = m_Link.GetPreviousLayout();
 905     if(rObjectID.IsNull())
 906         return false;
 907     return true;
 908 }
 909 /**
 910  * @descr whether current frame is for water mark. Problem maybe exists by this method, must be tracking
 911  *
 912  */
 913 bool LwpFrameLayout::IsForWaterMark()
 914 {
 915     if(m_nBuoyancy >=LAY_BUOYLAYER)
 916     {
 917         if (m_Content.IsNull())
 918             return false;
 919         rtl::Reference<LwpObject> content = m_Content.obj();
 920         if (!content.is())
 921             return false;
 922         if (content->GetTag() == VO_GRAPHIC)
 923             return true;
 924     }
 925     return false;
 926 }
 927
 928 /**
 929  * @descr Get frame width
 930  *
 931  */
 932 double LwpFrameLayout::GetWidth()
 933 {
 934     double fWidth = LwpMiddleLayout::GetWidth();
 935     if(IsInlineToMargin() && IsAutoGrowWidth())
 936     {
 937         //for text field entry when choosing maximize field length
 938         fWidth = GetMaxWidth();
 939     }
 940     return fWidth;
 941 }
 942
 943 /**
 944  * @descr Get frame width when the text field chooses maximize field length
 945  *
 946  */
 947 double LwpFrameLayout::GetMaxWidth()
 948 {
 949     double fActualWidth = 0;
 950     rtl::Reference<LwpVirtualLayout> xLayout(GetContainerLayout());
 951     LwpMiddleLayout* pParent = dynamic_cast<LwpMiddleLayout*>(xLayout.get());
 952     if (pParent)
 953     {
 954         LwpPoint aPoint = GetOrigin();
 955         double fXOffset = LwpTools::ConvertFromUnitsToMetric(aPoint.GetX());
 956         double fWrapRight = GetExtMarginsValue(MARGIN_RIGHT);
 957
 958         //Get parent layout width
 959         double fParentWidth = pParent->GetWidth();
 960         if(pParent->IsCell())
 961         {
 962             //Get actual width of this cell layout
 963             fParentWidth = static_cast<LwpCellLayout*>(pParent)->GetActualWidth();
 964         }
 965
 966         double fParentMarginRight = 0;
 967         sal_uInt8 nType = GetRelativeType();
 968         if(nType == LwpLayoutRelativityGuts::LAY_INLINE
 969             || nType == LwpLayoutRelativityGuts::LAY_INLINE_NEWLINE )
 970         {
 971             fParentMarginRight = pParent->GetMarginsValue(MARGIN_RIGHT);
 972         }
 973
 974         fActualWidth = fParentWidth - fXOffset - fParentMarginRight - fWrapRight;
 975     }
 976
 977     return fActualWidth;
 978 }
 979
 980 /**
 981  * @descr Set frame size according to graphic size
 982  *
 983  */
 984 void LwpFrameLayout::ApplyGraphicSize(XFFrame * pXFFrame)
 985 {
 986     rtl::Reference<LwpObject> content = m_Content.obj();
 987     if(content.is() && (content->GetTag() == VO_GRAPHIC
 988                 || content->GetTag() == VO_OLEOBJECT ))
 989     {
 990         LwpGraphicOleObject* pGraOle = static_cast<LwpGraphicOleObject*>(content.get());
 991         //Get frame geometry size
 992         double fWidth = 0;
 993         double fHeight = 0;
 994         pGraOle->GetGrafScaledSize(fWidth, fHeight);
 995         if( IsFitGraphic())
 996         {
 997             //graphic scaled sze
 998             fWidth += GetMarginsValue(MARGIN_LEFT) + GetMarginsValue(MARGIN_RIGHT);
 999             fHeight += GetMarginsValue(MARGIN_TOP) + GetMarginsValue(MARGIN_BOTTOM);
1000         }
1001         else if(IsAutoGrowDown() || IsAutoGrowUp())
1002         {
1003             fWidth = GetWidth();
1004             fHeight += GetMarginsValue(MARGIN_TOP) + GetMarginsValue(MARGIN_BOTTOM);
1005         }
1006         else if( IsAutoGrowLeft() || IsAutoGrowRight())
1007         {
1008             fHeight = GetHeight();
1009             fWidth += GetMarginsValue(MARGIN_LEFT) + GetMarginsValue(MARGIN_RIGHT);
1010         }
1011         else
1012         {
1013             fWidth = GetWidth();
1014             fHeight = GetHeight();
1015         }
1016         pXFFrame->SetWidth(fWidth);
1017         pXFFrame->SetHeight(fHeight);
1018     }
1019 }
1020
1021 LwpGroupLayout::LwpGroupLayout(LwpObjectHeader &objHdr, LwpSvStream* pStrm)
1022     : LwpPlacableLayout(objHdr, pStrm)
1023     , m_pFrame(nullptr)
1024 {
1025
1026 }
1027
1028 LwpGroupLayout::~LwpGroupLayout()
1029 {
1030     delete m_pFrame;
1031 }
1032 /**
1033  * @descr read group layout object
1034  *
1035  */
1036 void LwpGroupLayout::Read()
1037 {
1038     LwpPlacableLayout::Read();
1039     m_pObjStrm->SkipExtra();
1040 }
1041 /**
1042  * @descr register group frame style
1043  *
1044  */
1045 void LwpGroupLayout::RegisterStyle()
1046 {
1047     if (m_pFrame)
1048         return;
1049
1050     //register frame style
1051     XFFrameStyle* pFrameStyle = new XFFrameStyle();
1052     m_pFrame = new LwpFrame(this);
1053     m_pFrame->RegisterStyle(pFrameStyle);
1054
1055     //register child frame style
1056     RegisterChildStyle();
1057 }
1058 /**
1059  * @descr create a xfframe and add into content container
1060  * @param:  pCont - content container that contains the frame.
1061  *
1062  */
1063 void LwpGroupLayout::XFConvert(XFContentContainer *pCont)
1064 {
1065     if(m_pFrame)
1066     {
1067         //parse the frame which anchor to paragraph
1068         if(IsRelativeAnchored())
1069         {
1070             XFConvertFrame(pCont);
1071         }
1072         else
1073         {
1074             m_pFrame->XFConvert(pCont);
1075         }
1076
1077     }
1078 }
1079 /**
1080  * @descr create a xfframe and add into content container, called by XFConvert
1081  * @param:  pCont - content container that contains the frame.
1082  * @param:  nPageNo - the page number that the frame anchors
1083  *
1084  */
1085 void LwpGroupLayout::XFConvertFrame(XFContentContainer* pCont, sal_Int32 nStart , sal_Int32 nEnd, bool bAll)
1086 {
1087     if(m_pFrame)
1088     {
1089         XFFrame* pXFFrame = nullptr;
1090         if(nEnd < nStart)
1091         {
1092             pXFFrame = new XFFrame();
1093         }
1094         else
1095         {
1096             pXFFrame = new XFFloatFrame(nStart, nEnd, bAll);
1097         }
1098
1099         m_pFrame->Parse(pXFFrame, nStart);
1100
1101         //add child frame into group
1102         LwpVirtualLayout* pLayout = dynamic_cast<LwpVirtualLayout*>(GetChildHead().obj().get());
1103
1104         while (pLayout && pLayout != this)
1105         {
1106             pLayout->DoXFConvert(pXFFrame);
1107             pLayout = dynamic_cast<LwpVirtualLayout*>(pLayout->GetNext().obj().get());
1108         }
1109
1110         pCont ->Add(pXFFrame);
1111     }
1112 }
1113
1114 LwpGroupFrame::LwpGroupFrame(LwpObjectHeader &objHdr, LwpSvStream* pStrm)
1115     :LwpContent(objHdr, pStrm)
1116 {}
1117
1118 LwpGroupFrame::~LwpGroupFrame()
1119 {}
1120
1121 void LwpGroupFrame::Read()
1122 {
1123     LwpContent::Read();
1124     m_pObjStrm->SkipExtra();
1125
1126 }
1127
1128 void  LwpGroupFrame::RegisterStyle()
1129 {
1130 }
1131
1132 void LwpGroupFrame::XFConvert(XFContentContainer* /*pCont*/)
1133 {
1134 }
1135
1136 LwpDropcapLayout::LwpDropcapLayout(LwpObjectHeader &objHdr, LwpSvStream* pStrm)
1137     : LwpFrameLayout(objHdr, pStrm)
1138 {
1139     m_nChars = 1;
1140     m_nLines = 3;
1141 }
1142
1143 void LwpDropcapLayout::Read()
1144 {
1145     LwpFrameLayout::Read();
1146     m_nLines = m_pObjStrm->QuickReaduInt16();
1147     m_pObjStrm->SeekRel(1);
1148     m_pObjStrm->SkipExtra();
1149 }
1150
1151 void LwpDropcapLayout::Parse(IXFStream* pOutputStream)
1152 {
1153     LwpStory* pStory = static_cast<LwpStory*>(m_Content.obj(VO_STORY).get());
1154     if (!pStory)
1155         return;
1156     rtl::Reference<LwpObject> pPara = pStory->GetFirstPara().obj(VO_PARA);
1157     if(pPara.is())
1158     {
1159         pPara->SetFoundry(m_pFoundry);
1160         pPara->DoParse(pOutputStream);
1161     }
1162 }
1163
1164 void LwpDropcapLayout::XFConvert(XFContentContainer* pCont)
1165 {
1166     LwpStory* pStory = static_cast<LwpStory*>(m_Content.obj(VO_STORY).get());
1167     if (pStory)
1168     {
1169         pStory->SetFoundry(m_pFoundry);
1170         pStory->XFConvert(pCont);
1171     }
1172 }
1173
1174 LwpStory* LwpDropcapLayout::GetContentStory()
1175 {
1176     return static_cast<LwpStory*>(m_Content.obj(VO_STORY).get());
1177 }
1178
1179 void LwpDropcapLayout::RegisterStyle(LwpFoundry* pFoundry)
1180 {
1181     LwpStory* pStory = GetContentStory();
1182     if (pStory)
1183     {
1184         pStory->SetDropcapFlag(true);
1185         pStory->SetFoundry(pFoundry);
1186         LwpPara* pPara = dynamic_cast<LwpPara*>(pStory->GetFirstPara().obj().get());
1187         while(pPara)
1188         {
1189             pPara->SetFoundry(pFoundry);
1190             pPara->RegisterStyle();
1191             pPara = dynamic_cast<LwpPara*>(pPara->GetNext().obj().get());
1192         }
1193     }
1194 }
1195
1196 /**
1197  * @descr  do nothing
1198  *
1199  */
1200 void LwpDropcapLayout::RegisterStyle()
1201 {
1202 }
1203
1204 LwpRubyLayout::LwpRubyLayout(LwpObjectHeader &objHdr, LwpSvStream* pStrm)
1205     : LwpFrameLayout(objHdr, pStrm)
1206     , m_nPlacement(0)
1207     , m_nAlignment(0)
1208     , m_nStateFlag(0)
1209     , m_nXOffset(0)
1210     , m_nYOffset(0)
1211 {
1212 }
1213
1214 void LwpRubyLayout::Read()
1215 {
1216     LwpFrameLayout::Read();
1217     m_nPlacement = m_pObjStrm->QuickReaduInt8();
1218     m_nAlignment = m_pObjStrm->QuickReaduInt8();
1219     m_nStateFlag = m_pObjStrm->QuickReaduInt16();
1220     m_nXOffset = m_pObjStrm->QuickReadInt32();
1221     m_nYOffset = m_pObjStrm->QuickReadInt32();
1222     m_objRubyMarker.ReadIndexed(m_pObjStrm);
1223     m_pObjStrm->SkipExtra();
1224 }
1225
1226 LwpRubyMarker* LwpRubyLayout::GetMarker()
1227 {
1228     return static_cast<LwpRubyMarker*>(m_objRubyMarker.obj(VO_RUBYMARKER).get());
1229 }
1230
1231 LwpStory* LwpRubyLayout::GetContentStory()
1232 {
1233     return static_cast<LwpStory*>(m_Content.obj(VO_STORY).get());
1234 }
1235
1236 void LwpRubyLayout::ConvertContentText()
1237 {
1238     LwpStory* pStory = GetContentStory();
1239     LwpRubyMarker* pMarker = GetMarker();
1240     if (pStory && pMarker)
1241         pMarker->SetRubyText(pStory->GetContentText(true));
1242 }
1243
1244 void LwpRubyLayout::RegisterStyle()
1245 {
1246     LwpRubyMarker* pMarker = GetMarker();
1247     if (!pMarker)
1248         throw std::runtime_error("missing Ruby Marker");
1249
1250     XFRubyStyle* pRubyStyle = new XFRubyStyle;
1251
1252     enumXFRubyPosition eType = enumXFRubyLeft;
1253     if (m_nAlignment == LEFT)
1254     {
1255         eType = enumXFRubyLeft;
1256     }
1257     else if(m_nAlignment == RIGHT)
1258     {
1259         eType =  enumXFRubyRight;
1260     }
1261     else if(m_nAlignment == CENTER)
1262     {
1263         eType =  enumXFRubyCenter;
1264     }
1265     pRubyStyle->SetAlignment(eType);
1266
1267     eType = enumXFRubyTop;
1268     if (m_nPlacement == TOP)
1269     {
1270         eType = enumXFRubyTop;
1271     }
1272     else if(m_nPlacement == BOTTOM)
1273     {
1274         eType =  enumXFRubyBottom;
1275     }
1276     pRubyStyle->SetPosition(eType);
1277
1278     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
1279     OUString rubyStyle = pXFStyleManager->AddStyle(pRubyStyle).m_pStyle->GetStyleName();
1280     pMarker->SetRubyStyleName(rubyStyle);
1281
1282     LwpStory* pStory = GetContentStory();
1283     pStory->SetFoundry(m_pFoundry);
1284     OUString textStyle = pStory->RegisterFirstFribStyle();
1285     pMarker->SetTextStyleName(textStyle);
1286 }
1287
1288 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */