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