sw/source/filter/rtf/rtfnum.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: rtfnum.cxx,v $
  10  * $Revision: 1.26 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sw.hxx"
  33 #include <hintids.hxx>
  34 #include <tools/stream.hxx>
  35 #include <svtools/rtftoken.h>
  36 #include <svtools/rtfkeywd.hxx>
  37 #include <svtools/intitem.hxx>
  38 #include <svtools/rtfout.hxx>
  39 #include <svx/lrspitem.hxx>
  40 #include <svx/fontitem.hxx>
  41 #include <svx/fhgtitem.hxx>
  42 #include <svx/wghtitem.hxx>
  43 #include <svx/postitem.hxx>
  44 #include <svx/cmapitem.hxx>
  45 #include <svx/crsditem.hxx>
  46 #include <svx/colritem.hxx>
  47 #include <svx/udlnitem.hxx>
  48 #include <svx/wrlmitem.hxx>
  49 #include <shellio.hxx>
  50 #include <fltini.hxx>
  51 #include <swtypes.hxx>
  52 #include <swparrtf.hxx>
  53 #include <wrtrtf.hxx>
  54 #include <ndtxt.hxx>
  55 #include <doc.hxx>
  56 #include <docary.hxx>
  57 #include <pam.hxx>
  58 #include <charfmt.hxx>
  59 #include <charatr.hxx>
  60 #include <paratr.hxx>
  61 #ifndef _CMDID_H
  62 #include <cmdid.h>
  63 #endif
  64 #include <numrule.hxx>
  65
  66 #define RTF_NUMRULE_NAME "RTF_Num"
  67
  68 SV_IMPL_VARARR( SwListArr, SwListEntry )
  69
  70
  71 void lcl_ExpandNumFmts( SwNumRule& rRule )
  72 {
  73     // dann noch das NumFormat in alle Ebenen setzen
  74     for( BYTE n = 1; n < MAXLEVEL; ++n )
  75         if( !rRule.GetNumFmt( n ) )
  76         {
  77             SwNumFmt aNumFmt( rRule.Get( 0 ));
  78             aNumFmt.SetAbsLSpace( aNumFmt.GetAbsLSpace() * ( n + 1 ) );
  79             rRule.Set( n, aNumFmt );
  80         }
  81 }
  82
  83 SfxItemSet& GetNumChrFmt( SwDoc& rDoc, SwNumRule& rRule, BYTE nNumLvl )
  84 {
  85     SwCharFmt* pChrFmt = rRule.Get( nNumLvl ).GetCharFmt();
  86     if( !pChrFmt )
  87     {
  88         String sNm( rRule.GetName() );
  89         ( sNm += ' ' ) += String::CreateFromInt32( nNumLvl + 1 );
  90         pChrFmt = rDoc.MakeCharFmt( sNm, rDoc.GetDfltCharFmt() );
  91         if( !rRule.GetNumFmt( nNumLvl ))
  92             rRule.Set( nNumLvl, rRule.Get( nNumLvl ) );
  93         ((SwNumFmt*)rRule.GetNumFmt( nNumLvl ))->SetCharFmt( pChrFmt );
  94     }
  95     return (SfxItemSet&)pChrFmt->GetAttrSet();
  96 }
  97
  98 void SwRTFParser::ReadListLevel( SwNumRule& rRule, BYTE nNumLvl )
  99 {
 100     int nToken;
 101     int nNumOpenBrakets = 1;            // die erste wurde schon vorher erkannt !!
 102     int nLvlTxtLevel = 0, nLvlNumberLevel = 0;
 103     String sLvlText, sLvlNumber;
 104     SwNumFmt* pCurNumFmt;
 105     String aStringFollow = aEmptyStr;
 106
 107     if( MAXLEVEL >= nNumLvl )
 108     {
 109         pCurNumFmt = (SwNumFmt*)rRule.GetNumFmt( nNumLvl );
 110         pCurNumFmt->SetAbsLSpace( 0 );
 111         pCurNumFmt->SetFirstLineOffset( 0 );
 112     }
 113     else
 114         pCurNumFmt = 0;
 115
 116     while( nNumOpenBrakets && IsParserWorking() )
 117     {
 118         switch( ( nToken = GetNextToken() ))
 119         {
 120         case '}':
 121             if( nNumOpenBrakets )
 122             {
 123                 if( nLvlTxtLevel == nNumOpenBrakets )
 124                 {
 125                     if( DelCharAtEnd( sLvlText, ';' ).Len() &&
 126                         sLvlText.Len() && sLvlText.Len() ==
 127                         (USHORT)(sLvlText.GetChar( 0 )) + 1 )
 128                         sLvlText.Erase( 0, 1 );
 129                     nLvlTxtLevel = 0;
 130                 }
 131                 if( nLvlNumberLevel == nNumOpenBrakets )
 132                 {
 133                     DelCharAtEnd( sLvlNumber, ';' );
 134                     nLvlNumberLevel = 0;
 135                 }
 136             }
 137             --nNumOpenBrakets;
 138             break;
 139
 140         case '{':
 141             {
 142                 if( RTF_IGNOREFLAG != GetNextToken() )
 143                     nToken = SkipToken( -1 );
 144                 // Unknown und alle bekannten nicht ausgewerteten Gruppen
 145                 // sofort ueberspringen
 146                 else if( RTF_UNKNOWNCONTROL != ( nToken = GetNextToken() ))
 147 //                                              RTF_PANOSE != nToken && RTF_FALT != nToken &&
 148 //                                              RTF_FALT != nToken && RTF_FNAME != nToken &&
 149 //                                              RTF_FONTEMB != nToken && RTF_FONTFILE != nToken )
 150                     nToken = SkipToken( -2 );
 151                 else
 152                 {
 153                     // gleich herausfiltern
 154                     ReadUnknownData();
 155                     nToken = GetNextToken();
 156                     if( '}' != nToken )
 157                         eState = SVPAR_ERROR;
 158                     break;
 159                 }
 160                 ++nNumOpenBrakets;
 161             }
 162             break;
 163
 164         case RTF_LEVELNFC:
 165             {
 166                 sal_Int16 eType = SVX_NUM_ARABIC;
 167                 switch( nTokenValue )
 168                 {
 169                 case 1:         eType = SVX_NUM_ROMAN_UPPER;                    break;
 170                 case 2:         eType = SVX_NUM_ROMAN_LOWER;                    break;
 171                 case 3:         eType = SVX_NUM_CHARS_UPPER_LETTER_N;   break;
 172                 case 4:         eType = SVX_NUM_CHARS_LOWER_LETTER_N;   break;
 173                 case 255:
 174                 case 23:        eType = SVX_NUM_CHAR_SPECIAL;                   break;
 175                 }
 176                 if( pCurNumFmt )
 177                     pCurNumFmt->SetNumberingType(eType);
 178             }
 179             break;
 180
 181         case RTF_LEVELJC:
 182             {
 183                 SvxAdjust eAdj = SVX_ADJUST_LEFT;
 184                 switch( nTokenValue )
 185                 {
 186                 case 1:         eAdj = SVX_ADJUST_CENTER;       break;
 187                 case 2:         eAdj = SVX_ADJUST_RIGHT;        break;
 188                 }
 189                 if( pCurNumFmt )
 190                     pCurNumFmt->SetNumAdjust( eAdj );
 191             }
 192             break;
 193
 194         case RTF_LEVELSTARTAT:
 195             if( pCurNumFmt && -1 != nTokenValue )
 196                 pCurNumFmt->SetStart( USHORT( nTokenValue ));
 197             break;
 198
 199         case RTF_LEVELTEXT:
 200             nLvlTxtLevel = nNumOpenBrakets;
 201             break;
 202
 203         case RTF_LEVELNUMBERS:
 204             nLvlNumberLevel = nNumOpenBrakets;
 205             break;
 206
 207
 208         case RTF_TEXTTOKEN:
 209             if( nLvlTxtLevel == nNumOpenBrakets )
 210                 sLvlText += aToken;
 211             else if( nLvlNumberLevel == nNumOpenBrakets )
 212                 sLvlNumber += aToken;
 213             break;
 214
 215         case RTF_LEVELFOLLOW:
 216           /* removed; waiting for swnum02 to be integrated!
 217             switch (nTokenValue)
 218             {
 219             case 0:
 220                 aStringFollow=String('\t');
 221                 break;
 222             case 1:
 223                 aStringFollow=String(' ');
 224                 break;
 225             }
 226             */
 227             break;
 228
 229         case RTF_LEVELOLD:
 230         case RTF_LEVELPREV:
 231         case RTF_LEVELPREVSPACE:
 232         case RTF_LEVELINDENT:
 233         case RTF_LEVELSPACE:
 234         case RTF_LEVELLEGAL:
 235         case RTF_LEVELNORESTART:
 236             break;
 237
 238         default:
 239             if( pCurNumFmt && (
 240                 RTF_CHRFMT == (nToken & ~(0xff | RTF_SWGDEFS) ) ||
 241                 RTF_PARFMT == (nToken & ~(0xff | RTF_SWGDEFS) ) ))
 242             {
 243                 SfxItemSet aSet( pDoc->GetAttrPool(), aTxtNodeSetRange );
 244                 // put the current CharFmtAttr into the set
 245                 SfxItemSet& rCFmtSet = GetNumChrFmt( *pDoc, rRule, nNumLvl );
 246                 aSet.Put( rCFmtSet );
 247                 // and put the current "LRSpace" into the set
 248                 {
 249                     SvxLRSpaceItem aLR( RES_LR_SPACE );
 250                     aLR.SetTxtLeft( pCurNumFmt->GetAbsLSpace() );
 251                     aLR.SetTxtFirstLineOfst(pCurNumFmt->GetFirstLineOffset());
 252                     aSet.Put( aLR );
 253                 }
 254
 255                 ReadAttr( nToken, &aSet );
 256
 257                 //#i24880# Word appears to ignore char background for numbering
 258                 aSet.ClearItem(RES_CHRATR_BACKGROUND);
 259
 260                 // put all CharFmt Items into the charfmt
 261                 rCFmtSet.Put( aSet );
 262
 263                 // test for LRSpace Item. If exist then set all relevant
 264                 // values on the numrule format
 265                 const SfxPoolItem* pItem;
 266                 if( SFX_ITEM_SET == aSet.GetItemState( RES_LR_SPACE,
 267                         FALSE, &pItem ))
 268                 {
 269                     const SvxLRSpaceItem& rLR = *(SvxLRSpaceItem*)pItem;
 270                     pCurNumFmt->SetAbsLSpace( static_cast< short >(rLR.GetTxtLeft()) );
 271                     pCurNumFmt->SetFirstLineOffset( rLR.GetTxtFirstLineOfst());
 272                 }
 273
 274                 // dann aus der Vorlage den Font holen
 275                 if( SVX_NUM_CHAR_SPECIAL == pCurNumFmt->GetNumberingType() )
 276                     pCurNumFmt->SetBulletFont( FindFontOfItem(
 277                                 pCurNumFmt->GetCharFmt()->GetFont() ) );
 278             }
 279             break;
 280         }
 281     }
 282
 283     if( IsParserWorking() && pCurNumFmt )
 284     {
 285         // dann erzeuge mal die Pre/Postfix-Strings
 286         if( sLvlText.Len() &&
 287             SVX_NUM_CHAR_SPECIAL == pCurNumFmt->GetNumberingType() )
 288         {
 289             pCurNumFmt->SetBulletChar( sLvlText.GetChar( 0 ) );
 290             // dann aus der Vorlage den Font holen
 291             if( pCurNumFmt->GetCharFmt() )
 292                 pCurNumFmt->SetBulletFont( FindFontOfItem(
 293                         pCurNumFmt->GetCharFmt()->GetFont() ) );
 294         }
 295         else if( sLvlNumber.Len() && sLvlText.Len() )
 296         {
 297             // in sLvlText steht der Text, in sLvlNumber die Position
 298             // der Ebenen in sLvlText
 299             pCurNumFmt->SetPrefix(
 300                 sLvlText.Copy( 0, USHORT( sLvlNumber.GetChar( 0 ))-1 ));
 301             pCurNumFmt->SetSuffix( sLvlText.Copy(
 302                     USHORT( sLvlNumber.GetChar( sLvlNumber.Len()-1 )) ));
 303             // wieviele Levels stehen im String?
 304             pCurNumFmt->SetIncludeUpperLevels( (BYTE)sLvlNumber.Len() );
 305         }
 306         else
 307         {
 308             pCurNumFmt->SetNumberingType(SVX_NUM_NUMBER_NONE);
 309             pCurNumFmt->SetSuffix( sLvlText );
 310         }
 311
 312         String newSuffix=pCurNumFmt->GetSuffix();
 313         newSuffix+=aStringFollow;
 314         pCurNumFmt->SetSuffix(newSuffix);
 315         /* removed; waiting for swnum02 to be integrated!
 316         if (aStringFollow.GetChar(0)=='\t' && !pCurNumFmt->IsItemize())
 317         {
 318             pCurNumFmt->SetAbsLSpace(0);
 319             pCurNumFmt->SetFirstLineOffset(0);
 320         }
 321         */
 322     }
 323
 324     SkipToken( -1 );
 325 }
 326
 327 void SwRTFParser::ReadListTable()
 328 {
 329     int nToken;
 330     int nNumOpenBrakets = 1;            // die erste wurde schon vorher erkannt !!
 331     bNewNumList = TRUE;
 332
 333     BYTE nNumLvl = 0;
 334     SwNumRule* pCurRule = 0;
 335     SwListEntry aEntry;
 336
 337     while( nNumOpenBrakets && IsParserWorking() )
 338     {
 339         switch( ( nToken = GetNextToken() ))
 340         {
 341         case '}':               if( --nNumOpenBrakets && IsParserWorking() )
 342                         {
 343                             // Style konnte vollstaendig gelesen werden,
 344                             // also ist das noch ein stabiler Status
 345                             SaveState( RTF_LISTTABLE );
 346                             if( 1 == nNumOpenBrakets )
 347                             {
 348                                 if( aEntry.nListId )
 349                                     aListArr.Insert( aEntry, aListArr.Count() );
 350                                 aEntry.Clear();
 351                             }
 352                         }
 353                         break;
 354
 355         case '{':
 356             {
 357                 if( RTF_IGNOREFLAG != GetNextToken() )
 358                     nToken = SkipToken( -1 );
 359                 // Unknown und alle bekannten nicht ausgewerteten Gruppen
 360                 // sofort ueberspringen
 361                 else if( RTF_UNKNOWNCONTROL != ( nToken = GetNextToken() ))
 362 //                                              RTF_PANOSE != nToken && RTF_FALT != nToken &&
 363 //                                              RTF_FALT != nToken && RTF_FNAME != nToken &&
 364 //                                              RTF_FONTEMB != nToken && RTF_FONTFILE != nToken )
 365                     nToken = SkipToken( -2 );
 366                 else
 367                 {
 368                     // gleich herausfiltern
 369                     ReadUnknownData();
 370                     nToken = GetNextToken();
 371                     if( '}' != nToken )
 372                         eState = SVPAR_ERROR;
 373                     break;
 374                 }
 375                 ++nNumOpenBrakets;
 376             }
 377             break;
 378
 379         case RTF_LIST:
 380             {
 381                 if( pCurRule && pCurRule->IsContinusNum() )
 382                     lcl_ExpandNumFmts( *pCurRule );
 383
 384                 String sTmp( String::CreateFromAscii(
 385                     RTL_CONSTASCII_STRINGPARAM( RTF_NUMRULE_NAME " 1" )));
 386                 aEntry.nListDocPos = pDoc->MakeNumRule( sTmp );
 387                 pCurRule = pDoc->GetNumRuleTbl()[ aEntry.nListDocPos ];
 388                 // --> OD 2008-07-08 #i91400#
 389                 pCurRule->SetName( pDoc->GetUniqueNumRuleName( &sTmp, FALSE ),
 390                                    *pDoc );
 391                 // <--
 392                 pCurRule->SetAutoRule( FALSE );
 393                 nNumLvl = (BYTE)-1;
 394             }
 395             break;
 396
 397         case RTF_LISTID:                        aEntry.nListId = nTokenValue;           break;
 398         case RTF_LISTTEMPLATEID:        aEntry.nListTemplateId = nTokenValue; break;
 399
 400         case RTF_LISTRESTARTHDN:
 401             break;
 402         case RTF_LISTNAME:
 403             if (nNextCh=='}') break;  // #118989# empty listnames
 404             if( RTF_TEXTTOKEN == GetNextToken() )
 405             {
 406                 String sTmp( DelCharAtEnd( aToken, ';' ));
 407                 if( sTmp.Len() && !pDoc->FindNumRulePtr( sTmp ))
 408                 {
 409                     // --> OD 2008-07-08 #i91400#
 410                     pCurRule->SetName( sTmp, *pDoc );
 411                     // <--
 412                 }
 413             }
 414             SkipGroup();
 415             break;
 416
 417         case RTF_LISTSIMPLE:
 418             pCurRule->SetContinusNum( TRUE );
 419             break;
 420
 421         case RTF_LISTLEVEL:
 422             {
 423                 if( ++nNumLvl < MAXLEVEL )
 424                     pCurRule->Set( nNumLvl, pCurRule->Get( nNumLvl ));
 425                 ReadListLevel( *pCurRule, nNumLvl );
 426             }
 427             break;
 428         }
 429     }
 430
 431     if( pCurRule && pCurRule->IsContinusNum() )
 432         lcl_ExpandNumFmts( *pCurRule );
 433
 434     SkipToken( -1 );            // die schliesende Klammer wird "oben" ausgewertet
 435 }
 436
 437 BOOL lcl_IsEqual( SwNumRule* pOrigRule, SwNumRule* pRule )
 438 {
 439     BOOL bRet = 0;
 440     if( pOrigRule && pRule )
 441     {
 442         bRet =  pOrigRule->GetRuleType() == pRule->GetRuleType() &&
 443                 pOrigRule->IsContinusNum() == pRule->IsContinusNum() &&
 444                 pOrigRule->IsAbsSpaces() == pRule->IsAbsSpaces();
 445         if( bRet )
 446             for( BYTE n = 0; bRet && n < MAXLEVEL; ++n )
 447             {
 448                 const SwNumFmt* pOFmt = pOrigRule->GetNumFmt( n ),
 449                               * pFmt = pRule->GetNumFmt( n );
 450                 if( pFmt && pOFmt )
 451                 {
 452                     SwCharFmt* pOCFmt = pOFmt->GetCharFmt(),
 453                              * pCFmt = pFmt->GetCharFmt();
 454                     if( pOCFmt && pCFmt )
 455                     {
 456                         bRet = 0 != (pCFmt->GetAttrSet() == pOCFmt->GetAttrSet());
 457                     }
 458                     else
 459                         bRet = !pCFmt && !pOCFmt;
 460                     if( bRet )
 461                     {
 462                         ((SwNumFmt*)pOFmt)->SetCharFmt( 0 );
 463                         ((SwNumFmt*)pFmt)->SetCharFmt( 0 );
 464                         bRet = *pOFmt == *pFmt;
 465                         ((SwNumFmt*)pOFmt)->SetCharFmt( pOCFmt );
 466                         ((SwNumFmt*)pFmt)->SetCharFmt( pCFmt );
 467                     }
 468                 }
 469                 else
 470                     bRet = !pFmt && !pOFmt;
 471             }
 472     }
 473     return bRet;
 474 }
 475
 476 void SwRTFParser::ReadListOverrideTable()
 477 {
 478     int nToken;
 479     int nNumOpenBrakets = 1;            // die erste wurde schon vorher erkannt !!
 480     SwListEntry aEntry;
 481     SwNumRule* pRule = 0, *pOrigRule = 0;
 482     BYTE nNumLvl = 0;
 483     BOOL bOverrideFormat = FALSE, bOverrideStart = FALSE;
 484
 485     while( nNumOpenBrakets && IsParserWorking() )
 486     {
 487         switch( ( nToken = GetNextToken() ))
 488         {
 489         case '}':
 490             if( --nNumOpenBrakets && IsParserWorking() )
 491             {
 492                 // Style konnte vollstaendig gelesen werden,
 493                 // also ist das noch ein stabiler Status
 494                 SaveState( RTF_LISTOVERRIDETABLE );
 495
 496                 if( 1 == nNumOpenBrakets )
 497                 {
 498                     bOverrideFormat = FALSE, bOverrideStart = FALSE;
 499                     if( pRule )
 500                     {
 501                         if( lcl_IsEqual( pOrigRule, pRule ))
 502                         {
 503                             // no changes on the rule -> use the original rule
 504                             aEntry.nListDocPos = pDoc->FindNumRule(
 505                                                     pOrigRule->GetName() );
 506                             // delete the temp Rule
 507                             RemoveUnusedNumRule( pRule );
 508                         }
 509                         else if( pRule->IsContinusNum() )
 510                             lcl_ExpandNumFmts( *pRule );
 511                     }
 512
 513                     if( aEntry.nListId && aEntry.nListNo )
 514                     {
 515                         int nMatch=-1;
 516                         for( USHORT n = aListArr.Count(); n; )
 517                         {
 518                             if( aListArr[ --n ].nListId == aEntry.nListId)
 519                             {
 520                                 nMatch=n;
 521                                 break;
 522                             }
 523                         }
 524                         if(nMatch>=0)
 525                         {
 526                             USHORT nMatch2 = static_cast< USHORT >(nMatch);
 527                             if (!aListArr[nMatch2].nListNo )
 528                             {
 529                                 aListArr[nMatch2].nListNo = aEntry.nListNo;
 530                             }
 531                             else
 532                             {
 533                                 aEntry.nListDocPos=aListArr[nMatch2].nListDocPos;
 534                                 aEntry.nListTemplateId=aListArr[nMatch2].nListTemplateId;
 535                                 aListArr.Insert(aEntry, aListArr.Count());
 536                             }
 537                             if(pOrigRule)
 538                                 aListArr[nMatch2].nListDocPos = aEntry.nListDocPos;
 539                         }
 540                     }
 541                     aEntry.Clear();
 542                     pOrigRule = 0;
 543                     pRule = 0;
 544                 }
 545             }
 546             break;
 547
 548         case '{':
 549             {
 550                 if( RTF_IGNOREFLAG != GetNextToken() )
 551                     nToken = SkipToken( -1 );
 552                 // Unknown und alle bekannten nicht ausgewerteten Gruppen
 553                 // sofort ueberspringen
 554                 else if( RTF_UNKNOWNCONTROL != ( nToken = GetNextToken() ))
 555                     nToken = SkipToken( -2 );
 556                 else
 557                 {
 558                     // gleich herausfiltern
 559                     ReadUnknownData();
 560                     nToken = GetNextToken();
 561                     if( '}' != nToken )
 562                         eState = SVPAR_ERROR;
 563                     break;
 564                 }
 565                 ++nNumOpenBrakets;
 566             }
 567             break;
 568
 569         case RTF_LISTOVERRIDE:          aEntry.Clear();                                 break;
 570         case RTF_LISTID:                        aEntry.nListId = nTokenValue;   break;
 571         case RTF_LS:                            aEntry.nListNo = nTokenValue;   break;
 572         case RTF_LISTOVERRIDECOUNT:
 573             if( nTokenValue )
 574             {
 575                 pRule = 0;
 576                 // dann erzeugen wir mal schnell eine Kopie von der NumRule,
 577                 // denn diese wird jetzt mal kurz veraendert.
 578                 if( aEntry.nListId )
 579                     for( USHORT n = 0; n < aListArr.Count(); ++n )
 580                         if( aListArr[ n ].nListId == aEntry.nListId )
 581                         {
 582                             pRule = pDoc->GetNumRuleTbl()[
 583                                                 aListArr[ n ].nListDocPos ];
 584                             pOrigRule = pRule;
 585
 586                             String sTmp( String::CreateFromAscii(
 587                                 RTL_CONSTASCII_STRINGPARAM( RTF_NUMRULE_NAME " 1" )));
 588                             aEntry.nListDocPos = pDoc->MakeNumRule( sTmp, pRule );
 589                             pRule = pDoc->GetNumRuleTbl()[ aEntry.nListDocPos ];
 590                             // --> OD 2008-07-08 #i91400#
 591                             pRule->SetName( pDoc->GetUniqueNumRuleName( &sTmp, FALSE ),
 592                                             *pDoc );
 593                             // <--
 594                             pRule->SetAutoRule( FALSE );
 595                             nNumLvl = (BYTE)-1;
 596                             aListArr.Insert( aEntry, aListArr.Count() );
 597                             break;
 598                         }
 599
 600             }
 601             break;
 602
 603         case RTF_LISTLEVEL:
 604             if( pRule && bOverrideFormat )
 605             {
 606                 if( ++nNumLvl < MAXLEVEL )
 607                     pRule->Set( nNumLvl, pRule->Get( nNumLvl ));
 608                 ReadListLevel( *pRule, nNumLvl );
 609             }
 610             break;
 611
 612         case RTF_LEVELSTARTAT:
 613             if( pRule && bOverrideStart )
 614             {
 615             }
 616             break;
 617
 618         case RTF_LISTOVERRIDESTART:
 619             bOverrideStart = TRUE;
 620             break;
 621
 622         case RTF_LISTOVERRIDEFORMAT:
 623             bOverrideFormat = TRUE;
 624             break;
 625
 626         case RTF_LFOLEVEL:
 627             // was fehlt noch?
 628             break;
 629         }
 630     }
 631
 632     // search the outline numrule and set it into the doc
 633     if( GetStyleTbl().Count() )
 634     {
 635         if( !bStyleTabValid )
 636             MakeStyleTab();
 637
 638         const SfxPoolItem* pItem( 0 );
 639         const SwTxtFmtColl* pColl( 0 );
 640         USHORT nRulePos( USHRT_MAX );
 641         const SwNumRule *pNumRule = 0;
 642         SvxRTFStyleType* pStyle = GetStyleTbl().First();
 643         do {
 644             // --> OD 2007-12-17 #151213#
 645             // suppress deletion of outline list style.
 646             // refactoring of code: no assignments in if-condition
 647 //            if( MAXLEVEL > pStyle->nOutlineNo &&
 648 //                0 != ( pColl = aTxtCollTbl.Get( (USHORT)GetStyleTbl().
 649 //                                                        GetCurKey() )) &&
 650 //                SFX_ITEM_SET == pColl->GetItemState( RES_PARATR_NUMRULE,
 651 //                                                    FALSE, &pItem ) &&
 652 //                USHRT_MAX != (nRulePos = pDoc->FindNumRule(
 653 //                                ((SwNumRuleItem*)pItem)->GetValue() )) &&
 654 //                (pNumRule = pDoc->GetNumRuleTbl()[ nRulePos ])->IsAutoRule() )
 655             if ( MAXLEVEL > pStyle->nOutlineNo )
 656             {
 657                 pColl = aTxtCollTbl.Get( (USHORT)GetStyleTbl().GetCurKey() );
 658                 if ( pColl )
 659                 {
 660                     const SfxItemState eItemState =
 661                         pColl->GetItemState( RES_PARATR_NUMRULE, FALSE, &pItem );
 662                     if ( eItemState == SFX_ITEM_SET )
 663                     {
 664                         nRulePos = pDoc->FindNumRule( ((SwNumRuleItem*)pItem)->GetValue() );
 665                         if ( nRulePos != USHRT_MAX )
 666                         {
 667                             pNumRule = pDoc->GetNumRuleTbl()[ nRulePos ];
 668                             if ( pNumRule->IsAutoRule() &&
 669                                  pNumRule != pDoc->GetOutlineNumRule() )
 670                             {
 671                                 pDoc->SetOutlineNumRule( *pNumRule );
 672                                 pDoc->DelNumRule( pNumRule->GetName() );
 673                                 // now pNumRule pointer is invalid !!!
 674
 675                                 // now decrement all position in the listtable, which will
 676                                 // behind the doc-rule position
 677                                 for( USHORT n = aListArr.Count(); n; )
 678                                 {
 679                                     SwListEntry& rEntry = aListArr[ --n ];
 680                                     if( rEntry.nListDocPos == nRulePos )
 681                                         aListArr.Remove( n );
 682                                     else if( rEntry.nListDocPos > nRulePos )
 683                                         --rEntry.nListDocPos;
 684                                 }
 685                                 break;
 686                             }
 687                         }
 688                     }
 689                 }
 690             }
 691             // <--
 692
 693             pStyle->aAttrSet.ClearItem( FN_PARAM_NUM_LEVEL );
 694
 695         } while( 0 != (pStyle = GetStyleTbl().Next()) );
 696     }
 697
 698     SkipToken( -1 );            // die schliesende Klammer wird "oben" ausgewertet
 699 }
 700
 701 SwNumRule* SwRTFParser::GetNumRuleOfListNo( long nListNo, BOOL bRemoveFromList )
 702 {
 703     SwNumRule* pRet = 0;
 704     SwListEntry* pEntry;
 705     for( USHORT n = aListArr.Count(); n; )
 706         if( ( pEntry = &aListArr[ --n ])->nListNo == nListNo )
 707         {
 708             if( bRemoveFromList )
 709                 aListArr.Remove( n );
 710             else
 711             {
 712                 pEntry->bRuleUsed = TRUE;
 713                 pRet = pDoc->GetNumRuleTbl()[ pEntry->nListDocPos ];
 714             }
 715             break;
 716         }
 717     return pRet;
 718 }
 719
 720 void SwRTFParser::RemoveUnusedNumRule( SwNumRule* pRule )
 721 {
 722     if( pRule )
 723     {
 724         for ( BYTE nLvl = 0; nLvl < MAXLEVEL; ++nLvl )
 725         {
 726             SwNumFmt& rNFmt = (SwNumFmt&)pRule->Get( nLvl );
 727             SwCharFmt* pCFmt = rNFmt.GetCharFmt();
 728             if( pCFmt )
 729             {
 730                 pCFmt->Remove( &rNFmt );
 731                 if( !pCFmt->GetDepends() )
 732                     pDoc->DelCharFmt( pCFmt );
 733             }
 734         }
 735         pDoc->DelNumRule( pRule->GetName() );
 736     }
 737 #ifndef PRODUCT
 738     else
 739     {
 740         ASSERT( pRule, "NumRulePointer 0 kann nicht geloescht werden" );
 741     }
 742 #endif
 743 }
 744
 745 void SwRTFParser::RemoveUnusedNumRules()
 746 {
 747     SwListEntry* pEntry;
 748     SvPtrarr aDelArr;
 749     USHORT n;
 750     for( n = aListArr.Count(); n; )
 751     {
 752         if( !( pEntry = &aListArr[ --n ])->bRuleUsed )
 753         {
 754             // really *NOT* used by anyone else?
 755             BOOL unused=TRUE;
 756             for(USHORT j = 0;  j < aListArr.Count();  ++j)
 757             {
 758                 if (aListArr[n].nListNo==aListArr[j].nListNo)
 759                     unused&=!aListArr[j].bRuleUsed;
 760             }
 761             if (unused)
 762             {
 763                 void * p = pDoc->GetNumRuleTbl()[pEntry->nListDocPos];
 764                 // dont delete named char formats
 765                 if( USHRT_MAX == aDelArr.GetPos( p ) &&
 766                     ((SwNumRule*)p)->GetName().EqualsAscii( RTF_NUMRULE_NAME, 0,
 767                                     sizeof( RTF_NUMRULE_NAME )) )
 768                     aDelArr.Insert( p, aDelArr.Count() );
 769             }
 770         }
 771     }
 772
 773     for( n = aDelArr.Count(); n; )
 774     {
 775         SwNumRule* pDel = (SwNumRule*)aDelArr[ --n ];
 776         RemoveUnusedNumRule( pDel );
 777     }
 778 }
 779
 780 const Font* SwRTFParser::FindFontOfItem( const SvxFontItem& rItem ) const
 781 {
 782     SvxRTFFontTbl& rFntTbl = ((SwRTFParser*)this)->GetFontTbl();
 783     const Font* pFnt = rFntTbl.First();
 784     while( pFnt )
 785     {
 786         if( pFnt->GetFamily() == rItem.GetFamily() &&
 787             pFnt->GetName() == rItem.GetFamilyName() &&
 788             pFnt->GetStyleName() == rItem.GetStyleName() &&
 789             pFnt->GetPitch() == rItem.GetPitch() &&
 790             pFnt->GetCharSet() == rItem.GetCharSet() )
 791             return pFnt;
 792
 793         pFnt = rFntTbl.Next();
 794     }
 795     return 0;
 796 }
 797
 798
 799 SwNumRule *SwRTFParser::ReadNumSecLevel( int nToken )
 800 {
 801     // lese die \pnseclvl - Gruppe
 802     // nTokenValue gibt schon den richtigen Level vor 1 - 9!
 803     BYTE nLevel = 0;
 804     long nListNo = 0;
 805     BOOL bContinus = TRUE;
 806
 807     if( RTF_PNSECLVL == nToken )
 808     {
 809         // suche die Rule - steht unter Nummer 3
 810         nListNo = 3;
 811         bContinus = FALSE;
 812         nLevel = MAXLEVEL <= nTokenValue ? MAXLEVEL - 1
 813                                          : BYTE( nTokenValue - 1 );
 814     }
 815     else
 816     {
 817         switch( nToken = GetNextToken() )
 818         {
 819         case RTF_PNLVL:                 nListNo = 3;
 820                                 bContinus = FALSE;
 821                                 nLevel = MAXLEVEL <= nTokenValue
 822                                                     ? MAXLEVEL - 1
 823                                                     : BYTE( nTokenValue-1 );
 824                                 break;
 825
 826         case RTF_PNLVLBODY:
 827             nListNo = 2;
 828             break;
 829         case RTF_PNLVLBLT:
 830             nListNo = 1;
 831             break;
 832         case RTF_PNLVLCONT:
 833             SkipGroup();
 834             return 0;
 835         default:
 836             SkipGroup();
 837             return 0;
 838         }
 839     }
 840
 841     // suche die Rule - steht unter Nummer 3
 842     USHORT nNewFlag = static_cast< USHORT >(1 << nListNo);
 843     SwNumRule* pCurRule = GetNumRuleOfListNo( nListNo,
 844                                         0 != ( nNewNumSectDef & nNewFlag ) );
 845     if( !pCurRule )
 846     {
 847         // dann muessen wir die mal anlegen
 848         nNewNumSectDef &= ~nNewFlag;
 849         String sTmp( String::CreateFromAscii(
 850                         RTL_CONSTASCII_STRINGPARAM( RTF_NUMRULE_NAME " 1" )));
 851         SwListEntry aEntry( nListNo, 0, pDoc->MakeNumRule( sTmp ));
 852         aEntry.nListNo = nListNo;
 853         aListArr.Insert( aEntry, aListArr.Count() );
 854         pCurRule = pDoc->GetNumRuleTbl()[ aEntry.nListDocPos ];
 855         // --> OD 2008-07-08 #i91400#
 856         pCurRule->SetName( pDoc->GetUniqueNumRuleName( &sTmp, FALSE ), *pDoc );
 857         // <--
 858         pCurRule->SetAutoRule( FALSE );
 859         pCurRule->SetContinusNum( bContinus );
 860     }
 861
 862     if( !pCurRule->GetNumFmt( nLevel ))
 863         pCurRule->Set( nLevel, pCurRule->Get( nLevel ));
 864     SwNumFmt* pCurNumFmt = (SwNumFmt*)pCurRule->GetNumFmt( nLevel );
 865     if( RTF_PNLVLBLT == nToken )
 866         pCurNumFmt->SetNumberingType(SVX_NUM_CHAR_SPECIAL);
 867     pCurNumFmt->SetSuffix( aEmptyStr );
 868     pCurNumFmt->SetPrefix( aEmptyStr );
 869     pCurNumFmt->SetNumberingType(SVX_NUM_NUMBER_NONE);
 870
 871     if( bStyleTabValid && RTF_PNSECLVL != nToken )
 872     {
 873         // dann den akt. Lvl und Rule am Absatz setzen.
 874         // Dieses muss aber in den vorherigen "Kontext", sprich in den vor
 875         // der Klammer offenen Attrset. Darum das SetNewGroup davor und dahinter
 876         SetNewGroup( FALSE );
 877         GetAttrSet().Put( SfxUInt16Item( FN_PARAM_NUM_LEVEL, nLevel ));
 878         GetAttrSet().Put( SwNumRuleItem( pCurRule->GetName() ));
 879         SetNewGroup( TRUE );
 880     }
 881
 882     FontUnderline eUnderline;
 883     int nNumOpenBrakets = 1;            // die erste wurde schon vorher erkannt !!
 884     while( nNumOpenBrakets && IsParserWorking() )
 885     {
 886         switch( ( nToken = GetNextToken() ))
 887         {
 888         case '}':
 889             if( --nNumOpenBrakets && IsParserWorking() )
 890             {
 891                 // Style konnte vollstaendig gelesen werden,
 892                 // also ist das noch ein stabiler Status
 893                 SaveState( RTF_PNSECLVL );
 894             }
 895             break;
 896
 897         case '{':
 898             {
 899                 if( RTF_IGNOREFLAG != GetNextToken() )
 900                     nToken = SkipToken( -1 );
 901                 // Unknown und alle bekannten nicht ausgewerteten Gruppen
 902                 // sofort ueberspringen
 903                 else if( RTF_UNKNOWNCONTROL != ( nToken = GetNextToken() ))
 904                     nToken = SkipToken( -2 );
 905                 else
 906                 {
 907                     // gleich herausfiltern
 908                     ReadUnknownData();
 909                     nToken = GetNextToken();
 910                     if( '}' != nToken )
 911                         eState = SVPAR_ERROR;
 912                     break;
 913                 }
 914                 ++nNumOpenBrakets;
 915             }
 916             break;
 917
 918         case RTF_PNCARD:
 919         case RTF_PNORD:
 920         case RTF_PNORDT:
 921         case RTF_PNDEC:         pCurNumFmt->SetNumberingType(SVX_NUM_ARABIC);                           break;
 922         case RTF_PNUCLTR:       pCurNumFmt->SetNumberingType(SVX_NUM_CHARS_UPPER_LETTER_N);     break;
 923         case RTF_PNUCRM:    pCurNumFmt->SetNumberingType(SVX_NUM_ROMAN_UPPER);                  break;
 924         case RTF_PNLCLTR:   pCurNumFmt->SetNumberingType(SVX_NUM_CHARS_LOWER_LETTER_N); break;
 925         case RTF_PNLCRM:    pCurNumFmt->SetNumberingType(SVX_NUM_ROMAN_LOWER);                  break;
 926
 927         case RTF_PNF:
 928             {
 929                 const Font& rSVFont = GetFont( USHORT(nTokenValue) );
 930                 GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put(
 931                             SvxFontItem( rSVFont.GetFamily(),
 932                                 rSVFont.GetName(), rSVFont.GetStyleName(),
 933                                 rSVFont.GetPitch(), rSVFont.GetCharSet(),
 934                                             RES_CHRATR_FONT ));
 935                 if( SVX_NUM_CHAR_SPECIAL == pCurNumFmt->GetNumberingType() )
 936                     pCurNumFmt->SetBulletFont( &rSVFont );
 937             }
 938             break;
 939         case RTF_PNFS:
 940             {
 941                 if( -1 == nTokenValue )
 942                     nTokenValue = 240;
 943                 else
 944                     nTokenValue *= 10;
 945                 GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put(
 946                             SvxFontHeightItem( (const USHORT)nTokenValue, 100, RES_CHRATR_FONTSIZE ));
 947             }
 948             break;
 949
 950         case RTF_PNB:
 951             {
 952                 GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put( SvxWeightItem(
 953                                 nTokenValue ? WEIGHT_BOLD : WEIGHT_NORMAL, RES_CHRATR_WEIGHT ));
 954             }
 955             break;
 956
 957         case RTF_PNI:
 958             {
 959                 GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put( SvxPostureItem(
 960                             nTokenValue ? ITALIC_NORMAL : ITALIC_NONE, RES_CHRATR_POSTURE ));
 961             }
 962             break;
 963
 964         case RTF_PNCAPS:
 965         case RTF_PNSCAPS:
 966             {
 967                 GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put( SvxCaseMapItem(
 968                                 nTokenValue ? SVX_CASEMAP_KAPITAELCHEN
 969                                             : SVX_CASEMAP_NOT_MAPPED, RES_CHRATR_CASEMAP ));
 970             }
 971             break;
 972         case RTF_PNSTRIKE:
 973             {
 974                 GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put( SvxCrossedOutItem(
 975                         nTokenValue ? STRIKEOUT_SINGLE : STRIKEOUT_NONE, RES_CHRATR_CROSSEDOUT ));
 976             }
 977             break;
 978
 979         case RTF_PNCF:
 980             {
 981                 GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put( SvxColorItem(
 982                             GetColor( USHORT(nTokenValue) ), RES_CHRATR_COLOR ));
 983             }
 984             break;
 985
 986
 987         case RTF_PNUL:
 988             eUnderline = nTokenValue ? UNDERLINE_SINGLE : UNDERLINE_NONE;
 989             goto NUMATTR_SETUNDERLINE;
 990         case RTF_PNULD:
 991             eUnderline = UNDERLINE_DOTTED;
 992             goto NUMATTR_SETUNDERLINE;
 993         case RTF_PNULDB:
 994             eUnderline = UNDERLINE_DOUBLE;
 995             goto NUMATTR_SETUNDERLINE;
 996         case RTF_PNULNONE:
 997             eUnderline = UNDERLINE_NONE;
 998             goto NUMATTR_SETUNDERLINE;
 999         case RTF_PNULW:
1000             {
1001                 GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put(
1002                                     SvxWordLineModeItem( TRUE, RES_CHRATR_WORDLINEMODE ));
1003             }
1004             eUnderline = UNDERLINE_SINGLE;
1005             goto NUMATTR_SETUNDERLINE;
1006
1007 NUMATTR_SETUNDERLINE:
1008             {
1009                 GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put(
1010                         SvxUnderlineItem( eUnderline, RES_CHRATR_UNDERLINE ));
1011             }
1012             break;
1013
1014         case RTF_PNINDENT:
1015             if( 0 > short( nTokenValue ) )
1016                 nTokenValue = - (short)nTokenValue;
1017             pCurNumFmt->SetFirstLineOffset( - short( nTokenValue ));
1018             pCurNumFmt->SetAbsLSpace( (nLevel + 1 ) * USHORT( nTokenValue ));
1019             break;
1020         case RTF_PNSP:
1021             pCurNumFmt->SetCharTextDistance( USHORT( nTokenValue ));
1022             break;
1023
1024         case RTF_PNPREV:
1025             if( nLevel )
1026             {
1027                 BYTE nPrev = 2, nLast = nLevel;
1028                 while( nLast && 1 < pCurRule->Get( --nLast ).GetIncludeUpperLevels() )
1029                     ++nPrev;
1030                 pCurNumFmt->SetIncludeUpperLevels( nPrev );
1031             }
1032             break;
1033
1034         case RTF_PNQC:  pCurNumFmt->SetNumAdjust( SVX_ADJUST_CENTER );  break;
1035         case RTF_PNQL:  pCurNumFmt->SetNumAdjust( SVX_ADJUST_LEFT );            break;
1036         case RTF_PNQR:  pCurNumFmt->SetNumAdjust( SVX_ADJUST_RIGHT );           break;
1037
1038         case RTF_PNSTART:
1039             pCurNumFmt->SetStart( USHORT( nTokenValue ));
1040             break;
1041
1042         case RTF_PNNUMONCE:
1043         case RTF_PNACROSS:
1044         case RTF_PNHANG:
1045         case RTF_PNRESTART:             break;
1046
1047         case RTF_PNTXTA:
1048             {
1049                 String sTmp;
1050                 GetTextToEndGroup( sTmp );
1051                 if( SVX_NUM_CHAR_SPECIAL == pCurNumFmt->GetNumberingType() )
1052                 {
1053                     pCurNumFmt->SetBulletChar( sTmp.GetChar( 0 ) );
1054                     if( pCurNumFmt->GetCharFmt() )
1055                         pCurNumFmt->SetBulletFont( FindFontOfItem(
1056                                     pCurNumFmt->GetCharFmt()->GetFont() ) );
1057                     sTmp.Erase();
1058                 }
1059                 pCurNumFmt->SetSuffix( sTmp );
1060             }
1061             break;
1062
1063         case RTF_PNTXTB:
1064             {
1065                 String sTmp;
1066                 pCurNumFmt->SetPrefix( GetTextToEndGroup( sTmp ) );
1067             }
1068             break;
1069         }
1070     }
1071
1072     // falls vollstaendige Numerierung an ist und das Zeichen davor ein
1073     // Punkt ist, dann will RTF den Punkt als Trenner zwischen den Ebenen
1074     // haben - das haben wir aber schon als default
1075     if( 1 < pCurNumFmt->GetIncludeUpperLevels() &&
1076         1 == pCurNumFmt->GetPrefix().Len() &&
1077         '.' == pCurNumFmt->GetPrefix().GetChar( 0 ) &&
1078         SVX_NUM_CHAR_SPECIAL != pCurNumFmt->GetNumberingType() )
1079         pCurNumFmt->SetPrefix( aEmptyStr );
1080
1081     // falls das ein nicht numerierter Absatz mit ein Prefix-Text mit
1082     // einem Zeichen ist, dann setze den als Bulletzeichen
1083     if( pCurNumFmt->GetCharFmt() && SVX_NUM_NUMBER_NONE == pCurNumFmt->GetNumberingType() &&
1084         3 == nListNo && 1 == pCurNumFmt->GetPrefix().Len() )
1085     {
1086         SwCharFmt* pChFmt = pCurNumFmt->GetCharFmt();
1087         pCurNumFmt->SetNumberingType(SVX_NUM_CHAR_SPECIAL);
1088         pCurNumFmt->SetBulletFont( FindFontOfItem( pChFmt->GetFont() ) );
1089
1090         pCurNumFmt->SetBulletChar( pCurNumFmt->GetPrefix().GetChar( 0 ) );
1091         pCurNumFmt->SetPrefix( aEmptyStr );
1092
1093         // den Font oder sogar das gesamte CharFormat loeschen?
1094         if( SFX_ITEM_SET == pChFmt->GetItemState( RES_CHRATR_FONT, FALSE ))
1095         {
1096             if( 1 == pChFmt->GetAttrSet().Count() )
1097             {
1098                 pCurNumFmt->SetCharFmt( 0 );
1099                 pDoc->DelCharFmt( pChFmt );
1100             }
1101             else
1102                 pChFmt->ResetFmtAttr( RES_CHRATR_FONT );
1103         }
1104     }
1105
1106     SkipToken( -1 );            // die schliesende Klammer wird "oben" ausgewertet
1107     return pCurRule;
1108 }
1109
1110
1111 /* \f */
1112
1113 // dann noch die Ausgabe-Funktionen (nur fuer WinWord 97)
1114
1115 BOOL lcl_IsExportNumRule( const SwNumRule& rRule, BYTE* pEnd = 0 )
1116 {
1117     BYTE nEnd = MAXLEVEL;
1118     while( nEnd-- && !rRule.GetNumFmt( nEnd ))
1119         ;
1120     ++nEnd;
1121
1122     const SwNumFmt* pNFmt;
1123     BYTE nLvl;
1124
1125     for( nLvl = 0; nLvl < nEnd; ++nLvl )
1126         if( SVX_NUM_NUMBER_NONE != ( pNFmt = &rRule.Get( nLvl ))
1127             ->GetNumberingType() || pNFmt->GetPrefix().Len() ||
1128             (pNFmt->GetSuffix().Len() && pNFmt->GetSuffix() != aDotStr ))
1129             break;
1130
1131     if( pEnd )
1132         *pEnd = nEnd;
1133     return nLvl != nEnd;
1134 }
1135
1136 void SwRTFWriter::OutRTFListTab()
1137 {
1138     ByteString sOverrideList;
1139     USHORT nId = 1, nTmplId = 1, n;
1140
1141     // prepare the NodeNum to generate the NumString
1142     SwNumberTree::tNumberVector aNumVector;
1143     for( n = 0; n < MAXLEVEL; ++n )
1144         aNumVector.push_back(n);
1145     BYTE aNumLvlPos[ MAXLEVEL ];
1146
1147     if( !pNumRuleTbl )
1148         BuildNumRuleTbl();
1149
1150     for( n = 0; n < pNumRuleTbl->Count(); ++n )
1151     {
1152         const SwNumRule* pRule = (*pNumRuleTbl)[ n ];
1153
1154         // mit der ersten Rule wird auch die ListTable geschrieben
1155         if( !sOverrideList.Len() )
1156             OutComment( *this, OOO_STRING_SVTOOLS_RTF_LISTTABLE );
1157
1158         Strm() << '{' << OOO_STRING_SVTOOLS_RTF_LIST << OOO_STRING_SVTOOLS_RTF_LISTTEMPLATEID;
1159         OutULong( nTmplId );
1160         ByteString sTmp;
1161
1162         if( pRule->IsContinusNum() )
1163             Strm() << OOO_STRING_SVTOOLS_RTF_LISTSIMPLE;
1164
1165         BYTE nLvl, nEnd;
1166         lcl_IsExportNumRule( *pRule, &nEnd );
1167
1168         for( nLvl = 0; nLvl < nEnd; ++nLvl )
1169         {
1170             const SwNumFmt& rFmt = pRule->Get( nLvl );
1171             Strm() << sNewLine;
1172             if( nLvl > 8 )                      // RTF-kennt nur 9 Ebenen
1173                 OutComment( *this, OOO_STRING_SVTOOLS_RTF_SOUTLVL );
1174
1175             Strm() << '{' << OOO_STRING_SVTOOLS_RTF_LISTLEVEL << OOO_STRING_SVTOOLS_RTF_LEVELNFC;
1176
1177             USHORT nVal = 0;
1178             switch( rFmt.GetNumberingType() )
1179             {
1180             case SVX_NUM_ROMAN_UPPER:                   nVal = 1;       break;
1181             case SVX_NUM_ROMAN_LOWER:                   nVal = 2;       break;
1182             case SVX_NUM_CHARS_UPPER_LETTER:
1183             case SVX_NUM_CHARS_UPPER_LETTER_N:  nVal = 3;       break;
1184             case SVX_NUM_CHARS_LOWER_LETTER:
1185             case SVX_NUM_CHARS_LOWER_LETTER_N:  nVal = 4;       break;
1186
1187             case SVX_NUM_BITMAP:
1188             case SVX_NUM_CHAR_SPECIAL:                  nVal = 23;      break;
1189             }
1190             OutLong( nVal ) << OOO_STRING_SVTOOLS_RTF_LEVELJC;
1191
1192             switch( rFmt.GetNumAdjust() )
1193             {
1194             case SVX_ADJUST_CENTER:             nVal = 1;       break;
1195             case SVX_ADJUST_RIGHT:              nVal = 2;       break;
1196             default:                                    nVal = 0;       break;
1197             }
1198             OutLong( nVal ) << OOO_STRING_SVTOOLS_RTF_LEVELSTARTAT;
1199             OutLong( rFmt.GetStart() )
1200                 << OOO_STRING_SVTOOLS_RTF_LEVELFOLLOW << "0{" << OOO_STRING_SVTOOLS_RTF_LEVELTEXT << ' ';
1201
1202             BOOL bWriteBulletFont = FALSE;
1203             memset( aNumLvlPos, 0, MAXLEVEL );
1204             if( SVX_NUM_CHAR_SPECIAL == rFmt.GetNumberingType() ||
1205                 SVX_NUM_BITMAP == rFmt.GetNumberingType() )
1206             {
1207                 Strm() << "\\'01";
1208                 ByteString sNo( ByteString::CreateFromInt32( rFmt.GetBulletChar()));
1209                 Strm() << "\\u" << sNo.GetBuffer() << " ?";
1210                 bWriteBulletFont = TRUE;
1211             }
1212             else if( SVX_NUM_NUMBER_NONE == rFmt.GetNumberingType() )
1213             {
1214                 String sOut( rFmt.GetPrefix() ); sOut += rFmt.GetSuffix();
1215                 if( sOut.Len() )
1216                 {
1217                     Strm() << "\\'";
1218                     OutHex( sOut.Len() );
1219                     RTFOutFuncs::Out_String( Strm(), sOut,
1220                                             eDefaultEncoding, bWriteHelpFmt );
1221                 }
1222             }
1223             else
1224             {
1225                 memset( aNumLvlPos, 0, MAXLEVEL );
1226                 BYTE* pLvlPos = aNumLvlPos;
1227                 // --> OD 2005-11-18 #128056#
1228                 // correction of refactoring done by cws swnumtree:
1229                 // - the numbering string has to be restrict to the level
1230                 //   currently working on.
1231                 String sNumStr( pRule->MakeNumString( aNumVector, FALSE, TRUE, nLvl ));
1232                 // <--
1233
1234                 // now search the nums in the string
1235                 for( BYTE i = 0; i <= nLvl; ++i )
1236                 {
1237                     String sSrch( String::CreateFromInt32( i ));
1238                     xub_StrLen nFnd = sNumStr.Search( sSrch );
1239                     if( STRING_NOTFOUND != nFnd )
1240                     {
1241                         *pLvlPos = (BYTE)(nFnd + rFmt.GetPrefix().Len() + 1 );
1242                         ++pLvlPos;
1243                         sNumStr.SetChar( nFnd, (sal_Unicode)i );
1244                     }
1245                 }
1246
1247                 Strm() << "\\'";
1248                 OutHex( sNumStr.Len() + rFmt.GetPrefix().Len() +
1249                                         rFmt.GetSuffix().Len() );
1250
1251                 if( rFmt.GetPrefix().Len() )
1252                     RTFOutFuncs::Out_String( Strm(), rFmt.GetPrefix(),
1253                                             eDefaultEncoding, bWriteHelpFmt );
1254
1255
1256                 for( xub_StrLen x = 0; x < sNumStr.Len(); ++x )
1257                     if( sNumStr.GetChar( x ) < 0x20 ||
1258                         sNumStr.GetChar( x ) > 0xFF )
1259                     {
1260                         Strm() << "\\'"; OutHex( sNumStr.GetChar( x ) );
1261                     }
1262                     else
1263                         Strm() << (sal_Char)sNumStr.GetChar( x );
1264
1265                 if( rFmt.GetSuffix().Len() )
1266                     RTFOutFuncs::Out_String( Strm(), rFmt.GetSuffix(),
1267                                             eDefaultEncoding, bWriteHelpFmt );
1268             }
1269
1270             // write the levelnumbers
1271             Strm() << ";}{" << OOO_STRING_SVTOOLS_RTF_LEVELNUMBERS;
1272             for( BYTE i = 0; i <= nLvl && aNumLvlPos[ i ]; ++i )
1273             {
1274                 Strm() << "\\'"; OutHex( aNumLvlPos[ i ] );
1275             }
1276             Strm() << ";}";
1277
1278             if( rFmt.GetCharFmt() )
1279                 Out_SfxItemSet( aRTFAttrFnTab, *this,
1280                                 rFmt.GetCharFmt()->GetAttrSet(), TRUE );
1281
1282             if( bWriteBulletFont )
1283             {
1284                 Strm() << OOO_STRING_SVTOOLS_RTF_F;
1285                 const Font* pFont = rFmt.GetBulletFont();
1286                 if( !pFont )
1287                     // --> OD 2006-06-27 #b6440955#
1288                     pFont = &numfunc::GetDefBulletFont();
1289                     // <--
1290                 OutULong( GetId( *pFont ));
1291             }
1292
1293             Strm() << OOO_STRING_SVTOOLS_RTF_FI;
1294             OutLong( rFmt.GetFirstLineOffset() ) << OOO_STRING_SVTOOLS_RTF_LI;
1295             OutLong( rFmt.GetAbsLSpace() );
1296
1297             Strm() << '}';
1298
1299             if( nLvl > 8 )              // RTF-kennt nur 9 Ebenen
1300                 Strm() << '}';
1301         }
1302
1303         if( !pRule->IsAutoRule() )
1304         {
1305             Strm() << '{' << OOO_STRING_SVTOOLS_RTF_LISTNAME << ' ';
1306             RTFOutFuncs::Out_String( Strm(), pRule->GetName(), eDefaultEncoding,
1307                                     bWriteHelpFmt ) << ";}" ;
1308         }
1309         Strm() << OOO_STRING_SVTOOLS_RTF_LISTID;
1310         OutULong( nId ) << '}' << sNewLine;
1311
1312         sTmp = '{';
1313         ((((((( sTmp += OOO_STRING_SVTOOLS_RTF_LISTOVERRIDE ) +=
1314                     OOO_STRING_SVTOOLS_RTF_LISTID ) += ByteString::CreateFromInt32( nId )) +=
1315                     OOO_STRING_SVTOOLS_RTF_LISTOVERRIDECOUNT ) += '0' ) +=
1316                     OOO_STRING_SVTOOLS_RTF_LS ) += ByteString::CreateFromInt32( n )) += '}';
1317         sOverrideList += sTmp;
1318
1319         ++nId, ++nTmplId;
1320     }
1321
1322     if( sOverrideList.Len() )
1323         Strm() << "}{" << OOO_STRING_SVTOOLS_RTF_LISTOVERRIDETABLE
1324                << sOverrideList.GetBuffer() << '}' << sNewLine;
1325 }
1326
1327 USHORT SwRTFWriter::GetId( const SwNumRuleItem& rItem ) const
1328 {
1329     USHORT n, nId = USHRT_MAX;
1330     if( !pNumRuleTbl )
1331     {
1332         SwRTFWriter* pThis = (SwRTFWriter*)this;
1333         pThis->BuildNumRuleTbl();
1334     }
1335     const String& rNm = rItem.GetValue();
1336     for( n = pNumRuleTbl->Count(); n; )
1337         if( (*pNumRuleTbl)[ --n ]->GetName() == rNm )
1338         {
1339             nId = n;
1340             break;
1341         }
1342
1343     return nId;
1344 }
1345
1346 USHORT SwRTFWriter::GetNumRuleId( const SwNumRule& rRule )
1347 {
1348     if( !pNumRuleTbl )
1349         BuildNumRuleTbl();
1350     SwNumRulePtr pR = (SwNumRulePtr)&rRule;
1351     return pNumRuleTbl->GetPos( pR );
1352 }
1353
1354 void SwRTFWriter::BuildNumRuleTbl()
1355 {
1356     const SwNumRuleTbl& rListTbl = pDoc->GetNumRuleTbl();
1357     if( !pNumRuleTbl )
1358         pNumRuleTbl = new SwNumRuleTbl( (BYTE)rListTbl.Count() );
1359     for( USHORT n = rListTbl.Count()+1; n; )
1360     {
1361         SwNumRule* pRule;
1362         --n;
1363         if( n == rListTbl.Count() )
1364             pRule = (SwNumRule*)pDoc->GetOutlineNumRule();
1365         else
1366         {
1367             pRule = rListTbl[ n ];
1368             if( !pDoc->IsUsed( *pRule ))
1369                 continue;
1370         }
1371
1372         if( lcl_IsExportNumRule( *pRule ))
1373             pNumRuleTbl->Insert( pRule, pNumRuleTbl->Count() );
1374     }
1375 }
1376
1377 BOOL SwRTFWriter::OutListNum( const SwTxtNode& rNd )
1378 {
1379     BOOL bRet = FALSE;
1380     const SwNumRule* pRule = rNd.GetNumRule();
1381
1382     // --> OD 2008-03-18 #refactorlists#
1383 //    if( pRule && MAXLEVEL > rNd.GetActualListLevel() )
1384     if( pRule && rNd.IsInList() )
1385     // <--
1386     {
1387         // --> OD 2008-03-18 #refactorlists#
1388         ASSERT( rNd.GetActualListLevel() >= 0 && rNd.GetActualListLevel() < MAXLEVEL,
1389                 "<SwRTFWriter::OutListNum(..)> - text node does not have valid list level. Serious defect -> please inform OD" );
1390         // <--
1391
1392         bOutFmtAttr = FALSE;
1393         bOutListNumTxt = TRUE;
1394         bRet = TRUE;
1395
1396         const bool bExportNumRule = USHRT_MAX != GetNumRuleId( *pRule );
1397         const BYTE nLvl = static_cast< BYTE >(rNd.GetActualListLevel());
1398         const SwNumFmt* pFmt = pRule->GetNumFmt( nLvl );
1399         if( !pFmt )
1400             pFmt = &pRule->Get( nLvl );
1401
1402         const SfxItemSet& rNdSet = rNd.GetSwAttrSet();
1403
1404         SfxItemSet aSet( *rNdSet.GetPool(), rNdSet.GetRanges() );
1405         aSet.SetParent( &rNdSet );
1406         SvxLRSpaceItem aLR( (SvxLRSpaceItem&)rNdSet.Get( RES_LR_SPACE ) );
1407         aLR.SetTxtLeft( aLR.GetTxtLeft() + pFmt->GetAbsLSpace() );
1408
1409         aLR.SetTxtFirstLineOfst( pFmt->GetFirstLineOffset() );
1410         if ( bExportNumRule )
1411             Strm() << '{' << OOO_STRING_SVTOOLS_RTF_LISTTEXT << OOO_STRING_SVTOOLS_RTF_PARD << OOO_STRING_SVTOOLS_RTF_PLAIN << ' ';
1412
1413         aSet.Put( aLR );
1414         Out_SfxItemSet( aRTFAttrFnTab, *this, aSet, TRUE );
1415
1416         if( pFmt->GetCharFmt() )
1417             Out_SfxItemSet( aRTFAttrFnTab, *this,
1418                         pFmt->GetCharFmt()->GetAttrSet(), TRUE );
1419
1420         {
1421             String sTxt;
1422             if( SVX_NUM_CHAR_SPECIAL == pFmt->GetNumberingType() || SVX_NUM_BITMAP == pFmt->GetNumberingType() )
1423                 sTxt = pFmt->GetBulletChar();
1424             else
1425                 sTxt = rNd.GetNumString();
1426
1427             if( bOutFmtAttr )
1428             {
1429                 Strm() << ' ';
1430                 bOutFmtAttr = FALSE;
1431             }
1432
1433             if (sTxt.Len())
1434             {
1435                 RTFOutFuncs::Out_String(Strm(), sTxt, eDefaultEncoding,
1436                     bWriteHelpFmt);
1437             }
1438
1439             if( bExportNumRule )
1440             {
1441                 if( OUTLINE_RULE != pRule->GetRuleType() )
1442                 {
1443                     Strm() << OOO_STRING_SVTOOLS_RTF_TAB << '}' << OOO_STRING_SVTOOLS_RTF_ILVL;
1444                     if( nLvl > 8 )                      // RTF-kennt nur 9 Ebenen
1445                     {
1446                         OutULong( 8 );
1447                         OutComment( *this, OOO_STRING_SVTOOLS_RTF_SOUTLVL );
1448                         OutULong( nLvl ) << '}';
1449                     }
1450                     else
1451                         OutULong( nLvl );
1452                     Strm()  << ' ';
1453                 }
1454                 else
1455                     Strm() << OOO_STRING_SVTOOLS_RTF_TAB << '}';
1456             }
1457             else if( sTxt.Len() )
1458                 Strm() << OOO_STRING_SVTOOLS_RTF_TAB;
1459         }
1460         bOutListNumTxt = FALSE;
1461     }
1462     return bRet;
1463 }