lotuswordpro/source/filter/lwpbulletstylemgr.cxx

   1 /*************************************************************************
   2  *
   3  *  The Contents of this file are made available subject to the terms of
   4  *  either of the following licenses
   5  *
   6  *         - GNU Lesser General Public License Version 2.1
   7  *         - Sun Industry Standards Source License Version 1.1
   8  *
   9  *  Sun Microsystems Inc., October, 2000
  10  *
  11  *  GNU Lesser General Public License Version 2.1
  12  *  =============================================
  13  *  Copyright 2000 by Sun Microsystems, Inc.
  14  *  901 San Antonio Road, Palo Alto, CA 94303, USA
  15  *
  16  *  This library is free software; you can redistribute it and/or
  17  *  modify it under the terms of the GNU Lesser General Public
  18  *  License version 2.1, as published by the Free Software Foundation.
  19  *
  20  *  This library is distributed in the hope that it will be useful,
  21  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23  *  Lesser General Public License for more details.
  24  *
  25  *  You should have received a copy of the GNU Lesser General Public
  26  *  License along with this library; if not, write to the Free Software
  27  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  28  *  MA  02111-1307  USA
  29  *
  30  *
  31  *  Sun Industry Standards Source License Version 1.1
  32  *  =================================================
  33  *  The contents of this file are subject to the Sun Industry Standards
  34  *  Source License Version 1.1 (the "License"); You may not use this file
  35  *  except in compliance with the License. You may obtain a copy of the
  36  *  License at http://www.openoffice.org/license.html.
  37  *
  38  *  Software provided under this License is provided on an "AS IS" basis,
  39  *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  40  *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
  41  *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
  42  *  See the License for the specific provisions governing your rights and
  43  *  obligations concerning the Software.
  44  *
  45  *  The Initial Developer of the Original Code is: IBM Corporation
  46  *
  47  *  Copyright: 2008 by IBM Corporation
  48  *
  49  *  All Rights Reserved.
  50  *
  51  *  Contributor(s): _______________________________________
  52  *
  53  *
  54  ************************************************************************/
  55 /*************************************************************************
  56  * @file
  57  *  For LWP filter architecture prototype
  58  ************************************************************************/
  59 /*************************************************************************
  60  * Change History
  61  Jan 2005                       Created
  62  ************************************************************************/
  63 #include "lwpbulletstylemgr.hxx"
  64 #include "lwpdoc.hxx"
  65 #include "lwpstory.hxx"
  66 #include "lwpdivinfo.hxx"
  67 #include "lwppara.hxx"
  68 #include "lwpsilverbullet.hxx"
  69 #include "lwptools.hxx"
  70 #include "lwpparaproperty.hxx"
  71 #include "xfilter/xfliststyle.hxx"
  72 #include "xfilter/xfstylemanager.hxx"
  73 #include "xfilter/xflist.hxx"
  74 #include "lwpglobalmgr.hxx"
  75
  76 LwpBulletStyleMgr::LwpBulletStyleMgr() :
  77 m_pBulletList(NULL), m_bContinue(sal_True), m_bIsBulletSkipped(sal_False), m_nCurrentPos(0xFF)
  78 {
  79 }
  80
  81 LwpBulletStyleMgr::~LwpBulletStyleMgr()
  82 {
  83         if (m_pBulletList)
  84         {
  85                 delete m_pBulletList;
  86         }
  87
  88         m_vIDsPairList.clear();
  89         m_vStyleNameList.clear();
  90 }
  91
  92 /**
  93  * @short   Register bullet style to style-list. The function only register the bullet and single customized numbering
  94  *              not inluding the numbering sequence.
  95  * @param   pPara pointer to the current paragraph which has a bullet/numbering.
  96  * @param   pBullOver pointer to the bulletoverride of current paragraph.
  97  * @param   pIndent pointer to the indentoverride of current paragraph.
  98  */
  99 rtl::OUString LwpBulletStyleMgr::RegisterBulletStyle(LwpPara* pPara, LwpBulletOverride* pBullOver,
 100         LwpIndentOverride* pIndent)
 101 {
 102         if(!pPara || !pIndent || !pBullOver)
 103         {
 104 //              assert(false);
 105                 return rtl::OUString::createFromAscii("");
 106         }
 107
 108         LwpSilverBullet* pSilverBullet = pPara->GetSilverBullet();
 109         if (!pSilverBullet)
 110         {
 111                 assert(false);
 112                 return rtl::OUString::createFromAscii("");
 113         }
 114
 115         LwpPara* pBulletPara = pSilverBullet->GetBulletPara();
 116         if (!pBulletPara)
 117         {
 118                 assert(false);
 119                 return rtl::OUString::createFromAscii("");
 120         }
 121
 122         LwpParaProperty* pProp = pPara->GetProperty(PP_LOCAL_INDENT);
 123         LwpParaIndentProperty* pIndentProp = NULL;
 124         LwpObjectID aIndentID;
 125         if (pProp)
 126         {
 127                 pIndentProp = static_cast<LwpParaIndentProperty*>(pProp);
 128                 aIndentID = pIndentProp->GetIndentID();
 129         }
 130
 131         LwpObjectID aBulletID = pBullOver->GetSilverBullet();
 132         LwpBulletOverride aBulletOver = *pBullOver;
 133
 134         sal_uInt16 nNameIndex = 0;
 135         std::vector <OverridePair>::iterator iter;
 136         for(iter = m_vIDsPairList.begin(); iter != m_vIDsPairList.end(); iter++)
 137         {
 138                 if (iter->first.GetSilverBullet() == aBulletID && iter->second == aIndentID
 139                         && iter->first.IsRightAligned() == pBullOver->IsRightAligned())
 140                 {
 141                         return m_vStyleNameList[nNameIndex];
 142                 }
 143                 else
 144                 {
 145                         nNameIndex++;
 146                 }
 147         }
 148
 149         m_vIDsPairList.push_back(std::make_pair(aBulletOver, aIndentID));
 150         rtl::OUString aStyleName;
 151
 152         LwpFribPtr* pBulletParaFribs = pBulletPara->GetFribs();
 153         sal_Bool bIsNumbering = (sal_Bool)(pBulletParaFribs->HasFrib(FRIB_TAG_PARANUMBER) != 0);
 154
 155         enumXFAlignType eAlign = enumXFAlignStart;
 156         if (pBullOver->IsRightAligned())
 157         {
 158                 eAlign = enumXFAlignEnd;
 159         }
 160
 161         XFListStyle* pListStyle = new XFListStyle();
 162         XFStyleManager* pXFStyleMgr = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
 163
 164         if (!bIsNumbering)
 165         {
 166                 for (sal_uInt8 nC = 1; nC < 11; nC++)
 167                 {
 168                         pListStyle->SetListBullet(nC, pSilverBullet->GetBulletChar(), pSilverBullet->GetBulletFontName(),
 169                                 pSilverBullet->GetPrefix(), pSilverBullet->GetSuffix());
 170
 171                         if (pIndent->GetMRest() > 0.001)
 172                         {
 173                                 pListStyle->SetListPosition(nC, 0.0,
 174                                         LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(pIndent->GetMRest())), 0.0, eAlign);
 175                         }
 176                         else
 177                         {
 178                                 pListStyle->SetListPosition(nC, 0.0,
 179                                         0.0, LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(pIndent->GetMFirst())), eAlign);
 180                         }
 181                 }
 182
 183                 aStyleName = pXFStyleMgr->AddStyle(pListStyle)->GetStyleName();
 184         }
 185         else
 186         {
 187                 rtl::OUString aPrefix = rtl::OUString::createFromAscii("");
 188
 189                 LwpFrib* pFrib = pBulletParaFribs->HasFrib(FRIB_TAG_DOCVAR);
 190                 LwpFribDocVar* pDocVarFrib = NULL;
 191                 if (pFrib)
 192                 {
 193                         pDocVarFrib = static_cast<LwpFribDocVar*>(pFrib);
 194 //                              ModifierInfo* pInfo = pDocVarFrib->GetModifiers();
 195                         switch (pDocVarFrib->GetType())
 196                         {
 197                         case 0x000D: // division name
 198                                 aPrefix = this->GetDivisionName();
 199                                 break;
 200                         case 0x000E: // section name
 201                                 aPrefix = this->GetSectionName(pPara);
 202                                 break;
 203                         }
 204                 }
 205                 ParaNumbering aParaNumbering;
 206                 pBulletPara->GetParaNumber(1, &aParaNumbering);
 207                 LwpFribParaNumber* pParaNumber = aParaNumbering.pParaNumber;
 208                 if (pParaNumber)
 209                 {
 210                         for (sal_uInt8 nPos = 1; nPos < 10; nPos++)
 211                         {
 212                                 aPrefix = rtl::OUString::createFromAscii("");
 213                                 if (pParaNumber->GetStyleID() != NUMCHAR_other)
 214                                 {
 215                                         XFNumFmt aFmt;
 216                                         if (aParaNumbering.pPrefix)
 217                                         {
 218                                                 aPrefix += aParaNumbering.pPrefix->GetText();
 219 //                                                      aFmt.SetPrefix(aParaNumbering.pPrefix->GetText() + aAdditionalInfoName);
 220                                         }
 221
 222                                         rtl::OUString aNumber = LwpSilverBullet::GetNumCharByStyleID(pParaNumber);
 223                                         if (pParaNumber->GetStyleID() == NUMCHAR_01 || pParaNumber->GetStyleID() == NUMCHAR_Chinese4)
 224                                         {
 225                                                 aPrefix += rtl::OUString::createFromAscii("0");
 226                                         }
 227                                         aFmt.SetPrefix(aPrefix);
 228
 229                                         aFmt.SetFormat(aNumber);
 230
 231                                         if (aParaNumbering.pSuffix)
 232                                         {
 233                                                 aFmt.SetSuffix(aParaNumbering.pSuffix->GetText());
 234                                         }
 235
 236                                         //set numbering format into the style-list.
 237                                         pListStyle->SetListNumber(nPos, aFmt, pParaNumber->GetStart()+1);
 238
 239                                 }
 240                                 else
 241                                 {
 242                                         rtl::OUString aPrefix, aSuffix;
 243                                         if (aParaNumbering.pPrefix)
 244                                         {
 245                                                 aPrefix = aParaNumbering.pPrefix->GetText();
 246                                         }
 247                                         if (aParaNumbering.pSuffix)
 248                                         {
 249                                                 aSuffix = aParaNumbering.pSuffix->GetText();
 250                                         }
 251
 252                                         pListStyle->SetListBullet(nPos, LwpSilverBullet::GetNumCharByStyleID(pParaNumber).toChar(),
 253                                                 rtl::OUString::createFromAscii("Times New Roman"), aPrefix, aSuffix);
 254                                 }
 255
 256                                 pListStyle->SetListPosition(nPos, 0.0, 0.635, 0.0);
 257                         }
 258                         aStyleName = pXFStyleMgr->AddStyle(pListStyle)->GetStyleName();
 259                         }
 260
 261         }
 262
 263         m_vStyleNameList.push_back(aStyleName);
 264         return aStyleName;
 265
 266 }
 267
 268 /**
 269  * @short   No use now.
 270  * @param   rContent
 271  * @param   nFontID
 272  * @param   pIndent
 273  */
 274 /*rtl::OUString LwpBulletStyleMgr::RegisterBulletStyle(const rtl::OUString& rContent, sal_uInt32 nFontID, LwpIndentOverride* pIndent)
 275 {
 276         if (!pIndent)
 277         {
 278                 assert(false);
 279         }
 280
 281         if (!m_pFoundry)
 282         {
 283                 return rtl::OUString::createFromAscii("");
 284         }
 285         LwpFontManager* pFontMgr = m_pFoundry->GetFontManger();
 286
 287         rtl::OUString aFontName = pFontMgr->GetNameByID(nFontID);
 288         UChar32 cBulletChar = rContent.toChar();
 289         rtl::OUString aSuffix = rContent.copy(1);
 290         XFListStyle* pListStyle = new XFListStyle();
 291         XFStyleManager* pXFStyleMgr = XFStyleManager::Instance();
 292
 293         for (sal_uInt8 nC = 1; nC < 11; nC++)
 294         {
 295                 pListStyle->SetListBullet(nC, cBulletChar, aFontName, rtl::OUString::createFromAscii(""), aSuffix);
 296
 297                 if (pIndent->GetMRest() > 0.001)
 298                 {
 299                         pListStyle->SetListPosition(nC, 0.0,
 300                                 LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(pIndent->GetMRest())), 0.0);
 301                 }
 302                 else
 303                 {
 304                         pListStyle->SetListPosition(nC, 0.0,
 305                                 0.0, LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(pIndent->GetMFirst())));
 306                 }
 307         }
 308         return pXFStyleMgr->AddStyle(pListStyle);
 309 }*/
 310
 311 /**
 312  * @short   No use now.
 313  * @param   pListStyle
 314  * @param   pXFStyleMgr
 315  */
 316 /*void LwpBulletStyleMgr::CreateNewListStyle(XFListStyle*& pListStyle, XFStyleManager* pXFStyleMgr)
 317 {
 318         pListStyle = new XFListStyle();
 319         m_aBulletStyleList.push_back(pListStyle);
 320         m_aCurrentStyleName = pXFStyleMgr->AddStyle(pListStyle);
 321 }*/
 322
 323 /**
 324  * @short   No use now.
 325  * @param   pSilverBullet
 326  * @param   nLevel
 327  */
 328 /*rtl::OUString LwpBulletStyleMgr::AddStyleToList(LwpSilverBullet* pSilverBullet, sal_uInt16 nLevel)
 329 {
 330         XFListStyle* pListStyle = NULL;
 331         XFStyleManager* pXFStyleMgr = XFStyleManager::Instance();
 332
 333         if (m_aBulletStyleList.empty())
 334         {
 335         //      pListStyle = new XFListStyle();
 336         //      m_aBulletStyleList.push_back(pListStyle);
 337         //      m_aCurrentStyleName = pXFStyleMgr->AddStyle(pListStyle);
 338         //      this->CreateNewListStyle(pListStyle, pXFStyleMgr);
 339                 if (pSilverBullet->IsBulletOrdered())
 340                 {
 341                         m_strCurrentNumberingName = pSilverBullet->GetNumberingName();
 342                 }
 343                 else
 344                 {
 345                         m_nCurrentChar = pSilverBullet->GetBulletChar();
 346                         m_strCurrentFontName = pSilverBullet->GetBulletFontName();
 347                 }
 348         }
 349         else if (nLevel == 1)
 350         {
 351                 if (pSilverBullet->IsBulletOrdered())
 352                 {
 353                         if (m_strCurrentNumberingName == pSilverBullet->GetNumberingName())
 354                         {
 355                                 pListStyle = m_aBulletStyleList.back();
 356                         }
 357                         else
 358                         {
 359                                 this->CreateNewListStyle(pListStyle, pXFStyleMgr);
 360                         }
 361                 }
 362                 else
 363                 {
 364                         if ((m_nCurrentChar == pSilverBullet->GetBulletChar()) &&
 365                                 (m_strCurrentFontName == pSilverBullet->GetBulletFontName()))
 366                         {
 367                                 pListStyle = m_aBulletStyleList.back();
 368                         }
 369                         else
 370                         {
 371                                 this->CreateNewListStyle(pListStyle, pXFStyleMgr);
 372                         }
 373                 }
 374         }
 375         else
 376         {
 377                 pListStyle = m_aBulletStyleList.back();
 378         }
 379
 380         if (pSilverBullet->IsBulletOrdered())
 381         {
 382 //              pListStyle->SetListNumber(int level, XFNumFmt & fmt, sal_Int16 start);
 383         }
 384         else
 385         {
 386                 pListStyle->SetListBullet(nLevel, pSilverBullet->GetBulletChar(), pSilverBullet->GetBulletFontName(),
 387                         pSilverBullet->GetPrefix(), pSilverBullet->GetSuffix());
 388         }
 389
 390         return m_aCurrentStyleName;
 391 }*/
 392
 393 /**
 394  * @short   Output bullet list header, such as <text:ordered-list> and <text:list-item>
 395  * @param   pOutputStream pointer of XFstream to be written in.
 396  * @param   bIsOrdered if the list if ordered or not.
 397  * @param   rStyleName style name of the list
 398  * @param   nLevel level of the paragraph
 399  */
 400 void LwpBulletStyleMgr::OutputBulletListHeader(IXFStream* pOutputStream, sal_Bool bIsOrdered,
 401                 const rtl::OUString& rStyleName, sal_Int16 nLevel, sal_Bool bIsBulletSkiped)
 402 {
 403         if (nLevel == 0)
 404         {
 405                 return;
 406         }
 407
 408         m_bIsBulletSkipped = bIsBulletSkiped;
 409
 410         if (m_pBulletList)
 411         {
 412                 delete m_pBulletList;
 413         }
 414
 415         m_pBulletList = new XFList();
 416
 417         //todo: need judge here.
 418         sal_Bool bContinue = m_bContinue;
 419
 420         if (bIsOrdered)
 421         {
 422                 m_pBulletList->SetOrdered(sal_True);
 423         }
 424         else
 425         {
 426                 bContinue = sal_False;
 427                 m_pBulletList->SetOrdered(sal_False);
 428         }
 429         m_pBulletList->SetStyleName(rStyleName);
 430 //      if (nLevels < 0)
 431 //      {
 432 //              m_pBulletList->StartList(pOutputStream);
 433 //      }
 434 //      else
 435 //      {
 436                 for (sal_uInt8 nC = 0; nC < nLevel; nC++)
 437                 {
 438                         //continue numbering
 439                         if (nC == nLevel-1)
 440                         {
 441                                 m_pBulletList->StartList(pOutputStream, bContinue);
 442                         }
 443                         else
 444                         {
 445                                 m_pBulletList->StartList(pOutputStream);
 446                         }
 447                         if ((nC == nLevel-1) && bIsBulletSkiped)
 448                         {
 449                                 XFList::StartListHeader(pOutputStream);
 450                         }
 451                         else
 452                         {
 453                                 XFList::StartListItem(pOutputStream);
 454                         }
 455                 }
 456 //      }
 457 }
 458
 459 #include "xfilter/xflistitem.hxx"
 460 //Create nested XFList and XFItems and then add it to XFContentContainer(pCont)
 461 //Return the inner XFItem created.
 462 XFContentContainer* LwpBulletStyleMgr::AddBulletList(
 463                 XFContentContainer* pCont, sal_Bool bIsOrdered,
 464                 const rtl::OUString& rStyleName, sal_Int16 nLevel, sal_Bool bIsBulletSkiped)
 465 {
 466         assert(nLevel>0);
 467
 468         m_bIsBulletSkipped = bIsBulletSkiped;
 469
 470         //todo: need judge here.
 471         sal_Bool bContinue = m_bContinue;
 472
 473         XFList* theList;
 474         XFList* prevList = NULL;
 475         XFListItem* theItem;
 476         XFListItem* InnerItem = NULL;
 477         for (sal_Int8 nC = nLevel-1; nC >= 0; nC--)
 478         {
 479                 theList = new XFList();
 480                 theItem = new XFListItem();
 481                 theList->Add(theItem);
 482
 483                 if (bIsOrdered)
 484                 {
 485                         theList->SetOrdered(sal_True);
 486                 }
 487                 else
 488                 {
 489                         bContinue = sal_False;
 490                         theList->SetOrdered(sal_False);
 491                 }
 492
 493                 if (nC == nLevel-1)
 494                 {
 495                         theList->SetContinueNumber(bContinue);
 496                 }
 497                 //Add the outer list to pCont
 498                 if (nC == 0)
 499                 {
 500                         theList->SetStyleName(rStyleName);
 501                         pCont->Add(theList);
 502                 }
 503
 504                 if ((nC == nLevel-1) && bIsBulletSkiped)
 505                 {
 506                         theItem->SetIsHeader(sal_True);
 507
 508                         theList->SetContinueNumber(sal_True);
 509                         // end of add
 510                 }
 511
 512                 if(nC == nLevel-1)
 513                 {
 514                         InnerItem = theItem;
 515                 }
 516
 517                 if(prevList)
 518                 {
 519                         theItem->Add(prevList);
 520                 }
 521                 prevList = theList;
 522         }
 523         return InnerItem;
 524 }
 525
 526 /**
 527  * @short   Output bullet list header, such as </text:ordered-list> and </text:list-item>
 528  * @param   pOutputStream pointer of XFstream to be written in.
 529  * @param   nLevel level of the paragraph
 530  */
 531 void LwpBulletStyleMgr::OutputBulletListTail(IXFStream* pOutputStream, sal_uInt16 nLevel)
 532 {
 533         if ( !m_pBulletList )
 534         {
 535                 return;
 536         }
 537
 538         for (sal_uInt8 nC = 0; nC < nLevel; nC++)
 539         {
 540                 if (m_bIsBulletSkipped)
 541                 {
 542                         XFList::EndListHeader(pOutputStream);
 543                         m_bIsBulletSkipped = sal_False;
 544                 }
 545                 else
 546                 {
 547                         XFList::EndListItem(pOutputStream);
 548                 }
 549                 m_pBulletList->EndList(pOutputStream);
 550         }
 551 }
 552
 553 rtl::OUString LwpBulletStyleMgr::GetDivisionName()
 554 {
 555         if (!m_pFoundry)
 556         {
 557                 return rtl::OUString::createFromAscii("");
 558         }
 559
 560         rtl::OUString aRet = rtl::OUString::createFromAscii("");
 561
 562         LwpDocument* pDoc = m_pFoundry->GetDocument();
 563         if (pDoc)
 564         {
 565                 LwpObjectID* pID = pDoc->GetDivInfoID();
 566                 if (!pID->IsNull())
 567                 {
 568                         aRet = static_cast<LwpDivInfo*>(pID->obj(VO_DIVISIONINFO))->GetDivName();
 569                 }
 570         }
 571
 572         return aRet;
 573 }
 574
 575 rtl::OUString LwpBulletStyleMgr::GetSectionName(LwpPara* pPara)
 576 {
 577         LwpObjectID* pStoryID = pPara->GetStoryID();
 578         if (pStoryID->IsNull())
 579         {
 580                 return rtl::OUString::createFromAscii("");
 581         }
 582
 583         LwpStory* pStory = static_cast<LwpStory*>(pStoryID->obj(VO_STORY));
 584         if (!pStory)
 585         {
 586                 return rtl::OUString::createFromAscii("");
 587         }
 588
 589         return pStory->GetSectionName();
 590 }