lotuswordpro/source/filter/lwpparastyle.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  *  The Contents of this file are made available subject to the terms of
   5  *  either of the following licenses
   6  *
   7  *         - GNU Lesser General Public License Version 2.1
   8  *         - Sun Industry Standards Source License Version 1.1
   9  *
  10  *  Sun Microsystems Inc., October, 2000
  11  *
  12  *  GNU Lesser General Public License Version 2.1
  13  *  =============================================
  14  *  Copyright 2000 by Sun Microsystems, Inc.
  15  *  901 San Antonio Road, Palo Alto, CA 94303, USA
  16  *
  17  *  This library is free software; you can redistribute it and/or
  18  *  modify it under the terms of the GNU Lesser General Public
  19  *  License version 2.1, as published by the Free Software Foundation.
  20  *
  21  *  This library is distributed in the hope that it will be useful,
  22  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24  *  Lesser General Public License for more details.
  25  *
  26  *  You should have received a copy of the GNU Lesser General Public
  27  *  License along with this library; if not, write to the Free Software
  28  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  29  *  MA  02111-1307  USA
  30  *
  31  *
  32  *  Sun Industry Standards Source License Version 1.1
  33  *  =================================================
  34  *  The contents of this file are subject to the Sun Industry Standards
  35  *  Source License Version 1.1 (the "License"); You may not use this file
  36  *  except in compliance with the License. You may obtain a copy of the
  37  *  License at http://www.openoffice.org/license.html.
  38  *
  39  *  Software provided under this License is provided on an "AS IS" basis,
  40  *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  41  *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
  42  *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
  43  *  See the License for the specific provisions governing your rights and
  44  *  obligations concerning the Software.
  45  *
  46  *  The Initial Developer of the Original Code is: IBM Corporation
  47  *
  48  *  Copyright: 2008 by IBM Corporation
  49  *
  50  *  All Rights Reserved.
  51  *
  52  *  Contributor(s): _______________________________________
  53  *
  54  *
  55  ************************************************************************/
  56 /*************************************************************************
  57  * @file
  58  *  For LWP filter architecture prototype
  59  ************************************************************************/
  60 /*************************************************************************
  61  * Change History
  62  Jan 2005           Created
  63  ************************************************************************/
  64
  65 #include <boost/scoped_ptr.hpp>
  66
  67 #include "lwpparastyle.hxx"
  68 #include "lwpfilehdr.hxx"
  69 #include "lwpoverride.hxx"
  70 #include "lwpparaborderoverride.hxx"
  71 #include "lwpbreaksoverride.hxx"
  72 #include "lwpnumberingoverride.hxx"
  73 #include "lwptaboverride.hxx"
  74 #include "lwpbackgroundoverride.hxx"
  75 #include "xfilter/xfdefs.hxx"
  76 #include "xfilter/xfparastyle.hxx"
  77 #include "xfilter/xfborders.hxx"
  78 #include "lwpfont.hxx"
  79 #include "lwpfoundry.hxx"
  80 #include "lwppiece.hxx"
  81 #include "lwpshadow.hxx"
  82 #include "lwpborderstuff.hxx"
  83 #include "lwpmargins.hxx"
  84 #include "lwptabrack.hxx"
  85
  86 #include "lwpsilverbullet.hxx"
  87
  88 LwpParaStyle::LwpParaStyle(LwpObjectHeader& objHdr, LwpSvStream* pStrm) :
  89 LwpTextStyle(objHdr, pStrm), m_pKinsokuOptsOverride(new LwpKinsokuOptsOverride),
  90 m_pBulletOverride(new LwpBulletOverride)
  91 {
  92 }
  93
  94 LwpParaStyle::~LwpParaStyle()
  95 {
  96     if (m_pKinsokuOptsOverride)
  97     {
  98         delete m_pKinsokuOptsOverride;
  99     }
 100
 101     if (m_pBulletOverride)
 102     {
 103         delete m_pBulletOverride;
 104     }
 105 }
 106
 107 void LwpParaStyle::Read()
 108 {
 109     LwpTextStyle::Read();
 110
 111     if (LwpFileHeader::m_nFileRevision < 0x000B)
 112     {
 113         // read many overrides
 114         LwpAlignmentOverride    aAlignOverride;
 115         aAlignOverride.Read(m_pObjStrm);
 116
 117         LwpSpacingOverride  aSpacingOverride;
 118         aSpacingOverride.Read(m_pObjStrm);
 119
 120         LwpIndentOverride       aIndentOverride;
 121         aIndentOverride.Read(m_pObjStrm);
 122
 123         LwpParaBorderOverride   aPBOverride;
 124         aPBOverride.Read(m_pObjStrm);
 125
 126         LwpBreaksOverride   aBreaksOverride;
 127         aBreaksOverride.Read(m_pObjStrm);
 128
 129         LwpNumberingOverride    aNumberingOverride;
 130         aNumberingOverride.Read(m_pObjStrm);
 131
 132         LwpTabOverride      aTabOverride;
 133         aTabOverride.Read(m_pObjStrm);
 134
 135     }
 136     else
 137     {
 138         m_AlignmentStyle.ReadIndexed(m_pObjStrm);
 139         m_SpacingStyle.ReadIndexed(m_pObjStrm);
 140         m_IndentStyle.ReadIndexed(m_pObjStrm);
 141         m_BorderStyle.ReadIndexed(m_pObjStrm);
 142         m_BreaksStyle.ReadIndexed(m_pObjStrm);
 143         m_NumberingStyle.ReadIndexed(m_pObjStrm);
 144         m_TabStyle.ReadIndexed(m_pObjStrm);
 145
 146         m_pKinsokuOptsOverride->Read(m_pObjStrm);
 147         m_pBulletOverride->Read(m_pObjStrm);
 148
 149         if (m_pObjStrm->CheckExtra())
 150         {
 151             m_BackgroundStyle.ReadIndexed(m_pObjStrm);
 152             m_pObjStrm->SkipExtra();
 153         }
 154
 155     }
 156 }
 157
 158 void LwpParaStyle::Apply(XFParaStyle *pParaStyle)
 159 {
 160     assert(pParaStyle);
 161
 162     LwpVirtualPiece *pPiece = NULL;
 163     //alignment:
 164     pPiece = dynamic_cast<LwpVirtualPiece*>(m_AlignmentStyle.obj().get());
 165     if( pPiece )
 166     {
 167         LwpAlignmentOverride *pAlign = dynamic_cast<LwpAlignmentOverride*>(pPiece->GetOverride());
 168         if( pAlign )
 169                 ApplyAlignment(pParaStyle,pAlign);
 170     }
 171
 172     //don't known top and bottom indent now.
 173     pPiece = dynamic_cast<LwpVirtualPiece*>(m_IndentStyle.obj().get());
 174     if( pPiece )
 175     {
 176         LwpIndentOverride   *pIndent = dynamic_cast<LwpIndentOverride*>(pPiece->GetOverride());
 177         if( pIndent )
 178         {
 179             if (!m_pBulletOverride->IsInValid())//Add by ,for remove bullet indent in named bullet style
 180             {
 181                 boost::scoped_ptr<LwpIndentOverride> pNewIndent(pIndent->clone());
 182                 pNewIndent->SetMFirst(0);
 183                 pNewIndent->SetMRest(0);
 184                 ApplyIndent(NULL, pParaStyle, pNewIndent.get());
 185             }
 186             else
 187                 ApplyIndent(NULL,pParaStyle,pIndent);
 188         }
 189     }
 190     //shadow & borders.
 191     pPiece = dynamic_cast<LwpVirtualPiece*>(m_BorderStyle.obj().get());
 192     if( pPiece )
 193     {
 194         LwpParaBorderOverride *pBorder = dynamic_cast<LwpParaBorderOverride*>(pPiece->GetOverride());
 195         if( pBorder )
 196         {
 197             ApplyParaBorder(pParaStyle, pBorder);
 198         }
 199     }
 200
 201     pPiece = dynamic_cast<LwpVirtualPiece*>(m_SpacingStyle.obj().get());
 202     if (pPiece)
 203     {
 204         LwpSpacingOverride *pSpacing = dynamic_cast<LwpSpacingOverride*>(pPiece->GetOverride());
 205         if( pSpacing)
 206             ApplySpacing(NULL,pParaStyle,pSpacing);
 207     }
 208
 209     //paragraph background.
 210     pPiece = dynamic_cast<LwpVirtualPiece*>(m_BackgroundStyle.obj().get());
 211     if( pPiece )
 212     {
 213         LwpBackgroundOverride *pBack = dynamic_cast<LwpBackgroundOverride*>(pPiece->GetOverride());
 214         if( pBack )
 215         {
 216             LwpColor color = pBack->GetBackColor();
 217             XFColor aXFColor( color.To24Color() );
 218             pParaStyle->SetBackColor( aXFColor );
 219         }
 220     }
 221
 222     //add tab style
 223     pPiece = dynamic_cast<LwpVirtualPiece*>(m_TabStyle.obj().get());
 224     if( pPiece  )
 225     {
 226         LwpTabOverride *pTab = dynamic_cast<LwpTabOverride*>(pPiece->GetOverride());
 227         if(pTab)
 228         {
 229             ApplyTab(pParaStyle,pTab);
 230         }
 231     }
 232     pPiece = dynamic_cast<LwpVirtualPiece*>(m_BreaksStyle.obj().get());
 233     if( pPiece  )
 234     {
 235         LwpBreaksOverride *pBreak = dynamic_cast<LwpBreaksOverride*>(pPiece->GetOverride());
 236         if(pBreak)
 237         {
 238             ApplyBreaks(pParaStyle,pBreak);
 239         }
 240     }
 241
 242 }
 243
 244 void LwpParaStyle::ApplySubBorder(LwpBorderStuff* pBorderStuff, LwpBorderStuff::BorderType eType, XFBorders* pXFBorders)
 245 {
 246     enumXFBorder eXFBorderSide = enumXFBorderNone;
 247     switch (eType)
 248     {
 249     case LwpBorderStuff::LEFT:
 250         eXFBorderSide = enumXFBorderLeft;
 251         break;
 252     case LwpBorderStuff::RIGHT:
 253         eXFBorderSide = enumXFBorderRight;
 254         break;
 255     case LwpBorderStuff::TOP:
 256         eXFBorderSide = enumXFBorderTop;
 257         break;
 258     case LwpBorderStuff::BOTTOM:
 259         eXFBorderSide = enumXFBorderBottom;
 260         break;
 261     default:
 262         break;
 263     }
 264
 265     LwpColor    aColor = pBorderStuff->GetSideColor(eType);
 266     float       fWidth = pBorderStuff->GetSideWidth(eType);
 267     sal_uInt16  nType = pBorderStuff->GetSideType(eType);
 268
 269     switch (nType)
 270     {
 271     default://fall through!
 272     case 0x14: //single fall through!
 273     case 0x17: //treble
 274         pXFBorders->SetWidth(eXFBorderSide, fWidth);
 275         break;
 276     case 0x15: //double , fall through!
 277     case 0x16: //thick double
 278         pXFBorders->SetDoubleLine(eXFBorderSide, true, false);
 279         pXFBorders->SetWidthOuter(eXFBorderSide, static_cast<float>(fWidth*0.333));
 280         pXFBorders->SetWidthSpace(eXFBorderSide, static_cast<float>(fWidth*0.334));
 281         pXFBorders->SetWidthInner(eXFBorderSide, static_cast<float>(fWidth*0.333));
 282 //      pXFBorders->SetWidth(eXFBorderSide, fWidth);
 283         break;
 284     case 0x18: //thick-thin
 285         pXFBorders->SetDoubleLine(eXFBorderSide, true, false);
 286         pXFBorders->SetWidthOuter(eXFBorderSide, static_cast<float>(fWidth*0.5));
 287         pXFBorders->SetWidthInner(eXFBorderSide, static_cast<float>(fWidth*0.25));
 288         pXFBorders->SetWidthSpace(eXFBorderSide, static_cast<float>(fWidth*0.25));
 289         break;
 290     case 0x19: //thin-thick
 291         pXFBorders->SetDoubleLine(eXFBorderSide, true, false);
 292         pXFBorders->SetWidthInner(eXFBorderSide, static_cast<float>(fWidth*0.7));
 293         pXFBorders->SetWidthOuter(eXFBorderSide, static_cast<float>(fWidth*0.15));
 294         pXFBorders->SetWidthSpace(eXFBorderSide, static_cast<float>(fWidth*0.15));
 295         break;
 296     }
 297
 298     if (aColor.IsValidColor())
 299     {
 300         XFColor aXFColor(aColor.To24Color());
 301         pXFBorders->SetColor(eXFBorderSide, aXFColor );
 302     }
 303 }
 304
 305 void LwpParaStyle::ApplyParaBorder(XFParaStyle* pParaStyle, LwpParaBorderOverride* pBorder)
 306 {
 307     //convert LwpShadow:
 308     LwpShadow *pShadow = pBorder->GetShadow();
 309     if( pShadow )
 310     {
 311         LwpColor color = pShadow->GetColor();
 312         float   offsetX = pShadow->GetOffsetX();
 313         float   offsetY = pShadow->GetOffsetY();
 314
 315         if( offsetX && offsetY && color.IsValidColor() )
 316         {
 317             XFColor aXFColor(color.To24Color());
 318             bool left = false;
 319             bool top = false;
 320             if( offsetX < 0 )
 321                 left = true;
 322             if( offsetY < 0 )
 323                 top = true;
 324             if( left )
 325             {
 326                 if( top )
 327                     pParaStyle->SetShadow(enumXFShadowLeftTop,-offsetX,aXFColor);
 328                 else
 329                     pParaStyle->SetShadow(enumXFShadowLeftBottom,-offsetX,aXFColor);
 330             }
 331             else
 332             {
 333                 if( top )
 334                     pParaStyle->SetShadow(enumXFShadowRightTop,offsetX,aXFColor);
 335                 else
 336                     pParaStyle->SetShadow(enumXFShadowRightBottom,offsetX,aXFColor);
 337             }
 338         }
 339     }
 340
 341     //convert to XFBorders object:
 342     LwpBorderStuff  *pBorderStuff = pBorder->GetBorderStuff();
 343     if( pBorderStuff && pBorderStuff->GetSide() != 0 )
 344     {
 345         XFBorders   *pXFBorders = new XFBorders();
 346         pParaStyle->SetBorders(pXFBorders);
 347
 348         LwpMargins* pMargins = pBorder->GetMargins();
 349
 350         // apply 4 borders respectively
 351         LwpBorderStuff::BorderType pType[] = { LwpBorderStuff::LEFT, LwpBorderStuff::RIGHT,
 352             LwpBorderStuff::TOP, LwpBorderStuff::BOTTOM };
 353         float pMarginValue[4];
 354
 355         for (sal_uInt8 nC = 0; nC < 4; nC++)
 356         {
 357             if (pBorderStuff->HasSide(pType[nC]))
 358             {
 359                 ApplySubBorder(pBorderStuff, pType[nC], pXFBorders);
 360
 361                 //get border spacing to text content
 362                 if (pMargins)
 363                 {
 364                     pMarginValue[nC] = static_cast<float>(pMargins->GetMarginsValue(nC));
 365                 }
 366             }
 367
 368         }
 369
 370         //apply border spacing to text content
 371         pParaStyle->SetPadding(pMarginValue[0], pMarginValue[1], pMarginValue[2], pMarginValue[3]);
 372
 373     }
 374 }
 375
 376 void LwpParaStyle::ApplyBreaks(XFParaStyle* pParaStyle, LwpBreaksOverride* pBreaks)
 377 {
 378     if (pBreaks->IsKeepWithNext())
 379     {
 380         pParaStyle->SetBreaks(enumXFBreakKeepWithNext);
 381     }
 382     if (pBreaks->IsPageBreakBefore())
 383     {
 384         pParaStyle->SetBreaks(enumXFBreakBefPage);
 385     }
 386     if (pBreaks->IsPageBreakAfter())
 387     {
 388         pParaStyle->SetBreaks(enumXFBreakAftPage);
 389     }
 390     if (pBreaks->IsColumnBreakBefore())
 391     {
 392         pParaStyle->SetBreaks(enumXFBreakBefColumn);
 393     }
 394     if (pBreaks->IsColumnBreakAfter())
 395     {
 396         pParaStyle->SetBreaks(enumXFBreakAftColumn);
 397     }
 398 }
 399
 400 void LwpParaStyle::ApplyAlignment(XFParaStyle* pParaStyle, LwpAlignmentOverride* pAlign)
 401 {
 402     enumXFAlignType alignType = enumXFAlignStart;
 403     LwpAlignmentOverride::AlignType type;
 404
 405     type = pAlign->GetAlignType();
 406     pParaStyle->SetNumberRight(false);//to identify its align attribute
 407     switch(type)
 408     {
 409     case LwpAlignmentOverride::ALIGN_LEFT:
 410         alignType = enumXFAlignStart;
 411         break;
 412     case LwpAlignmentOverride::ALIGN_RIGHT:
 413         alignType = enumXFAlignEnd;
 414         break;
 415     case LwpAlignmentOverride::ALIGN_CENTER:
 416         alignType = enumXFAlignCenter;
 417         break;
 418     case LwpAlignmentOverride::ALIGN_NUMERICLEFT://if non-number in table,ALIGN_NUMERICLEFT/RIGHT are useless
 419         alignType = enumXFAlignStart;            //note by  1/28
 420         break;
 421     case LwpAlignmentOverride::ALIGN_JUSTIFY:
 422     case LwpAlignmentOverride::ALIGN_JUSTIFYALL:
 423         alignType = enumXFAlignJustify;
 424         break;
 425     case LwpAlignmentOverride::ALIGN_NUMERICRIGHT:
 426         pParaStyle->SetNumberRight(true);//to identify its align attribute
 427         alignType = enumXFAlignEnd;
 428         break;
 429     default:
 430         break;
 431     }
 432     pParaStyle->SetAlignType(alignType);
 433 }
 434
 435 void LwpParaStyle::ApplyIndent(LwpPara* pPara, XFParaStyle* pParaStyle, LwpIndentOverride* pIndent)
 436 {
 437     LwpPara* pParentPara;
 438     if (pPara)
 439         pParentPara = pPara->GetParent();
 440     else
 441         pParentPara = NULL;
 442
 443     std::unique_ptr<LwpIndentOverride> pTotalIndent(new LwpIndentOverride);
 444     if (pIndent->IsUseRelative() && pParentPara)
 445     {
 446         LwpIndentOverride* pParentIndent = pParentPara->GetIndent();
 447         if (!pParentIndent)
 448             return;
 449         pTotalIndent.reset(pIndent->clone());
 450
 451         //add by ,for bullet only
 452         if (pPara)
 453         {
 454             if (pPara->GetBulletFlag())
 455             {
 456                 pTotalIndent->SetMAll(pParentIndent->GetMAll() + pTotalIndent->GetMAll());
 457                 pTotalIndent->SetMRight(pParentIndent->GetMRight()+ pTotalIndent->GetMRight());
 458                 pParaStyle->SetMargins(LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(
 459                     pTotalIndent->GetMAll())), pTotalIndent->GetRight());
 460                 pPara->SetIndent(pTotalIndent.release());
 461                 return;
 462             }
 463         }
 464         //end add
 465         sal_uInt16 relative = pParentIndent->GetRelative();
 466
 467         sal_Int32 Amount = pParentIndent->GetMAll();
 468
 469         if (relative == LwpIndentOverride::RELATIVE_FIRST)
 470             Amount += pParentIndent->GetMFirst();
 471         else if (relative == LwpIndentOverride::RELATIVE_REST)
 472             Amount += pParentIndent->GetMRest();
 473         pTotalIndent->SetMAll(Amount + pTotalIndent->GetMAll());
 474         pTotalIndent->SetMRight(pParentIndent->GetMRight()+ pTotalIndent->GetMRight());
 475
 476         pParaStyle->SetIndent(pTotalIndent->GetFirst());
 477         pParaStyle->SetMargins(pTotalIndent->GetLeft(), pTotalIndent->GetRight());
 478         pPara->SetIndent(pTotalIndent.release());
 479
 480     }
 481     else
 482     {
 483         pTotalIndent.reset(pIndent->clone());
 484         //add by
 485         if (pPara)
 486         {
 487             if (pPara->GetBulletFlag())
 488             {
 489 //              pParaStyle->SetIndent(LwpTools::ConvertFromUnits(pIndent->GetMAll()));
 490                 pParaStyle->SetMargins(LwpTools::ConvertToMetric(
 491                     LwpTools::ConvertFromUnits(pIndent->GetMAll())), pIndent->GetRight());
 492                 pPara->SetIndent(pTotalIndent.release());
 493                 return;
 494             }
 495         }
 496         //end add
 497
 498         pParaStyle->SetIndent(pIndent->GetFirst());
 499         pParaStyle->SetMargins(pIndent->GetLeft(), pIndent->GetRight());
 500         if (pPara)
 501         {
 502             pPara->SetIndent(pTotalIndent.release());
 503         }
 504     }
 505 }
 506
 507 void LwpParaStyle::ApplySpacing(LwpPara* pPara, XFParaStyle* pParaStyle, LwpSpacingOverride* pSpacing)
 508 {
 509     LwpSpacingCommonOverride* spacing = pSpacing->GetSpacing();
 510     LwpSpacingCommonOverride* abovepara = pSpacing->GetAboveSpacing();
 511     LwpSpacingCommonOverride* belowpara = pSpacing->GetBelowSpacing();
 512
 513     LwpSpacingCommonOverride::SpacingType type = spacing->GetType();
 514     sal_Int32 amount = spacing->GetAmount();
 515     sal_Int32 multiple = spacing->GetMultiple();
 516     enumLHType xftype;
 517     double height;
 518
 519     switch(type)
 520     {
 521     case LwpSpacingCommonOverride::SPACING_DYNAMIC:
 522     {
 523     xftype = enumLHPercent;
 524     height = double(multiple)/65536L*100;
 525     pParaStyle->SetLineHeight(xftype,height);
 526     }
 527         break;
 528     case LwpSpacingCommonOverride::SPACING_LEADING:
 529     {
 530     xftype = enumLHSpace;
 531     height = LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(amount));
 532     pParaStyle->SetLineHeight(xftype,height);
 533     }
 534         break;
 535     case LwpSpacingCommonOverride::SPACING_CUSTOM:
 536     {
 537     xftype = enumLHHeight;
 538     height =  LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(sal_Int32(float(multiple)/65536L*amount)));
 539         pParaStyle->SetLineHeight(xftype,height);
 540     }
 541         break;
 542     case LwpSpacingCommonOverride::SPACING_NONE:
 543         break;
 544     }
 545
 546 //TO DO: Above Line need to be processed!!!!!!! what it means??????  1-26
 547
 548     type = abovepara->GetType();
 549     amount = abovepara->GetAmount();
 550     multiple = abovepara->GetMultiple();
 551     double above_val =-1;
 552     switch(type)
 553     {
 554     case LwpSpacingCommonOverride::SPACING_DYNAMIC:
 555 //        above_val = LINE_HEIGHT*float(multiple)/65536L*100; //TO DO:  1-26
 556         break;
 557     case LwpSpacingCommonOverride::SPACING_LEADING:
 558         break;
 559     case LwpSpacingCommonOverride::SPACING_CUSTOM:
 560         above_val =  LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(sal_Int32(float(multiple)/65536L*amount)));
 561         break;
 562     case LwpSpacingCommonOverride::SPACING_NONE:
 563         break;
 564     }
 565
 566     type = belowpara->GetType();
 567     amount = belowpara->GetAmount();
 568     multiple = belowpara->GetMultiple();
 569     double below_val=-1;
 570     switch(type)
 571     {
 572     case LwpSpacingCommonOverride::SPACING_DYNAMIC:
 573 //        below_val = LINE_HEIGHT*float(multiple)/65536L*100;//TO DO:  1-26
 574         break;
 575     case LwpSpacingCommonOverride::SPACING_LEADING:
 576         break;
 577     case LwpSpacingCommonOverride::SPACING_CUSTOM:
 578         below_val =  LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(sal_Int32(float(multiple)/65536L*amount)));
 579         break;
 580     case LwpSpacingCommonOverride::SPACING_NONE:
 581         break;
 582     }
 583
 584     if (pPara)
 585     {
 586         if (below_val != -1)
 587             pPara->SetBelowSpacing(below_val);
 588         LwpPara* pPrePara = dynamic_cast<LwpPara*>(pPara->GetPrevious().obj().get());
 589         if (pPrePara && above_val != -1)
 590         {
 591             above_val += pPrePara->GetBelowSpacing();
 592
 593         }
 594
 595     }
 596     pParaStyle->SetMargins(-1,-1,above_val,below_val);
 597 }
 598 /**************************************************************************
 599  * @short:
 600  * @descr:
 601  * @param:
 602  * @param:
 603  * @return:
 604 **************************************************************************/
 605 void LwpParaStyle::ApplyTab(XFParaStyle *pParaStyle, LwpTabOverride *pTabOverRide)
 606 {
 607     LwpObjectID& rTabRackID = pTabOverRide->GetTabRackID();
 608     if(rTabRackID.IsNull())
 609     {
 610         return;
 611     }
 612
 613     LwpTabRack* pTabRack = dynamic_cast<LwpTabRack*>(rTabRackID.obj().get());
 614     if(!pTabRack)
 615     {
 616         return;
 617     }
 618
 619     pParaStyle->ClearTabStyles();
 620     //Get margin left value
 621     double dMarginLeft = pParaStyle->GetMargins().GetLeft();
 622
 623     sal_uInt16 nNumTabs = pTabRack->GetNumTabs();
 624     for(sal_uInt16 nIndex=0; nIndex<nNumTabs; nIndex++)
 625     {
 626         //get tab type
 627         LwpTab* pTab = pTabRack->Lookup(nIndex);
 628         if(!pTab)
 629             return;
 630
 631         enumXFTab eType = enumXFTabNone;
 632         LwpTab::TabType type = pTab->GetTabType();
 633         switch(type)
 634         {
 635         case LwpTab::TT_LEFT:
 636             eType = enumXFTabLeft;
 637             break;
 638         case LwpTab::TT_CENTER:
 639             eType = enumXFTabCenter;
 640             break;
 641         case LwpTab::TT_RIGHT:
 642             eType = enumXFTabRight;
 643             break;
 644         case LwpTab::TT_NUMERIC:
 645             eType = enumXFTabChar;
 646             break;
 647         }
 648
 649         //get position
 650         sal_uInt32 nPos = pTab->GetPosition();
 651         //different feature between SODC and lwp, the tab length must minus the margin left of para.
 652         double fLen = LwpTools::ConvertFromUnitsToMetric(nPos) - dMarginLeft;
 653
 654         //get leader type
 655         sal_Unicode cLeader = 0x00;
 656         LwpTab::LeaderType leader= pTab->GetLeaderType();
 657         switch(leader)
 658         {
 659         case LwpTab::TL_NONE:
 660             cLeader = 0x20;     //space
 661             break;
 662         case LwpTab::TL_HYPHEN: //'-'
 663             cLeader = 0xAD;
 664             break;
 665         case LwpTab::TL_DOT:    //'.'
 666             cLeader = 0x2E;
 667             break;
 668         case LwpTab::TL_LINE:   //'_'
 669             cLeader = 0x5F;
 670             break;
 671         }
 672
 673         sal_Unicode cAlignChar = static_cast<sal_Unicode>(pTab->GetAlignChar());
 674
 675         pParaStyle->AddTabStyle(eType,fLen,cLeader,cAlignChar);
 676     }
 677
 678 }
 679
 680 void LwpParaStyle::RegisterStyle()
 681 {
 682     XFParaStyle* pStyle = new XFParaStyle();
 683
 684     //Set name
 685     OUString styleName = GetName().str();
 686     pStyle->SetStyleName(styleName);
 687
 688     //Create font
 689     LwpFontManager& rFontMgr = m_pFoundry->GetFontManger();
 690     rtl::Reference<XFFont> pFont = rFontMgr.CreateFont(m_nFinalFontID);
 691     pStyle->SetFont(pFont);
 692
 693     //Set other paragraph properties...
 694
 695     Apply(pStyle);
 696     //Add style
 697     LwpStyleManager* pStyleMgr = m_pFoundry->GetStyleManager();
 698     pStyleMgr->AddStyle(GetObjectID(), pStyle);
 699 }
 700
 701 LwpAlignmentOverride* LwpParaStyle::GetAlignment()
 702 {
 703     if (m_AlignmentStyle.obj() == NULL)
 704         return NULL;
 705
 706     LwpAlignmentPiece *pPiece = dynamic_cast<LwpAlignmentPiece*>(m_AlignmentStyle.obj().get());
 707     if (pPiece)
 708         return dynamic_cast<LwpAlignmentOverride*>(pPiece->GetOverride());
 709     return NULL;
 710 }
 711
 712 LwpIndentOverride* LwpParaStyle::GetIndent()
 713 {
 714     if (m_IndentStyle.obj() == NULL)
 715         return NULL;
 716
 717     LwpIndentPiece *pPiece = dynamic_cast<LwpIndentPiece*>(m_IndentStyle.obj().get());
 718     if (pPiece)
 719         return dynamic_cast<LwpIndentOverride*>(pPiece->GetOverride());
 720     return NULL;
 721 }
 722
 723 LwpSpacingOverride* LwpParaStyle::GetSpacing()
 724 {
 725     if (m_SpacingStyle.obj() == NULL)
 726         return NULL;
 727
 728     LwpSpacingPiece *pPiece = dynamic_cast<LwpSpacingPiece*>(m_SpacingStyle.obj().get());
 729     if (pPiece)
 730         return dynamic_cast<LwpSpacingOverride*>(pPiece->GetOverride());
 731     return NULL;
 732 }
 733
 734 LwpParaBorderOverride* LwpParaStyle::GetParaBorder() const
 735 {
 736     if(m_BorderStyle.IsNull())
 737         return NULL;
 738
 739     LwpParaBorderPiece *pPiece = dynamic_cast<LwpParaBorderPiece*>(m_BorderStyle.obj(VO_PARABORDERPIECE).get());
 740     if (pPiece)
 741         return dynamic_cast<LwpParaBorderOverride*>(pPiece->GetOverride());
 742     return NULL;
 743 }
 744
 745 LwpBreaksOverride* LwpParaStyle::GetBreaks() const
 746 {
 747     if(m_BreaksStyle.IsNull())
 748         return NULL;
 749
 750     LwpBreaksPiece *pPiece = dynamic_cast<LwpBreaksPiece*>(m_BreaksStyle.obj(VO_BREAKSPIECE).get());
 751     if (pPiece)
 752         return dynamic_cast<LwpBreaksOverride*>(pPiece->GetOverride());
 753     return NULL;
 754 }
 755
 756
 757 LwpNumberingOverride* LwpParaStyle::GetNumberingOverride() const
 758 {
 759     if(m_NumberingStyle.IsNull())
 760         return NULL;
 761
 762     LwpNumberingPiece *pPiece = dynamic_cast<LwpNumberingPiece*>(m_NumberingStyle.obj(VO_NUMBERINGPIECE).get());
 763     if (pPiece)
 764         return dynamic_cast<LwpNumberingOverride*>(pPiece->GetOverride());
 765     return NULL;
 766 }
 767
 768 /**************************************************************************
 769  * @short:
 770  * @descr:
 771  * @param:
 772  * @param:
 773  * @return:
 774 **************************************************************************/
 775 LwpTabOverride* LwpParaStyle::GetTabOverride() const
 776 {
 777     if(m_TabStyle.obj() == NULL)
 778         return NULL;
 779     LwpTabPiece *pPiece = dynamic_cast<LwpTabPiece*>(m_TabStyle.obj().get());
 780     if (pPiece)
 781         return dynamic_cast<LwpTabOverride*>(pPiece->GetOverride());
 782     return NULL;
 783 }
 784
 785 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */