svx/source/svrtf/svxrtf.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: svxrtf.cxx,v $
  10  * $Revision: 1.34.212.1 $
  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_svx.hxx"
  33
  34 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil -*- */
  35
  36
  37 #include <ctype.h>
  38 #include <tools/datetime.hxx>
  39 #include <rtl/tencinfo.h>
  40 #include <svtools/itemiter.hxx>
  41 #include <svtools/whiter.hxx>
  42 #include <svtools/rtftoken.h>
  43 #include <svtools/itempool.hxx>
  44
  45 #include <comphelper/string.hxx>
  46
  47 #include <com/sun/star/lang/Locale.hpp>
  48 #include <svx/scriptspaceitem.hxx>
  49 #include "fontitem.hxx"
  50 #include <svx/colritem.hxx>
  51 #include "svxrtf.hxx"
  52 #include <svx/svxids.hrc>
  53 #include <vcl/svapp.hxx>
  54
  55 #include <com/sun/star/document/XDocumentProperties.hpp>
  56
  57
  58 using namespace ::com::sun::star;
  59
  60
  61 SV_IMPL_PTRARR( SvxRTFColorTbl, ColorPtr )
  62 SV_IMPL_PTRARR( SvxRTFItemStackList, SvxRTFItemStackType* )
  63
  64 CharSet lcl_GetDefaultTextEncodingForRTF()
  65 {
  66
  67     ::com::sun::star::lang::Locale aLocale;
  68     ::rtl::OUString aLangString;
  69
  70     aLocale = Application::GetSettings().GetLocale();
  71     aLangString = aLocale.Language;
  72
  73     if ( aLangString.equals( ::rtl::OUString::createFromAscii( "ru" ) )
  74       || aLangString.equals( ::rtl::OUString::createFromAscii( "uk" ) ) )
  75         return RTL_TEXTENCODING_MS_1251;
  76     if ( aLangString.equals( ::rtl::OUString::createFromAscii( "tr" ) ) )
  77         return RTL_TEXTENCODING_MS_1254;
  78     else
  79         return RTL_TEXTENCODING_MS_1252;
  80 }
  81
  82 // -------------- Methoden --------------------
  83
  84 SvxRTFParser::SvxRTFParser( SfxItemPool& rPool, SvStream& rIn,
  85             uno::Reference<document::XDocumentProperties> i_xDocProps,
  86             int bReadNewDoc )
  87     : SvRTFParser( rIn, 5 ),
  88     rStrm(rIn),
  89     aColorTbl( 16, 4 ),
  90     aFontTbl( 16, 4 ),
  91     pInsPos( 0 ),
  92     pAttrPool( &rPool ),
  93     m_xDocProps( i_xDocProps ),
  94     pRTFDefaults( 0 ),
  95     nVersionNo( 0 )
  96 {
  97     bNewDoc = bReadNewDoc;
  98
  99     bChkStyleAttr = bCalcValue = bReadDocInfo = bIsInReadStyleTab = FALSE;
 100     bIsLeftToRightDef = TRUE;
 101
 102     {
 103         RTFPlainAttrMapIds aTmp( rPool );
 104         aPlainMap.Insert( (USHORT*)&aTmp,
 105                     sizeof( RTFPlainAttrMapIds ) / sizeof(USHORT), 0 );
 106     }
 107     {
 108         RTFPardAttrMapIds aTmp( rPool );
 109         aPardMap.Insert( (USHORT*)&aTmp,
 110                     sizeof( RTFPardAttrMapIds ) / sizeof(USHORT), 0 );
 111     }
 112     pDfltFont = new Font;
 113     pDfltColor = new Color;
 114 }
 115
 116 void SvxRTFParser::EnterEnvironment()
 117 {
 118 }
 119
 120 void SvxRTFParser::LeaveEnvironment()
 121 {
 122 }
 123
 124 void SvxRTFParser::ResetPard()
 125 {
 126 }
 127
 128 SvxRTFParser::~SvxRTFParser()
 129 {
 130     if( aColorTbl.Count() )
 131         ClearColorTbl();
 132     if( aFontTbl.Count() )
 133         ClearFontTbl();
 134     if( aStyleTbl.Count() )
 135         ClearStyleTbl();
 136     if( aAttrStack.Count() )
 137         ClearAttrStack();
 138
 139     delete pRTFDefaults;
 140
 141     delete pInsPos;
 142     delete pDfltFont;
 143     delete pDfltColor;
 144 }
 145
 146 void SvxRTFParser::SetInsPos( const SvxPosition& rNew )
 147 {
 148     if( pInsPos )
 149         delete pInsPos;
 150     pInsPos = rNew.Clone();
 151 }
 152
 153 SvParserState SvxRTFParser::CallParser()
 154 {
 155     DBG_ASSERT( pInsPos, "keine Einfuegeposition" );
 156
 157     if( !pInsPos )
 158         return SVPAR_ERROR;
 159
 160     if( aColorTbl.Count() )
 161         ClearColorTbl();
 162     if( aFontTbl.Count() )
 163         ClearFontTbl();
 164     if( aStyleTbl.Count() )
 165         ClearStyleTbl();
 166     if( aAttrStack.Count() )
 167         ClearAttrStack();
 168
 169     bIsSetDfltTab = FALSE;
 170     bNewGroup = FALSE;
 171     nDfltFont = 0;
 172
 173     sBaseURL.Erase();
 174
 175     // erzeuge aus den gesetzten WhichIds die richtige WhichId-Tabelle.
 176     BuildWhichTbl();
 177
 178     return SvRTFParser::CallParser();
 179 }
 180
 181 void SvxRTFParser::Continue( int nToken )
 182 {
 183     SvRTFParser::Continue( nToken );
 184
 185     if( SVPAR_PENDING != GetStatus() )
 186     {
 187         SetAllAttrOfStk();
 188 #if 0
 189     //Regardless of what "color 0" is, word defaults to auto as the default colour.
 190     //e.g. see #i7713#
 191         if( bNewDoc && ((RTFPlainAttrMapIds*)aPlainMap.GetData())->nColor )
 192             pAttrPool->SetPoolDefaultItem( SvxColorItem( GetColor( 0 ),
 193                         ((RTFPlainAttrMapIds*)aPlainMap.GetData())->nColor ));
 194 #endif
 195      }
 196 }
 197
 198
 199 // wird fuer jedes Token gerufen, das in CallParser erkannt wird
 200 void SvxRTFParser::NextToken( int nToken )
 201 {
 202     sal_Unicode cCh;
 203     switch( nToken )
 204     {
 205     case RTF_COLORTBL:          ReadColorTable();               break;
 206     case RTF_FONTTBL:           ReadFontTable();                break;
 207     case RTF_STYLESHEET:        ReadStyleTable();               break;
 208
 209     case RTF_DEFF:
 210             if( bNewDoc )
 211             {
 212                 if( aFontTbl.Count() )
 213                     // koennen wir sofort setzen
 214                     SetDefault( nToken, nTokenValue );
 215                 else
 216                     // wird nach einlesen der Fonttabelle gesetzt
 217                     nDfltFont = int(nTokenValue);
 218             }
 219             break;
 220
 221     case RTF_DEFTAB:
 222     case RTF_DEFLANG:
 223             if( bNewDoc )
 224                 SetDefault( nToken, nTokenValue );
 225             break;
 226
 227
 228     case RTF_PICT:                      ReadBitmapData();               break;
 229
 230     case RTF_LINE:                      cCh = '\n';     goto INSINGLECHAR;
 231     case RTF_TAB:                       cCh = '\t';     goto INSINGLECHAR;
 232     case RTF_SUBENTRYINDEX:     cCh = ':';      goto INSINGLECHAR;
 233
 234     case RTF_EMDASH:            cCh = 151;      goto INSINGLECHAR;
 235     case RTF_ENDASH:            cCh = 150;      goto INSINGLECHAR;
 236     case RTF_BULLET:            cCh = 149;      goto INSINGLECHAR;
 237     case RTF_LQUOTE:            cCh = 145;      goto INSINGLECHAR;
 238     case RTF_RQUOTE:            cCh = 146;      goto INSINGLECHAR;
 239     case RTF_LDBLQUOTE:         cCh = 147;      goto INSINGLECHAR;
 240     case RTF_RDBLQUOTE:         cCh = 148;      goto INSINGLECHAR;
 241 INSINGLECHAR:
 242         aToken = ByteString::ConvertToUnicode( (sal_Char)cCh,
 243                                             RTL_TEXTENCODING_MS_1252 );
 244
 245         // kein Break, aToken wird als Text gesetzt
 246     case RTF_TEXTTOKEN:
 247         {
 248             InsertText();
 249             // alle angesammelten Attribute setzen
 250             for( USHORT n = aAttrSetList.Count(); n; )
 251             {
 252                 SvxRTFItemStackType* pStkSet = aAttrSetList[--n];
 253                 SetAttrSet( *pStkSet );
 254                 aAttrSetList.DeleteAndDestroy( n );
 255             }
 256         }
 257         break;
 258
 259
 260     case RTF_PAR:
 261         InsertPara();
 262         break;
 263     case '{':
 264         if (bNewGroup)                  // Verschachtelung !!
 265             _GetAttrSet();
 266         EnterEnvironment();
 267         bNewGroup = true;
 268         break;
 269     case '}':
 270         if( !bNewGroup )                // leere Gruppe ??
 271             AttrGroupEnd();
 272         LeaveEnvironment();
 273         bNewGroup = false;
 274         break;
 275     case RTF_INFO:
 276 #ifndef SVX_LIGHT
 277         if (bReadDocInfo && bNewDoc && m_xDocProps.is())
 278             ReadInfo();
 279         else
 280 #endif
 281             SkipGroup();
 282         break;
 283
 284     // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 285     // erstmal gesamt ueberlesen (muessen alle in einer Gruppe stehen !!)
 286     // Koennen auch ohne dem IGNORE-Flag im RTF-File auftreten; alle Gruppen
 287     // mit IGNORE-Flag werden im default-Zweig ueberlesen.
 288
 289     case RTF_SWG_PRTDATA:
 290     case RTF_FIELD:
 291     case RTF_ATNID:
 292     case RTF_ANNOTATION:
 293
 294     case RTF_BKMKSTART:
 295     case RTF_BKMKEND:
 296     case RTF_BKMK_KEY:
 297     case RTF_XE:
 298     case RTF_TC:
 299     case RTF_NEXTFILE:
 300     case RTF_TEMPLATE:
 301 #if 0
 302     //disabled for #i19718#
 303     case RTF_SHPRSLT:   // RTF_SHP fehlt noch !!
 304 #endif
 305                             SkipGroup();
 306                             break;
 307     // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 308
 309     case RTF_PGDSCNO:
 310     case RTF_PGBRK:
 311     case RTF_SHADOW:
 312             if( RTF_IGNOREFLAG != GetStackPtr( -1 )->nTokenId )
 313                 break;
 314             nToken = SkipToken( -1 );
 315             if( '{' == GetStackPtr( -1 )->nTokenId )
 316                 nToken = SkipToken( -1 );
 317
 318             ReadAttr( nToken, &GetAttrSet() );
 319             break;
 320
 321     default:
 322         switch( nToken & ~(0xff | RTF_SWGDEFS) )
 323         {
 324         case RTF_PARFMT:                // hier gibts keine Swg-Defines
 325             ReadAttr( nToken, &GetAttrSet() );
 326             break;
 327
 328         case RTF_CHRFMT:
 329         case RTF_BRDRDEF:
 330         case RTF_TABSTOPDEF:
 331
 332             if( RTF_SWGDEFS & nToken)
 333             {
 334                 if( RTF_IGNOREFLAG != GetStackPtr( -1 )->nTokenId )
 335                     break;
 336                 nToken = SkipToken( -1 );
 337                 if( '{' == GetStackPtr( -1 )->nTokenId )
 338                 {
 339                     nToken = SkipToken( -1 );
 340                 }
 341             }
 342             ReadAttr( nToken, &GetAttrSet() );
 343             break;
 344         default:
 345             {
 346                 if( /*( '{' == GetStackPtr( -1 )->nTokenId ) ||*/
 347                     ( RTF_IGNOREFLAG == GetStackPtr( -1 )->nTokenId &&
 348                       '{' == GetStackPtr( -2 )->nTokenId ) )
 349                     SkipGroup();
 350             }
 351             break;
 352         }
 353         break;
 354     }
 355 }
 356
 357 void SvxRTFParser::ReadStyleTable()
 358 {
 359     int nToken, bSaveChkStyleAttr = bChkStyleAttr;
 360     short nStyleNo = 0;
 361     int _nOpenBrakets = 1;              // die erste wurde schon vorher erkannt !!
 362     SvxRTFStyleType* pStyle = new SvxRTFStyleType( *pAttrPool, aWhichMap.GetData() );
 363     pStyle->aAttrSet.Put( GetRTFDefaults() );
 364
 365     bIsInReadStyleTab = TRUE;
 366     bChkStyleAttr = FALSE;              // Attribute nicht gegen die Styles checken
 367
 368     while( _nOpenBrakets && IsParserWorking() )
 369     {
 370         switch( nToken = GetNextToken() )
 371         {
 372         case '}':               if( --_nOpenBrakets && IsParserWorking() )
 373                             // Style konnte vollstaendig gelesen werden,
 374                             // also ist das noch ein stabiler Status
 375                             SaveState( RTF_STYLESHEET );
 376                         break;
 377         case '{':
 378             {
 379                 if( RTF_IGNOREFLAG != GetNextToken() )
 380                     nToken = SkipToken( -1 );
 381                 else if( RTF_UNKNOWNCONTROL != ( nToken = GetNextToken() ) &&
 382                             RTF_PN != nToken )
 383                     nToken = SkipToken( -2 );
 384                 else
 385                 {
 386                     // gleich herausfiltern
 387                     ReadUnknownData();
 388                     nToken = GetNextToken();
 389                     if( '}' != nToken )
 390                         eState = SVPAR_ERROR;
 391                     break;
 392                 }
 393                 ++_nOpenBrakets;
 394             }
 395             break;
 396
 397         case RTF_SBASEDON:      pStyle->nBasedOn = USHORT(nTokenValue); pStyle->bBasedOnIsSet=TRUE;     break;
 398         case RTF_SNEXT:         pStyle->nNext = USHORT(nTokenValue);    break;
 399         case RTF_OUTLINELEVEL:
 400         case RTF_SOUTLVL:       pStyle->nOutlineNo = BYTE(nTokenValue); break;
 401         case RTF_S:                     nStyleNo = (short)nTokenValue;                  break;
 402         case RTF_CS:            nStyleNo = (short)nTokenValue;
 403                             pStyle->bIsCharFmt = TRUE;
 404                             break;
 405
 406         case RTF_TEXTTOKEN:
 407             {
 408                 pStyle->sName = DelCharAtEnd( aToken, ';' );
 409
 410 /*
 411 ??? soll man das umsetzen ???
 412                 if( !pStyle->sName.Len() )
 413                     pStyle->sName = "Standard";
 414 */
 415                 // sollte die Nummer doppelt vergeben werden ?
 416                 if( aStyleTbl.Count() )
 417                 {
 418                     SvxRTFStyleType* pOldSt = aStyleTbl.Remove( nStyleNo );
 419                     if( pOldSt )
 420                         delete pOldSt;
 421                 }
 422                 // alle Daten vom Style vorhanden, also ab in die Tabelle
 423                 aStyleTbl.Insert( nStyleNo, pStyle );
 424                 pStyle = new SvxRTFStyleType( *pAttrPool, aWhichMap.GetData() );
 425                 pStyle->aAttrSet.Put( GetRTFDefaults() );
 426                 nStyleNo = 0;
 427             }
 428             break;
 429         default:
 430             switch( nToken & ~(0xff | RTF_SWGDEFS) )
 431             {
 432             case RTF_PARFMT:            // hier gibts keine Swg-Defines
 433                 ReadAttr( nToken, &pStyle->aAttrSet );
 434                 break;
 435
 436             case RTF_CHRFMT:
 437             case RTF_BRDRDEF:
 438             case RTF_TABSTOPDEF:
 439
 440                 if( RTF_SWGDEFS & nToken)
 441                 {
 442                     if( RTF_IGNOREFLAG != GetStackPtr( -1 )->nTokenId )
 443                         break;
 444                     nToken = SkipToken( -1 );
 445                     if( '{' == GetStackPtr( -1 )->nTokenId )
 446                     {
 447                         nToken = SkipToken( -1 );
 448 #if 0
 449                         --_nOpenBrakets;                // korrigieren!!
 450 #endif
 451                     }
 452                 }
 453                 ReadAttr( nToken, &pStyle->aAttrSet );
 454                 break;
 455             }
 456             break;
 457         }
 458     }
 459     delete pStyle;                      // loesche das letze Style
 460     SkipToken( -1 );            // die schliesende Klammer wird "oben" ausgewertet
 461
 462     // Flag wieder auf alten Zustand
 463     bChkStyleAttr = bSaveChkStyleAttr;
 464     bIsInReadStyleTab = FALSE;
 465 }
 466
 467 void SvxRTFParser::ReadColorTable()
 468 {
 469     int nToken;
 470     BYTE nRed = 0xff, nGreen = 0xff, nBlue = 0xff;
 471
 472     while( '}' != ( nToken = GetNextToken() ) && IsParserWorking() )
 473     {
 474         switch( nToken )
 475         {
 476         case RTF_RED:   nRed = BYTE(nTokenValue);               break;
 477         case RTF_GREEN: nGreen = BYTE(nTokenValue);             break;
 478         case RTF_BLUE:  nBlue = BYTE(nTokenValue);              break;
 479
 480         case RTF_TEXTTOKEN:             // oder sollte irgendein Unsin darumstehen?
 481             if( 1 == aToken.Len()
 482                     ? aToken.GetChar( 0 ) != ';'
 483                     : STRING_NOTFOUND == aToken.Search( ';' ) )
 484                 break;          // es muss zumindestens das ';' gefunden werden
 485
 486             // else kein break !!
 487
 488         case ';':
 489             if( IsParserWorking() )
 490             {
 491                 // eine Farbe ist Fertig, in die Tabelle eintragen
 492                 // versuche die Werte auf SV interne Namen zu mappen
 493                 ColorPtr pColor = new Color( nRed, nGreen, nBlue );
 494                 if( !aColorTbl.Count() &&
 495                     BYTE(-1) == nRed && BYTE(-1) == nGreen && BYTE(-1) == nBlue )
 496                     pColor->SetColor( COL_AUTO );
 497                 aColorTbl.Insert( pColor, aColorTbl.Count() );
 498                 nRed = 0, nGreen = 0, nBlue = 0;
 499
 500                 // Color konnte vollstaendig gelesen werden,
 501                 // also ist das noch ein stabiler Status
 502                 SaveState( RTF_COLORTBL );
 503             }
 504             break;
 505         }
 506     }
 507     SkipToken( -1 );            // die schliesende Klammer wird "oben" ausgewertet
 508 }
 509
 510 void SvxRTFParser::ReadFontTable()
 511 {
 512     int nToken;
 513     int _nOpenBrakets = 1;              // die erste wurde schon vorher erkannt !!
 514     Font* pFont = new Font();
 515     short nFontNo(0), nInsFontNo (0);
 516     String sAltNm, sFntNm;
 517     BOOL bIsAltFntNm = FALSE, bCheckNewFont;
 518
 519     CharSet nSystemChar = lcl_GetDefaultTextEncodingForRTF();
 520     pFont->SetCharSet( nSystemChar );
 521     SetEncoding( nSystemChar );
 522
 523     while( _nOpenBrakets && IsParserWorking() )
 524     {
 525         bCheckNewFont = FALSE;
 526         switch( ( nToken = GetNextToken() ))
 527         {
 528             case '}':
 529                 bIsAltFntNm = FALSE;
 530                 // Style konnte vollstaendig gelesen werden,
 531                 // also ist das noch ein stabiler Status
 532                 if( --_nOpenBrakets <= 1 && IsParserWorking() )
 533                     SaveState( RTF_FONTTBL );
 534                 bCheckNewFont = TRUE;
 535                 nInsFontNo = nFontNo;
 536                 break;
 537             case '{':
 538                 if( RTF_IGNOREFLAG != GetNextToken() )
 539                     nToken = SkipToken( -1 );
 540                 // Unknown und alle bekannten nicht ausgewerteten Gruppen
 541                 // sofort ueberspringen
 542                 else if( RTF_UNKNOWNCONTROL != ( nToken = GetNextToken() ) &&
 543                         RTF_PANOSE != nToken && RTF_FNAME != nToken &&
 544                         RTF_FONTEMB != nToken && RTF_FONTFILE != nToken )
 545                     nToken = SkipToken( -2 );
 546                 else
 547                 {
 548                     // gleich herausfiltern
 549                     ReadUnknownData();
 550                     nToken = GetNextToken();
 551                     if( '}' != nToken )
 552                         eState = SVPAR_ERROR;
 553                     break;
 554                 }
 555                 ++_nOpenBrakets;
 556                 break;
 557             case RTF_FROMAN:
 558                 pFont->SetFamily( FAMILY_ROMAN );
 559                 break;
 560             case RTF_FSWISS:
 561                 pFont->SetFamily( FAMILY_SWISS );
 562                 break;
 563             case RTF_FMODERN:
 564                 pFont->SetFamily( FAMILY_MODERN );
 565                 break;
 566             case RTF_FSCRIPT:
 567                 pFont->SetFamily( FAMILY_SCRIPT );
 568                 break;
 569             case RTF_FDECOR:
 570                 pFont->SetFamily( FAMILY_DECORATIVE );
 571                 break;
 572             // bei technischen/symbolischen Font wird der CharSet ungeschaltet!!
 573             case RTF_FTECH:
 574                 pFont->SetCharSet( RTL_TEXTENCODING_SYMBOL );
 575                 // deliberate fall through
 576             case RTF_FNIL:
 577                 pFont->SetFamily( FAMILY_DONTKNOW );
 578                 break;
 579             case RTF_FCHARSET:
 580                 if (-1 != nTokenValue)
 581                 {
 582                     CharSet nCharSet = rtl_getTextEncodingFromWindowsCharset(
 583                         (BYTE)nTokenValue);
 584                     pFont->SetCharSet(nCharSet);
 585                     //When we're in a font, the fontname is in the font
 586                     //charset, except for symbol fonts I believe
 587                     if (nCharSet == RTL_TEXTENCODING_SYMBOL)
 588                         nCharSet = RTL_TEXTENCODING_DONTKNOW;
 589                     SetEncoding(nCharSet);
 590                 }
 591                 break;
 592             case RTF_FPRQ:
 593                 switch( nTokenValue )
 594                 {
 595                     case 1:
 596                         pFont->SetPitch( PITCH_FIXED );
 597                         break;
 598                     case 2:
 599                         pFont->SetPitch( PITCH_VARIABLE );
 600                         break;
 601                 }
 602                 break;
 603             case RTF_F:
 604                 bCheckNewFont = TRUE;
 605                 nInsFontNo = nFontNo;
 606                 nFontNo = (short)nTokenValue;
 607                 break;
 608             case RTF_FALT:
 609                 bIsAltFntNm = TRUE;
 610                 break;
 611             case RTF_TEXTTOKEN:
 612                 DelCharAtEnd( aToken, ';' );
 613                 if ( aToken.Len() )
 614                 {
 615                     if( bIsAltFntNm )
 616                         sAltNm = aToken;
 617                     else
 618                         sFntNm = aToken;
 619                 }
 620                 break;
 621         }
 622
 623         if( bCheckNewFont && 1 >= _nOpenBrakets && sFntNm.Len() )  // one font is ready
 624         {
 625             // alle Daten vom Font vorhanden, also ab in die Tabelle
 626             if (sAltNm.Len())
 627                 (sFntNm += ';' ) += sAltNm;
 628
 629             pFont->SetName( sFntNm );
 630             aFontTbl.Insert( nInsFontNo, pFont );
 631             pFont = new Font();
 632             pFont->SetCharSet( nSystemChar );
 633             sAltNm.Erase();
 634             sFntNm.Erase();
 635         }
 636     }
 637     // den letzen muessen wir selbst loeschen
 638     delete pFont;
 639     SkipToken( -1 );            // die schliesende Klammer wird "oben" ausgewertet
 640
 641     // setze den default Font am Doc
 642     if( bNewDoc && IsParserWorking() )
 643         SetDefault( RTF_DEFF, nDfltFont );
 644 }
 645
 646 void SvxRTFParser::ReadBitmapData()
 647 {
 648     SvRTFParser::ReadBitmapData();
 649 }
 650
 651 void SvxRTFParser::ReadOLEData()
 652 {
 653     SvRTFParser::ReadOLEData();
 654 }
 655
 656 String& SvxRTFParser::GetTextToEndGroup( String& rStr )
 657 {
 658     rStr.Erase( 0 );
 659     int _nOpenBrakets = 1, nToken;              // die erste wurde schon vorher erkannt !!
 660
 661     while( _nOpenBrakets && IsParserWorking() )
 662     {
 663         switch( nToken = GetNextToken() )
 664         {
 665         case '}':               --_nOpenBrakets;        break;
 666         case '{':
 667             {
 668                 if( RTF_IGNOREFLAG != GetNextToken() )
 669                     nToken = SkipToken( -1 );
 670                 else if( RTF_UNKNOWNCONTROL != GetNextToken() )
 671                     nToken = SkipToken( -2 );
 672                 else
 673                 {
 674                     // gleich herausfiltern
 675                     ReadUnknownData();
 676                     nToken = GetNextToken();
 677                     if( '}' != nToken )
 678                         eState = SVPAR_ERROR;
 679                     break;
 680                 }
 681                 ++_nOpenBrakets;
 682             }
 683             break;
 684
 685         case RTF_TEXTTOKEN:
 686             rStr += aToken;
 687             break;
 688         }
 689     }
 690     SkipToken( -1 );            // die schliesende Klammer wird "oben" ausgewertet
 691     return rStr;
 692 }
 693
 694 util::DateTime SvxRTFParser::GetDateTimeStamp( )
 695 {
 696     util::DateTime aDT;
 697     BOOL bWeiter = TRUE;
 698     int nToken;
 699     while( bWeiter && IsParserWorking() )
 700     {
 701         switch( nToken = GetNextToken() )
 702         {
 703         case RTF_YR:    aDT.Year = (USHORT)nTokenValue;     break;
 704         case RTF_MO:    aDT.Month = (USHORT)nTokenValue;        break;
 705         case RTF_DY:    aDT.Day = (USHORT)nTokenValue;      break;
 706         case RTF_HR:    aDT.Hours = (USHORT)nTokenValue;        break;
 707         case RTF_MIN:   aDT.Minutes = (USHORT)nTokenValue;      break;
 708         default:
 709             bWeiter = FALSE;
 710         }
 711     }
 712     SkipToken( -1 );            // die schliesende Klammer wird "oben" ausgewertet
 713     return aDT;
 714 }
 715
 716 void SvxRTFParser::ReadInfo( const sal_Char* pChkForVerNo )
 717 {
 718 #ifndef SVX_LIGHT
 719     int _nOpenBrakets = 1, nToken;              // die erste wurde schon vorher erkannt !!
 720     DBG_ASSERT(m_xDocProps.is(),
 721         "SvxRTFParser::ReadInfo: no DocumentProperties");
 722     String sStr, sComment;
 723     long nVersNo = 0;
 724
 725     while( _nOpenBrakets && IsParserWorking() )
 726     {
 727         switch( nToken = GetNextToken() )
 728         {
 729         case '}':               --_nOpenBrakets;        break;
 730         case '{':
 731             {
 732                 if( RTF_IGNOREFLAG != GetNextToken() )
 733                     nToken = SkipToken( -1 );
 734                 else if( RTF_UNKNOWNCONTROL != GetNextToken() )
 735                     nToken = SkipToken( -2 );
 736                 else
 737                 {
 738                     // gleich herausfiltern
 739                     ReadUnknownData();
 740                     nToken = GetNextToken();
 741                     if( '}' != nToken )
 742                         eState = SVPAR_ERROR;
 743                     break;
 744                 }
 745                 ++_nOpenBrakets;
 746             }
 747             break;
 748
 749         case RTF_TITLE:
 750             m_xDocProps->setTitle( GetTextToEndGroup( sStr ) );
 751             break;
 752         case RTF_SUBJECT:
 753             m_xDocProps->setSubject( GetTextToEndGroup( sStr ) );
 754             break;
 755         case RTF_AUTHOR:
 756             m_xDocProps->setAuthor( GetTextToEndGroup( sStr ) );
 757             break;
 758         case RTF_OPERATOR:
 759             m_xDocProps->setModifiedBy( GetTextToEndGroup( sStr ) );
 760             break;
 761         case RTF_KEYWORDS:
 762             {
 763                 ::rtl::OUString sTemp = GetTextToEndGroup( sStr );
 764                 m_xDocProps->setKeywords(
 765                     ::comphelper::string::convertCommaSeparated(sTemp) );
 766                 break;
 767             }
 768         case RTF_DOCCOMM:
 769             m_xDocProps->setDescription( GetTextToEndGroup( sStr ) );
 770             break;
 771
 772         case RTF_HLINKBASE:
 773             sBaseURL = GetTextToEndGroup( sStr ) ;
 774             break;
 775
 776         case RTF_CREATIM:
 777             m_xDocProps->setCreationDate( GetDateTimeStamp() );
 778             break;
 779
 780         case RTF_REVTIM:
 781             m_xDocProps->setModificationDate( GetDateTimeStamp() );
 782             break;
 783
 784         case RTF_PRINTIM:
 785             m_xDocProps->setPrintDate( GetDateTimeStamp() );
 786             break;
 787
 788         case RTF_COMMENT:
 789             GetTextToEndGroup( sComment );
 790             break;
 791
 792         case RTF_BUPTIM:
 793             SkipGroup();
 794             break;
 795
 796         case RTF_VERN:
 797             nVersNo = nTokenValue;
 798             break;
 799
 800         case RTF_EDMINS:
 801         case RTF_ID:
 802         case RTF_VERSION:
 803         case RTF_NOFPAGES:
 804         case RTF_NOFWORDS:
 805         case RTF_NOFCHARS:
 806             NextToken( nToken );
 807             break;
 808
 809 //              default:
 810         }
 811     }
 812
 813     if( pChkForVerNo &&
 814         COMPARE_EQUAL == sComment.CompareToAscii( pChkForVerNo ))
 815         nVersionNo = nVersNo;
 816
 817     SkipToken( -1 );            // die schliesende Klammer wird "oben" ausgewertet
 818 #endif
 819 }
 820
 821
 822 void SvxRTFParser::ClearColorTbl()
 823 {
 824     aColorTbl.DeleteAndDestroy( 0, aColorTbl.Count() );
 825 }
 826
 827 void SvxRTFParser::ClearFontTbl()
 828 {
 829     for( ULONG nCnt = aFontTbl.Count(); nCnt; )
 830         delete aFontTbl.GetObject( --nCnt );
 831 }
 832
 833 void SvxRTFParser::ClearStyleTbl()
 834 {
 835     for( ULONG nCnt = aStyleTbl.Count(); nCnt; )
 836         delete aStyleTbl.GetObject( --nCnt );
 837 }
 838
 839 void SvxRTFParser::ClearAttrStack()
 840 {
 841     SvxRTFItemStackType* pTmp;
 842     for( ULONG nCnt = aAttrStack.Count(); nCnt; --nCnt )
 843     {
 844         pTmp = aAttrStack.Pop();
 845         delete pTmp;
 846     }
 847 }
 848
 849 String& SvxRTFParser::DelCharAtEnd( String& rStr, const sal_Unicode cDel )
 850 {
 851     if( rStr.Len() && ' ' == rStr.GetChar( 0 ))
 852         rStr.EraseLeadingChars();
 853     if( rStr.Len() && ' ' == rStr.GetChar( rStr.Len()-1 ))
 854         rStr.EraseTrailingChars();
 855     if( rStr.Len() && cDel == rStr.GetChar( rStr.Len()-1 ))
 856         rStr.Erase( rStr.Len()-1 );
 857     return rStr;
 858 }
 859
 860
 861 const Font& SvxRTFParser::GetFont( USHORT nId )
 862 {
 863     const Font* pFont = aFontTbl.Get( nId );
 864     if( !pFont )
 865     {
 866         const SvxFontItem& rDfltFont = (const SvxFontItem&)
 867                         pAttrPool->GetDefaultItem(
 868                     ((RTFPlainAttrMapIds*)aPlainMap.GetData())->nFont );
 869         pDfltFont->SetName( rDfltFont.GetStyleName() );
 870         pDfltFont->SetFamily( rDfltFont.GetFamily() );
 871         pFont = pDfltFont;
 872     }
 873     return *pFont;
 874 }
 875
 876 SvxRTFItemStackType* SvxRTFParser::_GetAttrSet( int bCopyAttr )
 877 {
 878     SvxRTFItemStackType* pAkt = aAttrStack.Top();
 879     SvxRTFItemStackType* pNew;
 880     if( pAkt )
 881         pNew = new SvxRTFItemStackType( *pAkt, *pInsPos, bCopyAttr );
 882     else
 883         pNew = new SvxRTFItemStackType( *pAttrPool, aWhichMap.GetData(),
 884                                         *pInsPos );
 885     pNew->SetRTFDefaults( GetRTFDefaults() );
 886
 887     aAttrStack.Push( pNew );
 888     bNewGroup = FALSE;
 889     return pNew;
 890 }
 891
 892
 893 void SvxRTFParser::_ClearStyleAttr( SvxRTFItemStackType& rStkType )
 894 {
 895     // check attributes to the attributes of the stylesheet or to
 896     // the default attrs of the document
 897     SfxItemSet &rSet = rStkType.GetAttrSet();
 898     const SfxItemPool& rPool = *rSet.GetPool();
 899     const SfxPoolItem* pItem;
 900     SfxWhichIter aIter( rSet );
 901
 902     SvxRTFStyleType* pStyle;
 903     if( !IsChkStyleAttr() ||
 904         !rStkType.GetAttrSet().Count() ||
 905         0 == ( pStyle = aStyleTbl.Get( rStkType.nStyleNo ) ))
 906     {
 907         for( USHORT nWhich = aIter.GetCurWhich(); nWhich; nWhich = aIter.NextWhich() )
 908         {
 909             if( SFX_WHICH_MAX > nWhich &&
 910                 SFX_ITEM_SET == rSet.GetItemState( nWhich, FALSE, &pItem ) &&
 911                      rPool.GetDefaultItem( nWhich ) == *pItem )
 912                 rSet.ClearItem( nWhich );               // loeschen
 913         }
 914     }
 915     else
 916     {
 917         // alle Attribute, die schon vom Style definiert sind, aus dem
 918         // akt. AttrSet entfernen
 919         SfxItemSet &rStyleSet = pStyle->aAttrSet;
 920         const SfxPoolItem* pSItem;
 921         for( USHORT nWhich = aIter.GetCurWhich(); nWhich; nWhich = aIter.NextWhich() )
 922         {
 923             if( SFX_ITEM_SET == rStyleSet.GetItemState( nWhich, TRUE, &pSItem ))
 924             {
 925                 // JP 22.06.99: im Style und im Set gleich gesetzt -> loeschen
 926                 if( SFX_ITEM_SET == rSet.GetItemState( nWhich, FALSE, &pItem )
 927                     && *pItem == *pSItem )
 928                     rSet.ClearItem( nWhich );           // loeschen
 929             }
 930                 // Bug 59571 - falls nicht im Style gesetzt und gleich mit
 931                 //                              dem PoolDefault -> auch dann loeschen
 932             else if( SFX_WHICH_MAX > nWhich &&
 933                     SFX_ITEM_SET == rSet.GetItemState( nWhich, FALSE, &pItem ) &&
 934                      rPool.GetDefaultItem( nWhich ) == *pItem )
 935                 rSet.ClearItem( nWhich );               // loeschen
 936         }
 937     }
 938 }
 939
 940 void SvxRTFParser::AttrGroupEnd()       // den akt. Bearbeiten, vom Stack loeschen
 941 {
 942     if( aAttrStack.Count() )
 943     {
 944         SvxRTFItemStackType *pOld = aAttrStack.Pop();
 945         SvxRTFItemStackType *pAkt = aAttrStack.Top();
 946
 947         do {            // middle check loop
 948             ULONG nOldSttNdIdx = pOld->pSttNd->GetIdx();
 949             if( !pOld->pChildList &&
 950                 ((!pOld->aAttrSet.Count() && !pOld->nStyleNo ) ||
 951                 (nOldSttNdIdx == pInsPos->GetNodeIdx() &&
 952                 pOld->nSttCnt == pInsPos->GetCntIdx() )))
 953                 break;                  // keine Attribute oder Bereich
 954
 955             // setze nur die Attribute, die unterschiedlich zum Parent sind
 956             if( pAkt && pOld->aAttrSet.Count() )
 957             {
 958                 SfxItemIter aIter( pOld->aAttrSet );
 959                 const SfxPoolItem* pItem = aIter.GetCurItem(), *pGet;
 960                 while( TRUE )
 961                 {
 962                     if( SFX_ITEM_SET == pAkt->aAttrSet.GetItemState(
 963                         pItem->Which(), FALSE, &pGet ) &&
 964                         *pItem == *pGet )
 965                         pOld->aAttrSet.ClearItem( pItem->Which() );
 966
 967                     if( aIter.IsAtEnd() )
 968                         break;
 969                     pItem = aIter.NextItem();
 970                 }
 971
 972                 if( !pOld->aAttrSet.Count() && !pOld->pChildList &&
 973                     !pOld->nStyleNo )
 974                     break;
 975             }
 976
 977             // setze alle Attribute, die von Start bis hier
 978             // definiert sind.
 979             int bCrsrBack = !pInsPos->GetCntIdx();
 980             if( bCrsrBack )
 981             {
 982                 // am Absatzanfang ? eine Position zurueck
 983                 ULONG nNd = pInsPos->GetNodeIdx();
 984                 MovePos( FALSE );
 985                 // if can not move backward then later dont move forward !
 986                 bCrsrBack = nNd != pInsPos->GetNodeIdx();
 987             }
 988
 989             //Bug #46608#: ungueltige Bereiche ignorieren!
 990             if( ( pOld->pSttNd->GetIdx() < pInsPos->GetNodeIdx() ||
 991                 ( pOld->pSttNd->GetIdx() == pInsPos->GetNodeIdx() &&
 992                 pOld->nSttCnt <= pInsPos->GetCntIdx() ))
 993 #if 0
 994 //BUG 68555 - dont test for empty paragraph or any range
 995                 && ( nOldSttNdIdx != pInsPos->GetNodeIdx() ||
 996                 pOld->nSttCnt != pInsPos->GetCntIdx() ||
 997                 !pOld->nSttCnt )
 998 #endif
 999                 )
1000             {
1001                 if( !bCrsrBack )
1002                 {
1003                     // alle pard-Attribute gelten nur bis zum vorherigen
1004                     // Absatz !!
1005                     if( nOldSttNdIdx == pInsPos->GetNodeIdx() )
1006                     {
1007 #if 0
1008 //BUG 68555 - dont reset pard attrs, if the group not begins not at start of
1009 //                              paragraph
1010                         // Bereich innerhalb eines Absatzes:
1011                         // alle Absatz-Attribute und StyleNo loeschen
1012                         // aber nur wenn mitten drin angefangen wurde
1013                         if( pOld->nSttCnt )
1014                         {
1015                             pOld->nStyleNo = 0;
1016                             for( USHORT n = 0; n < aPardMap.Count() &&
1017                                                 pOld->aAttrSet.Count(); ++n )
1018                                 if( aPardMap[n] )
1019                                     pOld->aAttrSet.ClearItem( aPardMap[n] );
1020
1021                             if( !pOld->aAttrSet.Count() && !pOld->pChildList &&
1022                                 !pOld->nStyleNo  )
1023                                 break;  // auch dieser verlaesst uns jetzt
1024                         }
1025 #endif
1026                     }
1027                     else
1028                     {
1029                         // jetzt wirds kompliziert:
1030                         // - alle Zeichen-Attribute behalten den Bereich,
1031                         // - alle Absatz-Attribute bekommen den Bereich
1032                         //                      bis zum vorherigen Absatz
1033                         SvxRTFItemStackType* pNew = new SvxRTFItemStackType(
1034                                     *pOld, *pInsPos, TRUE );
1035                         pNew->aAttrSet.SetParent( pOld->aAttrSet.GetParent() );
1036
1037                         // loesche aus pNew alle Absatz Attribute
1038                         for( USHORT n = 0; n < aPardMap.Count() &&
1039                                             pNew->aAttrSet.Count(); ++n )
1040                             if( aPardMap[n] )
1041                                 pNew->aAttrSet.ClearItem( aPardMap[n] );
1042                         pNew->SetRTFDefaults( GetRTFDefaults() );
1043
1044                         // gab es ueberhaupt welche ?
1045                         if( pNew->aAttrSet.Count() == pOld->aAttrSet.Count() )
1046                             delete pNew;                // das wars dann
1047                         else
1048                         {
1049                             pNew->nStyleNo = 0;
1050
1051                             // spanne jetzt den richtigen Bereich auf
1052                             // pNew von alter
1053                             SetEndPrevPara( pOld->pEndNd, pOld->nEndCnt );
1054                             pNew->nSttCnt = 0;
1055
1056                             if( IsChkStyleAttr() )
1057                             {
1058                                 _ClearStyleAttr( *pOld );
1059                                 _ClearStyleAttr( *pNew );   //#i10381#, methinks.
1060                             }
1061
1062                             if( pAkt )
1063                             {
1064                                 pAkt->Add( pOld );
1065                                 pAkt->Add( pNew );
1066                             }
1067                             else
1068                             {
1069                                 // letzter vom Stack, also zwischenspeichern, bis der
1070                                 // naechste Text eingelesen wurde. (keine Attribute
1071                                 // aufspannen!!)
1072                                 aAttrSetList.Insert( pOld, aAttrSetList.Count() );
1073                                 aAttrSetList.Insert( pNew, aAttrSetList.Count() );
1074                             }
1075                             pOld = 0;   // pOld nicht loeschen
1076                             break;              // das wars !!
1077                         }
1078                     }
1079                 }
1080
1081                 pOld->pEndNd = pInsPos->MakeNodeIdx();
1082                 pOld->nEndCnt = pInsPos->GetCntIdx();
1083
1084 #if 0
1085                 if( IsChkStyleAttr() )
1086                     _ClearStyleAttr( *pOld );
1087 #else
1088                 /*
1089                 #i21422#
1090                 If the parent (pAkt) sets something e.g. , and the child (pOld)
1091                 unsets it and the style both are based on has it unset then
1092                 clearing the pOld by looking at the style is clearly a disaster
1093                 as the text ends up with pAkts bold and not pOlds no bold, this
1094                 should be rethought out. For the moment its safest to just do
1095                 the clean if we have no parent, all we suffer is too many
1096                 redundant properties.
1097                 */
1098                 if (IsChkStyleAttr() && !pAkt)
1099                     _ClearStyleAttr( *pOld );
1100 #endif
1101
1102                 if( pAkt )
1103                 {
1104                     pAkt->Add( pOld );
1105                     // split up and create new entry, because it make no sense
1106                     // to create a "so long" depend list. Bug 95010
1107                     if( bCrsrBack && 50 < pAkt->pChildList->Count() )
1108                     {
1109                         // am Absatzanfang ? eine Position zurueck
1110                         MovePos( TRUE );
1111                         bCrsrBack = FALSE;
1112
1113                         // eine neue Gruppe aufmachen
1114                         SvxRTFItemStackType* pNew = new SvxRTFItemStackType(
1115                                                 *pAkt, *pInsPos, TRUE );
1116                         pNew->SetRTFDefaults( GetRTFDefaults() );
1117
1118                         // alle bis hierher gueltigen Attribute "setzen"
1119                         AttrGroupEnd();
1120                         pAkt = aAttrStack.Top();  // can be changed after AttrGroupEnd!
1121                         pNew->aAttrSet.SetParent( pAkt ? &pAkt->aAttrSet : 0 );
1122                         aAttrStack.Push( pNew );
1123                         pAkt = pNew;
1124                     }
1125                 }
1126                 else
1127                     // letzter vom Stack, also zwischenspeichern, bis der
1128                     // naechste Text eingelesen wurde. (keine Attribute
1129                     // aufspannen!!)
1130                     aAttrSetList.Insert( pOld, aAttrSetList.Count() );
1131
1132                 pOld = 0;
1133             }
1134
1135             if( bCrsrBack )
1136                 // am Absatzanfang ? eine Position zurueck
1137                 MovePos( TRUE );
1138
1139         } while( FALSE );
1140
1141         if( pOld )
1142             delete pOld;
1143
1144         bNewGroup = FALSE;
1145     }
1146 }
1147
1148 void SvxRTFParser::SetAllAttrOfStk()            // end all Attr. and set it into doc
1149 {
1150     // noch alle Attrbute vom Stack holen !!
1151     while( aAttrStack.Count() )
1152         AttrGroupEnd();
1153
1154     for( USHORT n = aAttrSetList.Count(); n; )
1155     {
1156         SvxRTFItemStackType* pStkSet = aAttrSetList[--n];
1157         SetAttrSet( *pStkSet );
1158         aAttrSetList.DeleteAndDestroy( n );
1159     }
1160 }
1161
1162 // setzt alle Attribute, die unterschiedlich zum aktuellen sind
1163 void SvxRTFParser::SetAttrSet( SvxRTFItemStackType &rSet )
1164 {
1165     // wurde DefTab nie eingelesen? dann setze auf default
1166     if( !bIsSetDfltTab )
1167         SetDefault( RTF_DEFTAB, 720 );
1168
1169     if( rSet.pChildList )
1170         rSet.Compress( *this );
1171     if( rSet.aAttrSet.Count() || rSet.nStyleNo )
1172         SetAttrInDoc( rSet );
1173
1174     // dann mal alle Childs abarbeiten
1175     if( rSet.pChildList )
1176         for( USHORT n = 0; n < rSet.pChildList->Count(); ++n )
1177             SetAttrSet( *(*rSet.pChildList)[ n ] );
1178 }
1179
1180     // wurde noch kein Text eingefuegt ? (SttPos vom obersten StackEintrag!)
1181 int     SvxRTFParser::IsAttrSttPos()
1182 {
1183     SvxRTFItemStackType* pAkt = aAttrStack.Top();
1184     return !pAkt || (pAkt->pSttNd->GetIdx() == pInsPos->GetNodeIdx() &&
1185         pAkt->nSttCnt == pInsPos->GetCntIdx());
1186 }
1187
1188
1189 void SvxRTFParser::SetAttrInDoc( SvxRTFItemStackType & )
1190 {
1191 }
1192
1193 #ifdef USED
1194 void SvxRTFParser::SaveState( int nToken )
1195 {
1196     SvRTFParser::SaveState( nToken );
1197 }
1198
1199 void SvxRTFParser::RestoreState()
1200 {
1201     SvRTFParser::RestoreState();
1202 }
1203 #endif
1204
1205 void SvxRTFParser::BuildWhichTbl()
1206 {
1207     if( aWhichMap.Count() )
1208         aWhichMap.Remove( 0, aWhichMap.Count() );
1209     aWhichMap.Insert( (USHORT)0, (USHORT)0 );
1210
1211     // Aufbau einer Which-Map 'rWhichMap' aus einem Array von
1212     // 'pWhichIds' von Which-Ids. Es hat die Lange 'nWhichIds'.
1213     // Die Which-Map wird nicht geloescht.
1214     SvParser::BuildWhichTbl( aWhichMap, (USHORT*)aPardMap.GetData(), aPardMap.Count() );
1215     SvParser::BuildWhichTbl( aWhichMap, (USHORT*)aPlainMap.GetData(), aPlainMap.Count() );
1216 }
1217
1218 const SfxItemSet& SvxRTFParser::GetRTFDefaults()
1219 {
1220     if( !pRTFDefaults )
1221     {
1222         pRTFDefaults = new SfxItemSet( *pAttrPool, aWhichMap.GetData() );
1223         USHORT nId;
1224         if( 0 != ( nId = ((RTFPardAttrMapIds*)aPardMap.GetData())->nScriptSpace ))
1225         {
1226             SvxScriptSpaceItem aItem( FALSE, nId );
1227             if( bNewDoc )
1228                 pAttrPool->SetPoolDefaultItem( aItem );
1229             else
1230                 pRTFDefaults->Put( aItem );
1231         }
1232     }
1233     return *pRTFDefaults;
1234 }
1235
1236 /*\f*/
1237
1238 SvxRTFStyleType::SvxRTFStyleType( SfxItemPool& rPool, const USHORT* pWhichRange )
1239     : aAttrSet( rPool, pWhichRange )
1240 {
1241     nOutlineNo = BYTE(-1);                      // nicht gesetzt
1242     nBasedOn = 0;
1243     bBasedOnIsSet = FALSE;          //$flr #117411#
1244     nNext = 0;
1245     bIsCharFmt = FALSE;
1246 }
1247
1248
1249 SvxRTFItemStackType::SvxRTFItemStackType(
1250         SfxItemPool& rPool, const USHORT* pWhichRange,
1251         const SvxPosition& rPos )
1252     : aAttrSet( rPool, pWhichRange ),
1253     pChildList( 0 ),
1254     nStyleNo( 0 )
1255 {
1256     pSttNd = rPos.MakeNodeIdx();
1257     nSttCnt = rPos.GetCntIdx();
1258     pEndNd = pSttNd;
1259     nEndCnt = nSttCnt;
1260 }
1261
1262 SvxRTFItemStackType::SvxRTFItemStackType(
1263         const SvxRTFItemStackType& rCpy,
1264         const SvxPosition& rPos,
1265         int bCopyAttr )
1266     : aAttrSet( *rCpy.aAttrSet.GetPool(), rCpy.aAttrSet.GetRanges() ),
1267     pChildList( 0 ),
1268     nStyleNo( rCpy.nStyleNo )
1269 {
1270     pSttNd = rPos.MakeNodeIdx();
1271     nSttCnt = rPos.GetCntIdx();
1272     pEndNd = pSttNd;
1273     nEndCnt = nSttCnt;
1274
1275     aAttrSet.SetParent( &rCpy.aAttrSet );
1276     if( bCopyAttr )
1277         aAttrSet.Put( rCpy.aAttrSet );
1278 }
1279
1280 SvxRTFItemStackType::~SvxRTFItemStackType()
1281 {
1282     if( pChildList )
1283         delete pChildList;
1284     if( pSttNd != pEndNd )
1285         delete pEndNd;
1286     delete pSttNd;
1287 }
1288
1289 void SvxRTFItemStackType::Add( SvxRTFItemStackType* pIns )
1290 {
1291     if( !pChildList )
1292          pChildList = new SvxRTFItemStackList( 4, 16 );
1293     pChildList->Insert( pIns, pChildList->Count() );
1294 }
1295
1296 #if 0
1297 //cmc: This is the original. nEndCnt is redundantly assigned to itself, and
1298 //pEndNd can leak if not equal to pSttNd.
1299 void SvxRTFItemStackType::SetStartPos( const SvxPosition& rPos )
1300 {
1301     delete pSttNd;
1302     pSttNd = rPos.MakeNodeIdx();
1303     nSttCnt = rPos.GetCntIdx();
1304     pEndNd = pSttNd;
1305     nEndCnt = nEndCnt;
1306 }
1307 #else
1308 void SvxRTFItemStackType::SetStartPos( const SvxPosition& rPos )
1309 {
1310     if (pSttNd != pEndNd)
1311         delete pEndNd;
1312     delete pSttNd;
1313     pSttNd = rPos.MakeNodeIdx();
1314     pEndNd = pSttNd;
1315     nSttCnt = rPos.GetCntIdx();
1316 }
1317 #endif
1318
1319 void SvxRTFItemStackType::MoveFullNode(const SvxNodeIdx &rOldNode,
1320     const SvxNodeIdx &rNewNode)
1321 {
1322     bool bSameEndAsStart = (pSttNd == pEndNd) ? true : false;
1323
1324     if (GetSttNodeIdx() == rOldNode.GetIdx())
1325     {
1326         delete pSttNd;
1327         pSttNd = rNewNode.Clone();
1328         if (bSameEndAsStart)
1329             pEndNd = pSttNd;
1330     }
1331
1332     if (!bSameEndAsStart && GetEndNodeIdx() == rOldNode.GetIdx())
1333     {
1334         delete pEndNd;
1335         pEndNd = rNewNode.Clone();
1336     }
1337
1338     //And the same for all the children
1339     USHORT nCount = pChildList ? pChildList->Count() : 0;
1340     for (USHORT i = 0; i < nCount; ++i)
1341     {
1342         SvxRTFItemStackType* pStk = (*pChildList)[i];
1343         pStk->MoveFullNode(rOldNode, rNewNode);
1344     }
1345 }
1346
1347 bool SvxRTFParser::UncompressableStackEntry(const SvxRTFItemStackType &) const
1348 {
1349     return false;
1350 }
1351
1352 void SvxRTFItemStackType::Compress( const SvxRTFParser& rParser )
1353 {
1354     DBG_ASSERT( pChildList, "es gibt keine ChildListe" );
1355
1356     USHORT n;
1357     SvxRTFItemStackType* pTmp = (*pChildList)[0];
1358
1359     if( !pTmp->aAttrSet.Count() ||
1360         pSttNd->GetIdx() != pTmp->pSttNd->GetIdx() ||
1361         nSttCnt != pTmp->nSttCnt )
1362         return;
1363
1364     SvxNodeIdx* pLastNd = pTmp->pEndNd;
1365     xub_StrLen nLastCnt = pTmp->nEndCnt;
1366
1367     SfxItemSet aMrgSet( pTmp->aAttrSet );
1368     for( n = 1; n < pChildList->Count(); ++n )
1369     {
1370         pTmp = (*pChildList)[n];
1371         if( pTmp->pChildList )
1372             pTmp->Compress( rParser );
1373
1374         if( !pTmp->nSttCnt
1375             ? (pLastNd->GetIdx()+1 != pTmp->pSttNd->GetIdx() ||
1376                !rParser.IsEndPara( pLastNd, nLastCnt ) )
1377             : ( pTmp->nSttCnt != nLastCnt ||
1378                 pLastNd->GetIdx() != pTmp->pSttNd->GetIdx() ))
1379         {
1380             while( ++n < pChildList->Count() )
1381                 if( (pTmp = (*pChildList)[n])->pChildList )
1382                     pTmp->Compress( rParser );
1383             return;
1384         }
1385
1386         if (rParser.UncompressableStackEntry(*pTmp))
1387             return;
1388
1389         if( n )
1390         {
1391             // suche alle, die ueber den gesamten Bereich gesetzt sind
1392             SfxItemIter aIter( aMrgSet );
1393             const SfxPoolItem* pItem;
1394             do {
1395                 USHORT nWhich = aIter.GetCurItem()->Which();
1396                 if( SFX_ITEM_SET != pTmp->aAttrSet.GetItemState( nWhich,
1397                       FALSE, &pItem ) || *pItem != *aIter.GetCurItem() )
1398                     aMrgSet.ClearItem( nWhich );
1399
1400                 if( aIter.IsAtEnd() )
1401                     break;
1402                 aIter.NextItem();
1403             } while( TRUE );
1404
1405             if( !aMrgSet.Count() )
1406                 return;
1407         }
1408
1409         pLastNd = pTmp->pEndNd;
1410         nLastCnt = pTmp->nEndCnt;
1411     }
1412
1413     if( pEndNd->GetIdx() != pLastNd->GetIdx() || nEndCnt != nLastCnt )
1414         return;
1415
1416     // es kann zusammengefasst werden
1417     aAttrSet.Put( aMrgSet );
1418
1419     for( n = 0; n < pChildList->Count(); ++n )
1420     {
1421         pTmp = (*pChildList)[n];
1422         pTmp->aAttrSet.Differentiate( aMrgSet );
1423
1424         if( !pTmp->pChildList && !pTmp->aAttrSet.Count() && !pTmp->nStyleNo )
1425         {
1426             pChildList->Remove( n );
1427             delete pTmp;
1428             --n;
1429             continue;
1430         }
1431     }
1432     if( !pChildList->Count() )
1433     {
1434         delete pChildList;
1435         pChildList = 0;
1436     }
1437 }
1438 void SvxRTFItemStackType::SetRTFDefaults( const SfxItemSet& rDefaults )
1439 {
1440     if( rDefaults.Count() )
1441     {
1442         SfxItemIter aIter( rDefaults );
1443         do {
1444             USHORT nWhich = aIter.GetCurItem()->Which();
1445             if( SFX_ITEM_SET != aAttrSet.GetItemState( nWhich, FALSE ))
1446                 aAttrSet.Put( *aIter.GetCurItem() );
1447
1448             if( aIter.IsAtEnd() )
1449                 break;
1450             aIter.NextItem();
1451         } while( TRUE );
1452     }
1453 }
1454
1455 /*\f*/
1456
1457 RTFPlainAttrMapIds::RTFPlainAttrMapIds( const SfxItemPool& rPool )
1458 {
1459     nCaseMap = rPool.GetTrueWhich( SID_ATTR_CHAR_CASEMAP, FALSE );
1460     nBgColor = rPool.GetTrueWhich( SID_ATTR_BRUSH_CHAR, FALSE );
1461     nColor = rPool.GetTrueWhich( SID_ATTR_CHAR_COLOR, FALSE );
1462     nContour = rPool.GetTrueWhich( SID_ATTR_CHAR_CONTOUR, FALSE );
1463     nCrossedOut = rPool.GetTrueWhich( SID_ATTR_CHAR_STRIKEOUT, FALSE );
1464     nEscapement = rPool.GetTrueWhich( SID_ATTR_CHAR_ESCAPEMENT, FALSE );
1465     nFont = rPool.GetTrueWhich( SID_ATTR_CHAR_FONT, FALSE );
1466     nFontHeight = rPool.GetTrueWhich( SID_ATTR_CHAR_FONTHEIGHT, FALSE );
1467     nKering = rPool.GetTrueWhich( SID_ATTR_CHAR_KERNING, FALSE );
1468     nLanguage = rPool.GetTrueWhich( SID_ATTR_CHAR_LANGUAGE, FALSE );
1469     nPosture = rPool.GetTrueWhich( SID_ATTR_CHAR_POSTURE, FALSE );
1470     nShadowed = rPool.GetTrueWhich( SID_ATTR_CHAR_SHADOWED, FALSE );
1471     nUnderline = rPool.GetTrueWhich( SID_ATTR_CHAR_UNDERLINE, FALSE );
1472     nOverline = rPool.GetTrueWhich( SID_ATTR_CHAR_OVERLINE, FALSE );
1473     nWeight = rPool.GetTrueWhich( SID_ATTR_CHAR_WEIGHT, FALSE );
1474     nWordlineMode = rPool.GetTrueWhich( SID_ATTR_CHAR_WORDLINEMODE, FALSE );
1475     nAutoKerning = rPool.GetTrueWhich( SID_ATTR_CHAR_AUTOKERN, FALSE );
1476
1477     nCJKFont = rPool.GetTrueWhich( SID_ATTR_CHAR_CJK_FONT, FALSE );
1478     nCJKFontHeight = rPool.GetTrueWhich( SID_ATTR_CHAR_CJK_FONTHEIGHT, FALSE );
1479     nCJKLanguage = rPool.GetTrueWhich( SID_ATTR_CHAR_CJK_LANGUAGE, FALSE );
1480     nCJKPosture = rPool.GetTrueWhich( SID_ATTR_CHAR_CJK_POSTURE, FALSE );
1481     nCJKWeight = rPool.GetTrueWhich( SID_ATTR_CHAR_CJK_WEIGHT, FALSE );
1482     nCTLFont = rPool.GetTrueWhich( SID_ATTR_CHAR_CTL_FONT, FALSE );
1483     nCTLFontHeight = rPool.GetTrueWhich( SID_ATTR_CHAR_CTL_FONTHEIGHT, FALSE );
1484     nCTLLanguage = rPool.GetTrueWhich( SID_ATTR_CHAR_CTL_LANGUAGE, FALSE );
1485     nCTLPosture = rPool.GetTrueWhich( SID_ATTR_CHAR_CTL_POSTURE, FALSE );
1486     nCTLWeight = rPool.GetTrueWhich( SID_ATTR_CHAR_CTL_WEIGHT, FALSE );
1487     nEmphasis = rPool.GetTrueWhich( SID_ATTR_CHAR_EMPHASISMARK, FALSE );
1488     nTwoLines = rPool.GetTrueWhich( SID_ATTR_CHAR_TWO_LINES, FALSE );
1489     nRuby = 0; //rPool.GetTrueWhich( SID_ATTR_CHAR_CJK_RUBY, FALSE );
1490     nCharScaleX = rPool.GetTrueWhich( SID_ATTR_CHAR_SCALEWIDTH, FALSE );
1491     nHorzVert = rPool.GetTrueWhich( SID_ATTR_CHAR_ROTATED, FALSE );
1492     nRelief = rPool.GetTrueWhich( SID_ATTR_CHAR_RELIEF, FALSE );
1493     nHidden = rPool.GetTrueWhich( SID_ATTR_CHAR_HIDDEN, FALSE );
1494 }
1495
1496 RTFPardAttrMapIds ::RTFPardAttrMapIds ( const SfxItemPool& rPool )
1497 {
1498     nLinespacing = rPool.GetTrueWhich( SID_ATTR_PARA_LINESPACE, FALSE );
1499     nAdjust = rPool.GetTrueWhich( SID_ATTR_PARA_ADJUST, FALSE );
1500     nTabStop = rPool.GetTrueWhich( SID_ATTR_TABSTOP, FALSE );
1501     nHyphenzone = rPool.GetTrueWhich( SID_ATTR_PARA_HYPHENZONE, FALSE );
1502     nLRSpace = rPool.GetTrueWhich( SID_ATTR_LRSPACE, FALSE );
1503     nULSpace = rPool.GetTrueWhich( SID_ATTR_ULSPACE, FALSE );
1504     nBrush = rPool.GetTrueWhich( SID_ATTR_BRUSH, FALSE );
1505     nBox = rPool.GetTrueWhich( SID_ATTR_BORDER_OUTER, FALSE );
1506     nShadow = rPool.GetTrueWhich( SID_ATTR_BORDER_SHADOW, FALSE );
1507     nOutlineLvl = rPool.GetTrueWhich( SID_ATTR_PARA_OUTLLEVEL, FALSE );
1508     nSplit = rPool.GetTrueWhich( SID_ATTR_PARA_SPLIT, FALSE );
1509     nKeep = rPool.GetTrueWhich( SID_ATTR_PARA_KEEP, FALSE );
1510     nFontAlign = rPool.GetTrueWhich( SID_PARA_VERTALIGN, FALSE );
1511     nScriptSpace = rPool.GetTrueWhich( SID_ATTR_PARA_SCRIPTSPACE, FALSE );
1512     nHangPunct = rPool.GetTrueWhich( SID_ATTR_PARA_HANGPUNCTUATION, FALSE );
1513     nForbRule = rPool.GetTrueWhich( SID_ATTR_PARA_FORBIDDEN_RULES, FALSE );
1514     nDirection = rPool.GetTrueWhich( SID_ATTR_FRAMEDIRECTION, FALSE );
1515 }
1516
1517 /* vi:set tabstop=4 shiftwidth=4 expandtab: */