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