lotuswordpro/source/filter/lwppara1.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 #include <memory>
  62
  63 #include <boost/cast.hpp>
  64
  65 #include "lwppara.hxx"
  66 #include "lwpglobalmgr.hxx"
  67 #include "lwpfilehdr.hxx"
  68 #include "lwpparaproperty.hxx"
  69 #include "lwptools.hxx"
  70 #include "lwpparastyle.hxx"
  71 #include "xfilter/xffont.hxx"
  72 #include "xfilter/xftextstyle.hxx"
  73 #include "xfilter/xfstylemanager.hxx"
  74 #include "xfilter/xfparagraph.hxx"
  75 #include "xfilter/xftextcontent.hxx"
  76 #include "xfilter/xftextspan.hxx"
  77 #include "xfilter/xfmargins.hxx"
  78 #include "xfilter/xftabstop.hxx"
  79 #include "xfilter/xflinebreak.hxx"
  80 #include "xfilter/xfsection.hxx"
  81 #include "xfilter/xfsectionstyle.hxx"
  82 #include "xfilter/xfcolor.hxx"
  83 #include "xfilter/xfhyperlink.hxx"
  84 #include "lwpcharsetmgr.hxx"
  85 #include "lwpsection.hxx"
  86 #include "lwplayout.hxx"
  87 #include "lwpusewhen.hxx"
  88
  89 #include "lwpbulletstylemgr.hxx"
  90 #include "lwpstory.hxx"
  91 #include "lwpsilverbullet.hxx"
  92 #include "xfilter/xflist.hxx"
  93 #include "xfilter/xfframe.hxx"
  94
  95 #include "lwpdivinfo.hxx"
  96 #include "lwpdoc.hxx"
  97 #include "lwpholder.hxx"
  98 #include "lwppagehint.hxx"
  99
 100 #include "lwpdropcapmgr.hxx"
 101 #include "lwptable.hxx"
 102 #include "lwpcelllayout.hxx"
 103
 104 // boost::polymorphic_downcast checks and reports (using assert), if the
 105 // cast is incorrect (in debug builds).
 106 using boost::polymorphic_downcast;
 107
 108 /**
 109  * @short   get text of paragraph
 110  */
 111 OUString LwpPara::GetContentText(bool bAllText)
 112 {
 113 //  rFont = m_FontID;
 114     if (bAllText)
 115     {
 116         m_Fribs.SetPara(this);
 117         m_Fribs.GatherAllText();
 118         return m_AllText;
 119     }
 120     else
 121         return m_Content;
 122 }
 123
 124 /**
 125  * @short   set text of paragraph
 126  */
 127 void LwpPara::SetAllText(const OUString& sText)
 128 {
 129     m_AllText+=sText;
 130 }
 131
 132 /**
 133  * @short   set first frib content
 134  */
 135 void LwpPara::SetFirstFrib(const OUString& Content,sal_uInt32 FontID)
 136 {
 137     m_FontID= FontID;
 138     m_Content=Content;
 139 }
 140 /**
 141  * @short   get paragraph xfstyle
 142  */
 143 XFParaStyle* LwpPara::GetXFParaStyle()
 144 {
 145     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
 146     return pXFStyleManager->FindParaStyle(m_StyleName);
 147 }
 148 /**
 149  * @short   get drop cap info
 150  */
 151 #include "lwpframelayout.hxx"
 152 void LwpPara::GatherDropcapInfo()
 153 {
 154     SetDropcapLines(m_pDropcapLayout->GetLines());
 155     SetDropcapChars(m_pDropcapLayout->GetChars());
 156 }
 157 /**
 158  * @short   get parent paragraph
 159  */
 160 LwpPara* LwpPara::GetParent()
 161 {
 162     LwpPara* pPara;
 163     sal_uInt16 otherlevel;
 164     sal_uInt16 level = GetLevel();
 165
 166     if (level != 1)
 167     {
 168         pPara = dynamic_cast<LwpPara*>(GetPrevious().obj().get());
 169         while (pPara)
 170         {
 171             otherlevel = pPara->GetLevel();
 172             if ((otherlevel < level) || (otherlevel && (level == 0)))
 173                 return pPara;
 174             pPara = dynamic_cast<LwpPara*>(pPara->GetPrevious().obj().get());
 175         }
 176     }
 177     return nullptr;
 178 }
 179
 180 /**
 181  * @short:   Offer prefix, paranumber and suffix according to position.
 182  * @param:   nPosition index of wanted paranumbering in the style-list.
 183  * @param:   pParaNumbering a pointer to the structure which contains prefix, paranumber and
 184  *       suffix.
 185  */
 186 void LwpPara::GetParaNumber(sal_uInt16 nPosition, ParaNumbering* pParaNumbering)
 187 {
 188     if (nPosition > 9)
 189     {
 190         return;
 191     }
 192     sal_uInt16 nCurrentPos = 0;
 193
 194     LwpFrib* pPreFrib = nullptr;
 195     LwpFrib* pFrib = m_Fribs.GetFribs();
 196     if (!pFrib)
 197     {
 198         return;
 199     }
 200
 201     while (pFrib)
 202     {
 203         sal_uInt8 nFribType = pFrib->GetType();
 204         if (nFribType == FRIB_TAG_PARANUMBER)
 205         {
 206             nCurrentPos++;
 207             ModifierInfo* pModInfo = pFrib->GetModifiers();
 208             if (pModInfo)
 209             {
 210                 sal_uInt16 nHideLevels = pModInfo->aTxtAttrOverride.GetHideLevels();
 211                 if (nCurrentPos == nPosition)
 212                 {
 213                     //get prefix text frib
 214                     if (pPreFrib)
 215                     {
 216                         if ((pPreFrib->GetType() == FRIB_TAG_TEXT) &&
 217                             (pPreFrib->GetModifiers() && pPreFrib->GetModifiers()->aTxtAttrOverride.GetHideLevels() == nHideLevels))
 218                         {
 219                             pParaNumbering->pPrefix = static_cast<LwpFribText*>(pPreFrib);
 220                         }
 221                     }
 222
 223                     //get para numbering
 224                     pParaNumbering->pParaNumber = static_cast<LwpFribParaNumber*>(pFrib);
 225                     pParaNumbering->nNumLevel = nHideLevels;
 226
 227                     //get suffix text frib
 228                     if ( (pFrib = pFrib->GetNext()) )
 229                     {
 230                         if( pFrib->GetType() == FRIB_TAG_TEXT )
 231                         {
 232                             if (
 233                                  (pFrib->GetNext() && pFrib->GetNext()->GetType() == FRIB_TAG_TEXT) ||
 234                                  (pFrib->GetModifiers() && pFrib->GetModifiers()->aTxtAttrOverride.GetHideLevels() == nHideLevels)
 235                                )
 236                             {
 237                                 pParaNumbering->pSuffix = static_cast<LwpFribText*>(pFrib);
 238                             }
 239                         }
 240                     }
 241
 242                     break;
 243                 }
 244             }
 245             else
 246             {
 247                 if (nCurrentPos == nPosition)
 248                 {
 249                     //get prefix text frib
 250                     if (pPreFrib)
 251                     {
 252                         if (pPreFrib->GetType() == FRIB_TAG_TEXT)
 253                         {
 254                             pParaNumbering->pPrefix = static_cast<LwpFribText*>(pPreFrib);
 255                         }
 256                     }
 257
 258                     //get para numbering
 259                     pParaNumbering->pParaNumber = static_cast<LwpFribParaNumber*>(pFrib);
 260
 261                     //get suffix text frib
 262                     if ( (pFrib = pFrib->GetNext()) )
 263                     {
 264                         if (pFrib->GetType() == FRIB_TAG_TEXT)
 265                         {
 266                             pParaNumbering->pSuffix = static_cast<LwpFribText*>(pFrib);
 267                         }
 268                     }
 269
 270                 }
 271             }
 272         }
 273         pPreFrib = pFrib;
 274         if (pFrib)
 275         {
 276             pFrib = pFrib->GetNext();
 277         }
 278     }
 279 }
 280 /**
 281  * @short   override alignment
 282  */
 283 void LwpPara::OverrideAlignment(LwpAlignmentOverride* base,LwpAlignmentOverride* over,XFParaStyle* pOverStyle)
 284 {
 285     if (base)//the latter two parameter never be null
 286     {
 287         over->Override(base);
 288         LwpParaStyle::ApplyAlignment(pOverStyle,base);
 289     }
 290     else
 291         LwpParaStyle::ApplyAlignment(pOverStyle,over);
 292 }
 293 /**
 294  * @short   override indent attribute
 295  */
 296 void LwpPara::OverrideIndent(LwpIndentOverride* base,LwpIndentOverride* over,XFParaStyle* pOverStyle)
 297 {
 298     if (base)//the latter two parameter never be null
 299     {
 300             over->Override(base);
 301             LwpParaStyle::ApplyIndent(this,pOverStyle,base);
 302     }
 303     else
 304     {
 305             LwpParaStyle::ApplyIndent(this,pOverStyle,over);
 306         }
 307 }
 308 /**
 309  * @short   override spacing
 310  */
 311 void LwpPara::OverrideSpacing(LwpSpacingOverride* base,LwpSpacingOverride* over,XFParaStyle* pOverStyle)
 312 {
 313     if (base)//the latter two parameter never be null
 314     {
 315         if (over)
 316             over->Override(base);
 317         LwpParaStyle::ApplySpacing(this,pOverStyle,base);
 318     }
 319     else
 320         LwpParaStyle::ApplySpacing(this,pOverStyle,over);
 321 }
 322
 323 /**
 324  * @short:   Get parastyle object according to the objID.
 325  * @return:  pointer to the parastyle.
 326  */
 327 LwpParaStyle* LwpPara::GetParaStyle()
 328 {
 329     return dynamic_cast<LwpParaStyle*>(m_ParaStyle.obj(VO_PARASTYLE).get());
 330 }
 331
 332 /**
 333  * @short:   Override paraborder style.
 334  * @param:   pProps pointer to the LwpParaProperty and we can get local breaks through it.
 335  * @param:   pOverStyle pointer to XFParaStyle which contains the parastyle for XFilter.
 336  */
 337 void LwpPara::OverrideParaBorder(LwpParaProperty* pProps, XFParaStyle* pOverStyle)
 338 {
 339     // get paraborder in parastyle
 340     LwpParaStyle* pParaStyle = GetParaStyle();
 341     if (!pParaStyle)
 342     {
 343         return;
 344     }
 345
 346     LwpOverride* pBorder = pParaStyle->GetParaBorder();
 347     std::unique_ptr<LwpParaBorderOverride> pFinalBorder(
 348         pBorder
 349             ? polymorphic_downcast<LwpParaBorderOverride*>(pBorder->clone())
 350             : new LwpParaBorderOverride)
 351         ;
 352
 353     // get local border
 354     pBorder = static_cast<LwpParaBorderProperty*>(pProps)->GetLocalParaBorder();
 355     if (pBorder)
 356     {
 357         std::unique_ptr<LwpParaBorderOverride> pLocalBorder(
 358                 polymorphic_downcast<LwpParaBorderOverride*>(pBorder->clone()));
 359         pLocalBorder->Override(pFinalBorder.get());
 360     }
 361
 362     LwpParaStyle::ApplyParaBorder(pOverStyle, pFinalBorder.get());
 363 }
 364 /**
 365  * @short:   Override parabreaks style.
 366  * @param:   pProps pointer to the LwpParaProperty and we can get local breaks through it.
 367  * @param:   pOverStyle pointer to XFParaStyle which contains the parastyle for XFilter.
 368  */
 369 void LwpPara::OverrideParaBreaks(LwpParaProperty* pProps, XFParaStyle* pOverStyle)
 370 {
 371     // get breaks in parastyle
 372     LwpParaStyle* pParaStyle = GetParaStyle();
 373     if (!pParaStyle)
 374     {
 375         return;
 376     }
 377
 378     LwpOverride* pBreaks = pParaStyle->GetBreaks();
 379     std::unique_ptr<LwpBreaksOverride> pFinalBreaks(
 380         pBreaks
 381             ? polymorphic_downcast<LwpBreaksOverride*>(pBreaks->clone())
 382             : new LwpBreaksOverride)
 383         ;
 384
 385     // get local breaks
 386     pBreaks = static_cast<LwpParaBreaksProperty*>(pProps)->GetLocalParaBreaks();
 387     if (pBreaks)
 388     {
 389         std::unique_ptr<LwpBreaksOverride> const pLocalBreaks(
 390                 polymorphic_downcast<LwpBreaksOverride*>(pBreaks->clone()));
 391         pLocalBreaks->Override(pFinalBreaks.get());
 392     }
 393
 394     // save the breaks
 395     delete m_pBreaks;
 396     m_pBreaks = pFinalBreaks.release();
 397
 398     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
 399     if (m_pBreaks->IsKeepWithNext())
 400     {
 401         pOverStyle->SetBreaks(enumXFBreakKeepWithNext);
 402     }
 403     if (m_pBreaks->IsPageBreakBefore())
 404     {
 405         XFParaStyle* pStyle = new XFParaStyle();
 406         pStyle->SetBreaks(enumXFBreakAftPage);
 407         m_BefPageBreakName = pXFStyleManager->AddStyle(pStyle).m_pStyle->GetStyleName();
 408     }
 409     if (m_pBreaks->IsPageBreakAfter())
 410     {
 411         XFParaStyle* pStyle = new XFParaStyle();
 412         pStyle->SetBreaks(enumXFBreakAftPage);
 413         m_AftPageBreakName = pXFStyleManager->AddStyle(pStyle).m_pStyle->GetStyleName();
 414     }
 415     if (m_pBreaks->IsColumnBreakBefore())
 416     {
 417         XFParaStyle* pStyle = new XFParaStyle();
 418         pStyle->SetBreaks(enumXFBreakAftColumn);//tmp after, should change when layout read
 419         m_BefColumnBreakName = pXFStyleManager->AddStyle(pStyle).m_pStyle->GetStyleName();
 420     }
 421     if (m_pBreaks->IsColumnBreakAfter())
 422     {
 423         XFParaStyle* pStyle = new XFParaStyle();
 424         pStyle->SetBreaks(enumXFBreakAftColumn);
 425         m_AftColumnBreakName = pXFStyleManager->AddStyle(pStyle).m_pStyle->GetStyleName();
 426     }
 427
 428 //  pParaStyle->ApplyBreaks(pOverStyle, &aFinalBreaks);
 429 }
 430
 431 /**
 432  * @short:   Override bullet styles.
 433  * @param:   pProps pointer to the LwpParaProperty and we can get local bullet through it.
 434  */
 435 void LwpPara::OverrideParaBullet(LwpParaProperty* pProps)
 436 {
 437     // get bulletoverride in parastyle
 438     LwpParaStyle* pParaStyle = GetParaStyle();
 439     if (!pParaStyle)
 440     {
 441         return;
 442     }
 443
 444     if (pProps)
 445     {
 446         m_pBullOver = new LwpBulletOverride();
 447         // get local bulletoverride
 448         LwpBulletOverride* pLocalBullet  = static_cast<LwpParaBulletProperty*>(pProps)->GetLocalParaBullet();
 449         if (!pLocalBullet)
 450         {
 451             return;
 452         }
 453
 454         LwpObjectID aSilverBulletID = pLocalBullet->GetSilverBullet();
 455         if (aSilverBulletID.IsNull())
 456         {
 457             return;
 458         }
 459         else
 460         {
 461             m_bHasBullet = true;
 462
 463             LwpOverride* pBullet= pParaStyle->GetBulletOverride();
 464             std::unique_ptr<LwpBulletOverride> pFinalBullet(
 465                 pBullet
 466                     ? polymorphic_downcast<LwpBulletOverride*>(pBullet->clone())
 467                     : new LwpBulletOverride)
 468                 ;
 469
 470             std::unique_ptr<LwpBulletOverride> const pLocalBullet2(pLocalBullet->clone());
 471             pLocalBullet2->Override(pFinalBullet.get());
 472
 473             aSilverBulletID = pFinalBullet->GetSilverBullet();
 474             delete m_pBullOver;
 475             m_pBullOver = pFinalBullet.release();
 476             if (!aSilverBulletID.IsNull())
 477             {
 478                 m_pSilverBullet = dynamic_cast<LwpSilverBullet*>(aSilverBulletID.obj(VO_SILVERBULLET).get());
 479                 if (m_pSilverBullet)
 480                     m_pSilverBullet->SetFoundry(m_pFoundry);
 481             }
 482
 483             m_aSilverBulletID = aSilverBulletID;
 484         }
 485     }
 486     else
 487     {
 488 //      m_pBullOver = pParaStyle->GetBulletOverride();
 489         LwpBulletOverride* pBullOver = pParaStyle->GetBulletOverride();
 490         if (pBullOver)
 491         {
 492             m_aSilverBulletID = pBullOver->GetSilverBullet();
 493             if (!m_aSilverBulletID.IsNull())
 494             {
 495                 m_bHasBullet = true;
 496
 497                 m_pSilverBullet = dynamic_cast<LwpSilverBullet*>(m_aSilverBulletID.obj(VO_SILVERBULLET).get());
 498                 if (m_pSilverBullet)
 499                     m_pSilverBullet->SetFoundry(m_pFoundry);
 500             }
 501
 502             std::unique_ptr<LwpBulletOverride> pBulletOverride(pBullOver->clone());
 503             delete m_pBullOver;
 504             m_pBullOver = pBulletOverride.release();
 505         }
 506     }
 507 }
 508 /**
 509  * @short:   Override paranumbering properties.
 510  * @param:   pProps pointer to the LwpParaProperty and we can get local paranumbering through it.
 511  */
 512 void LwpPara::OverrideParaNumbering(LwpParaProperty* pProps)
 513 {
 514     // get numbering override in parastyle
 515     LwpParaStyle* pParaStyle = GetParaStyle();
 516     if (!pParaStyle)
 517     {
 518         return;
 519     }
 520
 521     LwpNumberingOverride* pParaNumbering = pParaStyle->GetNumberingOverride();
 522     std::unique_ptr<LwpNumberingOverride> pOver(new LwpNumberingOverride);
 523     //Override with the local numbering, if any
 524     if (pProps)
 525     {
 526         LwpNumberingOverride* pPropNumbering = static_cast<LwpParaNumberingProperty*>(pProps)->GetLocalNumbering();
 527         if (pPropNumbering)
 528         {
 529             pOver.reset(pPropNumbering->clone());
 530         }
 531     }
 532     else
 533     {
 534         if (pParaNumbering)
 535         {
 536             pOver.reset(pParaNumbering->clone());
 537         }
 538     }
 539
 540     if (m_nFlags & VALID_LEVEL)
 541     {
 542         pOver->OverrideLevel(m_nLevel);
 543     }
 544
 545     m_pParaNumbering.reset(pOver.release());
 546 }
 547
 548 void LwpPara::FindLayouts()
 549 {
 550     m_Fribs.SetPara(this);
 551     m_Fribs.FindLayouts();
 552     LwpPara* pNextPara = dynamic_cast<LwpPara*>(GetNext().obj().get());
 553     if(pNextPara)
 554     {
 555         pNextPara->FindLayouts();
 556     }
 557 }
 558
 559 /**************************************************************************
 560  * @descr:  Get property according to the property type
 561 **************************************************************************/
 562 LwpParaProperty* LwpPara::GetProperty(sal_uInt32 nPropType)
 563 {
 564     LwpParaProperty* pProps = m_pProps;
 565     while(pProps)
 566     {
 567         if(pProps->GetType() == nPropType)
 568         {
 569             return pProps;
 570         }
 571         pProps = pProps->GetNext();
 572
 573     }
 574     return nullptr;
 575 }
 576
 577 /**************************************************************************
 578  * @descr:  Get local tab rack
 579 **************************************************************************/
 580 LwpTabOverride* LwpPara::GetLocalTabOverride()
 581 {
 582     LwpParaProperty* pProp = GetProperty(PP_LOCAL_TABRACK);
 583     if(pProp)
 584     {
 585         return static_cast<LwpParaTabRackProperty*>(pProp)->GetTab();
 586     }
 587     return nullptr;
 588 }
 589
 590 /**
 591 * @descr:   Determined which para is earlier in position
 592 *
 593 */
 594 bool LwpPara::operator< (LwpPara& Other)
 595 {
 596     return m_nOrdinal < Other.GetOrdinal();
 597 }
 598
 599 /**
 600 * @descr:  If the two layouts in the same para, compare which layout is earlied according to frib order
 601 *
 602 */
 603 bool LwpPara::ComparePagePosition(LwpVirtualLayout * pPreLayout, LwpVirtualLayout * pNextLayout)
 604 {
 605     m_Fribs.SetPara(this);
 606     return m_Fribs.ComparePagePosition(pPreLayout, pNextLayout);
 607 }
 608
 609 /**
 610  * @short   check paragraph in cell or not
 611  */
 612 bool LwpPara::IsInCell()
 613 {
 614     LwpStory *pStory = GetStory();
 615     if (!pStory)
 616         return false;
 617     rtl::Reference<LwpVirtualLayout> xLayout(pStory->GetLayout(nullptr));
 618     if (xLayout.is() && xLayout->IsCell())
 619         return true;
 620     return false;
 621 }
 622
 623 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */