svx/source/editeng/editobj.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: editobj.cxx,v $
  10  * $Revision: 1.30 $
  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
  35 #include <eeng_pch.hxx>
  36
  37 #define ENABLE_STRING_STREAM_OPERATORS
  38 #include <tools/stream.hxx>
  39
  40 #include <editobj2.hxx>
  41 #include <svx/editdata.hxx>
  42 #include <editattr.hxx>
  43 #include <svx/editeng.hxx>
  44 #include <fontitem.hxx>
  45 #include <svx/cscoitem.hxx>
  46 #include <svx/flditem.hxx>
  47 #include <svx/lrspitem.hxx>
  48 #include <svx/tstpitem.hxx>
  49 #include <bulitem.hxx>
  50 #include <svx/numitem.hxx>
  51 #include <svx/brshitem.hxx>
  52 #include <vcl/graph.hxx>
  53 #include <svtools/intitem.hxx>
  54 #include <vcl/fontcvt.hxx>
  55 #include <tools/tenccvt.hxx>
  56
  57 DBG_NAME( EE_EditTextObject )
  58 DBG_NAME( XEditAttribute )
  59
  60 //--------------------------------------------------------------
  61
  62 BOOL lcl_CreateBulletItem( const SvxNumBulletItem& rNumBullet, USHORT nLevel, SvxBulletItem& rBullet )
  63 {
  64     const SvxNumberFormat* pFmt = rNumBullet.GetNumRule()->Get( nLevel );
  65     if ( pFmt )
  66     {
  67         rBullet.SetWidth( (-pFmt->GetFirstLineOffset()) + pFmt->GetCharTextDistance() );
  68         rBullet.SetSymbol( pFmt->GetBulletChar() );
  69         rBullet.SetPrevText( pFmt->GetPrefix() );
  70         rBullet.SetFollowText( pFmt->GetSuffix() );
  71         rBullet.SetStart( pFmt->GetStart() );
  72         rBullet.SetScale( pFmt->GetBulletRelSize() );
  73
  74         Font aBulletFont( rBullet.GetFont() );
  75         if ( pFmt->GetBulletFont() )
  76             aBulletFont = *pFmt->GetBulletFont();
  77         aBulletFont.SetColor( pFmt->GetBulletColor() );
  78         rBullet.SetFont( aBulletFont );
  79
  80         if ( pFmt->GetBrush() && pFmt->GetBrush()->GetGraphic() )
  81         {
  82             Bitmap aBmp( pFmt->GetBrush()->GetGraphic()->GetBitmap() );
  83             aBmp.SetPrefSize( pFmt->GetGraphicSize() );
  84             aBmp.SetPrefMapMode( MAP_100TH_MM );
  85             rBullet.SetBitmap( aBmp );
  86         }
  87
  88         switch ( pFmt->GetNumberingType() )
  89         {
  90             case SVX_NUM_CHARS_UPPER_LETTER:
  91             case SVX_NUM_CHARS_UPPER_LETTER_N:
  92                 rBullet.SetStyle( BS_ABC_BIG );
  93                 break;
  94             case SVX_NUM_CHARS_LOWER_LETTER:
  95             case SVX_NUM_CHARS_LOWER_LETTER_N:
  96                 rBullet.SetStyle( BS_ABC_SMALL );
  97                 break;
  98             case SVX_NUM_ROMAN_UPPER:
  99                 rBullet.SetStyle( BS_ROMAN_BIG );
 100                 break;
 101             case SVX_NUM_ROMAN_LOWER:
 102                 rBullet.SetStyle( BS_ROMAN_SMALL );
 103                 break;
 104             case SVX_NUM_ARABIC:
 105                 rBullet.SetStyle( BS_123 );
 106                 break;
 107             case SVX_NUM_NUMBER_NONE:
 108                 rBullet.SetStyle( BS_NONE );
 109                 break;
 110             case SVX_NUM_CHAR_SPECIAL:
 111                 rBullet.SetStyle( BS_BULLET );
 112                 break;
 113             case SVX_NUM_PAGEDESC:
 114                 DBG_ERROR( "Unknown: SVX_NUM_PAGEDESC" );
 115                 rBullet.SetStyle( BS_BULLET );
 116                 break;
 117             case SVX_NUM_BITMAP:
 118                 rBullet.SetStyle( BS_BMP );
 119                 break;
 120             default:
 121                 DBG_ERROR( "Unknown NumType" );
 122         }
 123
 124         switch ( pFmt->GetNumAdjust() )
 125         {
 126             case SVX_ADJUST_LEFT:
 127                 rBullet.SetJustification( BJ_VCENTER|BJ_HLEFT );
 128                 break;
 129             case SVX_ADJUST_RIGHT:
 130                 rBullet.SetJustification( BJ_VCENTER|BJ_HRIGHT );
 131                 break;
 132             case SVX_ADJUST_CENTER:
 133                 rBullet.SetJustification( BJ_VCENTER|BJ_HCENTER );
 134                 break;
 135             default:
 136                 DBG_ERROR( "Unknown or invalid NumAdjust" );
 137         }
 138     }
 139     return pFmt ? TRUE : FALSE;
 140 }
 141
 142
 143 XEditAttribute* MakeXEditAttribute( SfxItemPool& rPool, const SfxPoolItem& rItem, USHORT nStart, USHORT nEnd )
 144 {
 145     // das neue Attribut im Pool anlegen
 146     const SfxPoolItem& rNew = rPool.Put( rItem );
 147
 148     XEditAttribute* pNew = new XEditAttribute( rNew, nStart, nEnd );
 149     return pNew;
 150 }
 151
 152
 153 XEditAttribute::XEditAttribute( const SfxPoolItem& rAttr )
 154 {
 155     DBG_CTOR( XEditAttribute, 0 );
 156     pItem = &rAttr;
 157     nStart = 0;
 158     nEnd = 0;
 159 }
 160
 161 XEditAttribute::XEditAttribute( const SfxPoolItem& rAttr, USHORT nS, USHORT nE )
 162 {
 163     DBG_CTOR( XEditAttribute, 0 );
 164     pItem = &rAttr;
 165     nStart = nS;
 166     nEnd = nE;
 167 }
 168
 169 XEditAttribute::~XEditAttribute()
 170 {
 171     DBG_DTOR( XEditAttribute, 0 );
 172     pItem = 0;  // Gehoert dem Pool.
 173 }
 174
 175 XEditAttribute* XEditAttributeList::FindAttrib( USHORT _nWhich, USHORT nChar ) const
 176 {
 177     for ( USHORT n = Count(); n; )
 178     {
 179         XEditAttribute* pAttr = GetObject( --n );
 180         if( ( pAttr->GetItem()->Which() == _nWhich ) && ( pAttr->GetStart() <= nChar ) && ( pAttr->GetEnd() > nChar ) )
 181             return pAttr;
 182     }
 183     return NULL;
 184 }
 185
 186 ContentInfo::ContentInfo( SfxItemPool& rPool ) : aParaAttribs( rPool, EE_PARA_START, EE_CHAR_END )
 187 {
 188     eFamily = SFX_STYLE_FAMILY_PARA;
 189     pWrongs = NULL;
 190 /* cl removed because not needed anymore since binfilter
 191     pTempLoadStoreInfos = NULL;
 192 */
 193 }
 194
 195 // Richtiger CopyCTOR unsinning, weil ich mit einem anderen Pool arbeiten muss!
 196 ContentInfo::ContentInfo( const ContentInfo& rCopyFrom, SfxItemPool& rPoolToUse )
 197     : aParaAttribs( rPoolToUse, EE_PARA_START, EE_CHAR_END )
 198 {
 199     pWrongs = NULL;
 200 /* cl removed because not needed anymore since binfilter
 201     pTempLoadStoreInfos = NULL;
 202 */
 203     if ( rCopyFrom.GetWrongList() )
 204         pWrongs = rCopyFrom.GetWrongList()->Clone();
 205     // So sollten die Items im richtigen Pool landen!
 206     aParaAttribs.Set( rCopyFrom.GetParaAttribs() );
 207     aText = rCopyFrom.GetText();
 208     aStyle = rCopyFrom.GetStyle();
 209     eFamily = rCopyFrom.GetFamily();
 210
 211     // Attribute kopieren...
 212     for ( USHORT n = 0; n < rCopyFrom.GetAttribs().Count(); n++  )
 213     {
 214         XEditAttribute* pAttr = rCopyFrom.GetAttribs().GetObject( n );
 215         XEditAttribute* pMyAttr = MakeXEditAttribute( rPoolToUse, *pAttr->GetItem(), pAttr->GetStart(), pAttr->GetEnd() );
 216         aAttribs.Insert( pMyAttr, aAttribs.Count()  );
 217     }
 218
 219     // Wrongs
 220     pWrongs = NULL;
 221 #ifndef SVX_LIGHT
 222     if ( rCopyFrom.GetWrongList() )
 223         pWrongs = rCopyFrom.GetWrongList()->Clone();
 224 #endif // !SVX_LIGHT
 225 }
 226
 227 ContentInfo::~ContentInfo()
 228 {
 229     for ( USHORT nAttr = 0; nAttr < aAttribs.Count(); nAttr++ )
 230     {
 231         XEditAttribute* pAttr = aAttribs.GetObject(nAttr);
 232         // Item aus Pool entfernen!
 233         aParaAttribs.GetPool()->Remove( *pAttr->GetItem() );
 234         delete pAttr;
 235     }
 236     aAttribs.Remove( 0, aAttribs.Count() );
 237 #ifndef SVX_LIGHT
 238     delete pWrongs;
 239 #endif
 240 }
 241
 242 /* cl removed because not needed anymore since binfilter
 243 void ContentInfo::CreateLoadStoreTempInfos()
 244 {
 245     delete pTempLoadStoreInfos;
 246     pTempLoadStoreInfos = new LoadStoreTempInfos;
 247 }
 248
 249 void ContentInfo::DestroyLoadStoreTempInfos()
 250 {
 251     delete pTempLoadStoreInfos;
 252     pTempLoadStoreInfos = NULL;
 253 }
 254 */
 255
 256 // #i102062#
 257 bool ContentInfo::isWrongListEqual(const ContentInfo& rCompare) const
 258 {
 259     if(GetWrongList() == rCompare.GetWrongList())
 260         return true;
 261
 262     if(!GetWrongList() || !rCompare.GetWrongList())
 263         return false;
 264
 265     return (*GetWrongList() == *rCompare.GetWrongList());
 266 }
 267
 268 bool ContentInfo::operator==( const ContentInfo& rCompare ) const
 269 {
 270     if( (aText == rCompare.aText) &&
 271             (aStyle == rCompare.aStyle ) &&
 272             (aAttribs.Count() == rCompare.aAttribs.Count() ) &&
 273             (eFamily == rCompare.eFamily ) &&
 274             (aParaAttribs == rCompare.aParaAttribs ) )
 275     {
 276         const USHORT nCount = aAttribs.Count();
 277         if( nCount == rCompare.aAttribs.Count() )
 278         {
 279             USHORT n;
 280             for( n = 0; n < nCount; n++ )
 281             {
 282                 if( !(*aAttribs.GetObject(n) == *rCompare.aAttribs.GetObject(n)) )
 283                     return false;
 284             }
 285
 286             return true;
 287         }
 288     }
 289
 290     return false;
 291 }
 292
 293 EditTextObject::EditTextObject( USHORT n)
 294 {
 295     DBG_CTOR( EE_EditTextObject, 0 );
 296     nWhich = n;
 297 }
 298
 299 EditTextObject::EditTextObject( const EditTextObject& r )
 300 {
 301     DBG_CTOR( EE_EditTextObject, 0 );
 302     nWhich = r.nWhich;
 303 }
 304
 305 __EXPORT EditTextObject::~EditTextObject()
 306 {
 307     DBG_DTOR( EE_EditTextObject, 0 );
 308 }
 309
 310 USHORT EditTextObject::GetParagraphCount() const
 311 {
 312     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 313     return 0;
 314 }
 315
 316 XubString EditTextObject::GetText( USHORT /* nParagraph */ ) const
 317 {
 318     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 319     return XubString();
 320 }
 321
 322 void EditTextObject::Insert( const EditTextObject& /* rObj */, USHORT /* nPara */)
 323 {
 324     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 325 }
 326
 327 EditTextObject* EditTextObject::CreateTextObject( USHORT /*nPara*/, USHORT /*nParas*/ ) const
 328 {
 329     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 330     return 0;
 331 }
 332
 333 void EditTextObject::RemoveParagraph( USHORT /*nPara*/ )
 334 {
 335     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 336 }
 337
 338 BOOL EditTextObject::HasPortionInfo() const
 339 {
 340     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 341     return FALSE;
 342 }
 343
 344 void EditTextObject::ClearPortionInfo()
 345 {
 346     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 347 }
 348
 349 BOOL EditTextObject::HasOnlineSpellErrors() const
 350 {
 351     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 352     return FALSE;
 353 }
 354
 355 BOOL EditTextObject::HasCharAttribs( USHORT ) const
 356 {
 357     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 358     return FALSE;
 359 }
 360
 361 void EditTextObject::GetCharAttribs( USHORT /*nPara*/, EECharAttribArray& /*rLst*/ ) const
 362 {
 363     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 364 }
 365
 366 void EditTextObject::MergeParaAttribs( const SfxItemSet& /*rAttribs*/, USHORT /*nStart*/, USHORT /*nEnd*/ )
 367 {
 368     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 369 }
 370
 371 BOOL EditTextObject::IsFieldObject() const
 372 {
 373     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 374     return FALSE;
 375 }
 376
 377 const SvxFieldItem* EditTextObject::GetField() const
 378 {
 379     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 380     return 0;
 381 }
 382
 383 BOOL EditTextObject::HasField( TypeId /*aType*/ ) const
 384 {
 385     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 386     return FALSE;
 387 }
 388
 389 SfxItemSet EditTextObject::GetParaAttribs( USHORT /*nPara*/ ) const
 390 {
 391     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 392     return SfxItemSet( *(SfxItemPool*)NULL );
 393 }
 394
 395 void EditTextObject::SetParaAttribs( USHORT /*nPara*/, const SfxItemSet& /*rAttribs*/ )
 396 {
 397     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 398 }
 399
 400 BOOL EditTextObject::RemoveCharAttribs( USHORT /*nWhich*/ )
 401 {
 402     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 403     return FALSE;
 404 }
 405
 406 BOOL EditTextObject::RemoveParaAttribs( USHORT /*nWhich*/ )
 407 {
 408     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 409     return FALSE;
 410 }
 411
 412 BOOL EditTextObject::HasStyleSheet( const XubString& /*rName*/, SfxStyleFamily /*eFamily*/ ) const
 413 {
 414     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 415     return FALSE;
 416 }
 417
 418 void EditTextObject::GetStyleSheet( USHORT /*nPara*/, XubString& /*rName*/, SfxStyleFamily& /*eFamily*/ ) const
 419 {
 420     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 421 }
 422
 423 void EditTextObject::SetStyleSheet( USHORT /*nPara*/, const XubString& /*rName*/, const SfxStyleFamily& /*eFamily*/ )
 424 {
 425     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 426 }
 427
 428 BOOL __EXPORT EditTextObject::ChangeStyleSheets( const XubString&, SfxStyleFamily,
 429                                             const XubString&, SfxStyleFamily )
 430 {
 431     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 432     return FALSE;
 433 }
 434
 435 void __EXPORT EditTextObject::ChangeStyleSheetName( SfxStyleFamily /*eFamily*/,
 436                 const XubString& /*rOldName*/, const XubString& /*rNewName*/ )
 437 {
 438     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 439 }
 440
 441 USHORT EditTextObject::GetUserType() const
 442 {
 443     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 444     return 0;
 445 }
 446
 447 void EditTextObject::SetUserType( USHORT )
 448 {
 449     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 450 }
 451
 452 ULONG EditTextObject::GetObjectSettings() const
 453 {
 454     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 455     return 0;
 456 }
 457
 458 void EditTextObject::SetObjectSettings( ULONG )
 459 {
 460     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 461 }
 462
 463 BOOL EditTextObject::IsVertical() const
 464 {
 465     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 466     return FALSE;
 467 }
 468
 469 void EditTextObject::SetVertical( BOOL bVertical )
 470 {
 471     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 472     ((BinTextObject*)this)->SetVertical( bVertical );
 473 }
 474
 475 USHORT EditTextObject::GetScriptType() const
 476 {
 477     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 478     return ((const BinTextObject*)this)->GetScriptType();
 479 }
 480
 481
 482 BOOL EditTextObject::Store( SvStream& rOStream ) const
 483 {
 484     if ( rOStream.GetError() )
 485         return FALSE;
 486
 487     // Vorspann:
 488     sal_Size nStartPos = rOStream.Tell();
 489
 490     rOStream << (USHORT)Which();
 491
 492     sal_uInt32 nStructSz = 0;
 493     rOStream << nStructSz;
 494
 495     // Eigene Daten:
 496     StoreData( rOStream );
 497
 498     // Nachspann:
 499     sal_Size nEndPos = rOStream.Tell();
 500     nStructSz = nEndPos - nStartPos - sizeof( nWhich ) - sizeof( nStructSz );
 501     rOStream.Seek( nStartPos + sizeof( nWhich ) );
 502     rOStream << nStructSz;
 503     rOStream.Seek( nEndPos );
 504
 505     return rOStream.GetError() ? FALSE : TRUE;
 506 }
 507
 508 EditTextObject* EditTextObject::Create( SvStream& rIStream, SfxItemPool* pGlobalTextObjectPool )
 509 {
 510     ULONG nStartPos = rIStream.Tell();
 511
 512     // Ertmal sehen, was fuer ein Object...
 513     USHORT nWhich;
 514     rIStream >> nWhich;
 515
 516     sal_uInt32 nStructSz;
 517     rIStream >> nStructSz;
 518
 519     DBG_ASSERT( ( nWhich == 0x22 /*EE_FORMAT_BIN300*/ ) || ( nWhich == EE_FORMAT_BIN ), "CreateTextObject: Unbekanntes Objekt!" );
 520
 521     if ( rIStream.GetError() )
 522         return NULL;
 523
 524     EditTextObject* pTxtObj = NULL;
 525     switch ( nWhich )
 526     {
 527         case 0x22 /*BIN300*/:           pTxtObj = new BinTextObject( 0 );
 528                                     ((BinTextObject*)pTxtObj)->CreateData300( rIStream );
 529                                     break;
 530         case EE_FORMAT_BIN:                     pTxtObj = new BinTextObject( pGlobalTextObjectPool );
 531                                     pTxtObj->CreateData( rIStream );
 532                                     break;
 533         default:
 534         {
 535             // Wenn ich das Format nicht kenne, ueberlese ich den Inhalt:
 536             rIStream.SetError( EE_READWRITE_WRONGFORMAT );
 537         }
 538     }
 539
 540     // Sicherstellen, dass der Stream an der richtigen Stelle hinterlassen wird.
 541     sal_Size nFullSz = sizeof( nWhich ) + sizeof( nStructSz ) + nStructSz;
 542     rIStream.Seek( nStartPos + nFullSz );
 543     return pTxtObj;
 544 }
 545
 546 void EditTextObject::Skip( SvStream& rIStream )
 547 {
 548     sal_Size nStartPos = rIStream.Tell();
 549
 550     USHORT _nWhich;
 551     rIStream >> _nWhich;
 552
 553     sal_uInt32 nStructSz;
 554     rIStream >> nStructSz;
 555
 556     sal_Size nFullSz = sizeof( _nWhich ) + sizeof( nStructSz ) + nStructSz;
 557     rIStream.Seek( nStartPos + nFullSz );
 558 }
 559
 560 void __EXPORT EditTextObject::StoreData( SvStream& ) const
 561 {
 562     DBG_ERROR( "StoreData: Basisklasse!" );
 563 }
 564
 565 void __EXPORT EditTextObject::CreateData( SvStream& )
 566 {
 567     DBG_ERROR( "CreateData: Basisklasse!" );
 568 }
 569
 570 USHORT EditTextObject::GetVersion() const
 571 {
 572     DBG_ERROR( "V-Methode direkt vom EditTextObject!" );
 573     return 0;
 574 }
 575
 576 bool EditTextObject::operator==( const EditTextObject& rCompare ) const
 577 {
 578     return static_cast< const BinTextObject* >( this )->operator==( static_cast< const BinTextObject& >( rCompare ) );
 579 }
 580
 581 // #i102062#
 582 bool EditTextObject::isWrongListEqual(const EditTextObject& rCompare) const
 583 {
 584     return static_cast< const BinTextObject* >(this)->isWrongListEqual(static_cast< const BinTextObject& >(rCompare));
 585 }
 586
 587 // from SfxItemPoolUser
 588 void BinTextObject::ObjectInDestruction(const SfxItemPool& rSfxItemPool)
 589 {
 590     if(!bOwnerOfPool && pPool && pPool == &rSfxItemPool)
 591     {
 592         // The pool we are based on gets destructed; get owner of pool by creating own one.
 593         // No need to call RemoveSfxItemPoolUser(), this is done from the pool's destructor
 594         // Base new pool on EditEnginePool; it would also be possible to clone the used
 595         // pool if needed, but only text attributes should be used.
 596         SfxItemPool* pNewPool = EditEngine::CreatePool();
 597
 598         if(pPool)
 599         {
 600             pNewPool->SetDefaultMetric(pPool->GetMetric(DEF_METRIC));
 601         }
 602
 603         for(sal_uInt16 n(0); n < aContents.Count(); n++)
 604         {
 605             // clone ContentInfos for new pool
 606             ContentInfo* pOrg = aContents.GetObject(n);
 607             DBG_ASSERT(pOrg, "NULL-Pointer in ContentList!");
 608
 609             ContentInfo* pNew = new ContentInfo(*pOrg, *pNewPool);
 610             aContents.Replace(pNew, n);
 611             delete pOrg;
 612         }
 613
 614         // set local variables
 615         pPool = pNewPool;
 616         bOwnerOfPool = TRUE;
 617     }
 618 }
 619
 620 EditEngineItemPool* getEditEngineItemPool(SfxItemPool* pPool)
 621 {
 622     EditEngineItemPool* pRetval = dynamic_cast< EditEngineItemPool* >(pPool);
 623
 624     while(!pRetval && pPool && pPool->GetSecondaryPool())
 625     {
 626         pPool = pPool->GetSecondaryPool();
 627
 628         if(pPool)
 629         {
 630             pRetval = dynamic_cast< EditEngineItemPool* >(pPool);
 631         }
 632     }
 633
 634     return pRetval;
 635 }
 636
 637 BinTextObject::BinTextObject( SfxItemPool* pP ) :
 638     EditTextObject( EE_FORMAT_BIN ),
 639     SfxItemPoolUser()
 640 {
 641     nVersion = 0;
 642     nMetric = 0xFFFF;
 643     nUserType = 0;
 644     nObjSettings = 0;
 645     pPortionInfo = 0;
 646
 647     // #i101239# ensure target is a EditEngineItemPool, else
 648     // fallback to pool ownership. This is needed to ensure that at
 649     // pool destruction time of an alien pool, the pool is still alive.
 650     // When registering would happen at an alien pool which just uses an
 651     // EditEngineItemPool as some sub-pool, that pool could already
 652     // be decoupled and deleted whcih would lead to crashes.
 653     pPool =     getEditEngineItemPool(pP);
 654
 655     if ( pPool )
 656     {
 657         bOwnerOfPool = FALSE;
 658     }
 659     else
 660     {
 661         pPool = EditEngine::CreatePool();
 662         bOwnerOfPool =  TRUE;
 663     }
 664
 665     if(!bOwnerOfPool && pPool)
 666     {
 667         // it is sure now that the pool is an EditEngineItemPool
 668         pPool->AddSfxItemPoolUser(*this);
 669     }
 670
 671     bVertical = FALSE;
 672     bStoreUnicodeStrings = FALSE;
 673     nScriptType = 0;
 674 }
 675
 676 BinTextObject::BinTextObject( const BinTextObject& r ) :
 677     EditTextObject( r ),
 678     SfxItemPoolUser()
 679 {
 680     nVersion = r.nVersion;
 681     nMetric = r.nMetric;
 682     nUserType = r.nUserType;
 683     nObjSettings = r.nObjSettings;
 684     bVertical = r.bVertical;
 685     nScriptType = r.nScriptType;
 686     pPortionInfo = NULL;        // PortionInfo nicht kopieren
 687     bStoreUnicodeStrings = FALSE;
 688
 689     if ( !r.bOwnerOfPool )
 690     {
 691         // reuse alien pool; this must be a EditEngineItemPool
 692         // since there is no other way to construct a BinTextObject
 693         // than it's regular constructor where that is ensured
 694         pPool = r.pPool;
 695         bOwnerOfPool = FALSE;
 696     }
 697     else
 698     {
 699         pPool = EditEngine::CreatePool();
 700         bOwnerOfPool =  TRUE;
 701
 702     }
 703
 704     if(!bOwnerOfPool && pPool)
 705     {
 706         // it is sure now that the pool is an EditEngineItemPool
 707         pPool->AddSfxItemPoolUser(*this);
 708     }
 709
 710     if ( bOwnerOfPool && pPool && r.pPool )
 711         pPool->SetDefaultMetric( r.pPool->GetMetric( DEF_METRIC ) );
 712
 713     for ( USHORT n = 0; n < r.aContents.Count(); n++ )
 714     {
 715         ContentInfo* pOrg = r.aContents.GetObject( n );
 716         DBG_ASSERT( pOrg, "NULL-Pointer in ContentList!" );
 717         ContentInfo* pNew = new ContentInfo( *pOrg, *pPool );
 718         aContents.Insert( pNew, aContents.Count() );
 719     }
 720 }
 721
 722 __EXPORT BinTextObject::~BinTextObject()
 723 {
 724     if(!bOwnerOfPool && pPool)
 725     {
 726         pPool->RemoveSfxItemPoolUser(*this);
 727     }
 728
 729     ClearPortionInfo();
 730     DeleteContents();
 731     if ( bOwnerOfPool )
 732     {
 733         // Nicht mehr, wegen 1xDefItems.
 734         // siehe auch ~EditDoc().
 735 //              pPool->ReleaseDefaults( TRUE /* bDelete */ );
 736         SfxItemPool::Free(pPool);
 737     }
 738 }
 739
 740 USHORT BinTextObject::GetUserType() const
 741 {
 742     return nUserType;
 743 }
 744
 745 void BinTextObject::SetUserType( USHORT n )
 746 {
 747     nUserType = n;
 748 }
 749
 750 ULONG BinTextObject::GetObjectSettings() const
 751 {
 752     return nObjSettings;
 753 }
 754
 755 void BinTextObject::SetObjectSettings( ULONG n )
 756 {
 757     nObjSettings = n;
 758 }
 759
 760 BOOL BinTextObject::IsVertical() const
 761 {
 762     return bVertical;
 763 }
 764
 765 void BinTextObject::SetVertical( BOOL b )
 766 {
 767     if ( b != bVertical )
 768     {
 769         bVertical = b;
 770         ClearPortionInfo();
 771     }
 772 }
 773
 774 USHORT BinTextObject::GetScriptType() const
 775 {
 776     return nScriptType;
 777 }
 778
 779 void BinTextObject::SetScriptType( USHORT nType )
 780 {
 781     nScriptType = nType;
 782 }
 783
 784
 785 void BinTextObject::DeleteContents()
 786 {
 787     for ( USHORT n = 0; n < aContents.Count(); n++ )
 788     {
 789         ContentInfo* p = aContents.GetObject( n );
 790         DBG_ASSERT( p, "NULL-Pointer in ContentList!" );
 791         delete p;
 792     }
 793     aContents.Remove( 0, aContents.Count() );
 794 }
 795
 796 EditTextObject* __EXPORT BinTextObject::Clone() const
 797 {
 798     return new BinTextObject( *this );
 799 }
 800
 801 XEditAttribute* BinTextObject::CreateAttrib( const SfxPoolItem& rItem, USHORT nStart, USHORT nEnd )
 802 {
 803     return MakeXEditAttribute( *pPool, rItem, nStart, nEnd );
 804 }
 805
 806 void BinTextObject::DestroyAttrib( XEditAttribute* pAttr )
 807 {
 808     pPool->Remove( *pAttr->GetItem() );
 809     delete pAttr;
 810 }
 811
 812 ContentInfo* BinTextObject::CreateAndInsertContent()
 813 {
 814     ContentInfo* pC = new ContentInfo( *pPool );
 815     aContents.Insert( pC, aContents.Count() );
 816     return pC;
 817 }
 818
 819 USHORT BinTextObject::GetParagraphCount() const
 820 {
 821     return aContents.Count();
 822 }
 823
 824 XubString BinTextObject::GetText( USHORT nPara ) const
 825 {
 826     DBG_ASSERT( nPara < aContents.Count(), "BinTextObject::GetText: Absatz existiert nicht!" );
 827     if ( nPara < aContents.Count() )
 828     {
 829         ContentInfo* pC = aContents[ nPara ];
 830         return pC->GetText();
 831     }
 832     return XubString();
 833 }
 834
 835 void BinTextObject::Insert( const EditTextObject& rObj, USHORT nDestPara )
 836 {
 837     DBG_ASSERT( rObj.Which() == EE_FORMAT_BIN, "UTO: Unbekanntes Textobjekt" );
 838
 839     const BinTextObject& rBinObj = (const BinTextObject&)rObj;
 840
 841     if ( nDestPara > aContents.Count() )
 842         nDestPara = aContents.Count();
 843
 844     const USHORT nParas = rBinObj.GetContents().Count();
 845     for ( USHORT nP = 0; nP < nParas; nP++ )
 846     {
 847         ContentInfo* pC = rBinObj.GetContents()[ nP ];
 848         ContentInfo* pNew = new ContentInfo( *pC, *GetPool() );
 849         aContents.Insert( pNew, nDestPara+nP );
 850     }
 851     ClearPortionInfo();
 852 }
 853
 854 EditTextObject* BinTextObject::CreateTextObject( USHORT nPara, USHORT nParas ) const
 855 {
 856     if ( ( nPara >= aContents.Count() ) || !nParas )
 857         return NULL;
 858
 859     // Pool nur teilen, wenn von aussen eingestellter Pool.
 860     BinTextObject* pObj = new BinTextObject( bOwnerOfPool ? 0 : pPool );
 861     if ( bOwnerOfPool && pPool )
 862         pObj->GetPool()->SetDefaultMetric( pPool->GetMetric( DEF_METRIC ) );
 863
 864     // If complete text is only one ScriptType, this is valid.
 865     // If text contains different ScriptTypes, this shouldn't be a problem...
 866     pObj->nScriptType = nScriptType;
 867
 868     const USHORT nEndPara = nPara+nParas-1;
 869     for ( USHORT nP = nPara; nP <= nEndPara; nP++ )
 870     {
 871         ContentInfo* pC = aContents[ nP ];
 872         ContentInfo* pNew = new ContentInfo( *pC, *pObj->GetPool() );
 873         pObj->GetContents().Insert( pNew, pObj->GetContents().Count() );
 874     }
 875     return pObj;
 876 }
 877
 878 void BinTextObject::RemoveParagraph( USHORT nPara )
 879 {
 880     DBG_ASSERT( nPara < aContents.Count(), "BinTextObject::GetText: Absatz existiert nicht!" );
 881     if ( nPara < aContents.Count() )
 882     {
 883         ContentInfo* pC = aContents[ nPara ];
 884         aContents.Remove( nPara );
 885         delete pC;
 886         ClearPortionInfo();
 887     }
 888 }
 889
 890 BOOL BinTextObject::HasPortionInfo() const
 891 {
 892     return pPortionInfo ? TRUE : FALSE;
 893 }
 894
 895 void BinTextObject::ClearPortionInfo()
 896 {
 897     if ( pPortionInfo )
 898     {
 899         for ( USHORT n = pPortionInfo->Count(); n; )
 900             delete pPortionInfo->GetObject( --n );
 901         delete pPortionInfo;
 902         pPortionInfo = NULL;
 903     }
 904 }
 905
 906 BOOL BinTextObject::HasOnlineSpellErrors() const
 907 {
 908 #ifndef SVX_LIGHT
 909     for ( USHORT n = 0; n < aContents.Count(); n++ )
 910     {
 911         ContentInfo* p = aContents.GetObject( n );
 912         if ( p->GetWrongList() && p->GetWrongList()->Count() )
 913             return TRUE;
 914     }
 915 #endif // !SVX_LIGHT
 916     return FALSE;
 917
 918 }
 919
 920 BOOL BinTextObject::HasCharAttribs( USHORT _nWhich ) const
 921 {
 922     for ( USHORT nPara = GetContents().Count(); nPara; )
 923     {
 924         ContentInfo* pC = GetContents().GetObject( --nPara );
 925
 926         USHORT nAttribs = pC->GetAttribs().Count();
 927         if ( nAttribs && !_nWhich )
 928             return TRUE;
 929
 930         for ( USHORT nAttr = nAttribs; nAttr; )
 931         {
 932             XEditAttribute* pX = pC->GetAttribs().GetObject( --nAttr );
 933             if ( pX->GetItem()->Which() == _nWhich )
 934                 return TRUE;
 935         }
 936     }
 937     return FALSE;
 938 }
 939
 940 void BinTextObject::GetCharAttribs( USHORT nPara, EECharAttribArray& rLst ) const
 941 {
 942     rLst.Remove( 0, rLst.Count() );
 943     ContentInfo* pC = GetContents().GetObject( nPara );
 944     if ( pC )
 945     {
 946         for ( USHORT nAttr = 0; nAttr < pC->GetAttribs().Count(); nAttr++ )
 947         {
 948             XEditAttribute* pAttr = pC->GetAttribs().GetObject( nAttr );
 949             EECharAttrib aEEAttr;
 950             aEEAttr.pAttr = pAttr->GetItem();
 951             aEEAttr.nPara = nPara;
 952             aEEAttr.nStart = pAttr->GetStart();
 953             aEEAttr.nEnd = pAttr->GetEnd();
 954             rLst.Insert( aEEAttr, rLst.Count() );
 955         }
 956     }
 957 }
 958
 959 void BinTextObject::MergeParaAttribs( const SfxItemSet& rAttribs, USHORT nStart, USHORT nEnd )
 960 {
 961     BOOL bChanged = FALSE;
 962
 963     for ( USHORT nPara = GetContents().Count(); nPara; )
 964     {
 965         ContentInfo* pC = GetContents().GetObject( --nPara );
 966
 967         for ( USHORT nW = nStart; nW <= nEnd; nW++ )
 968         {
 969             if ( ( pC->GetParaAttribs().GetItemState( nW, FALSE ) != SFX_ITEM_ON )
 970                     && ( rAttribs.GetItemState( nW, FALSE ) == SFX_ITEM_ON ) )
 971             {
 972                 pC->GetParaAttribs().Put( rAttribs.Get( nW ) );
 973                 bChanged = TRUE;
 974             }
 975         }
 976     }
 977
 978     if ( bChanged )
 979         ClearPortionInfo();
 980 }
 981
 982 BOOL BinTextObject::IsFieldObject() const
 983 {
 984     return BinTextObject::GetField() ? TRUE : FALSE;
 985 }
 986
 987 const SvxFieldItem* BinTextObject::GetField() const
 988 {
 989     if ( GetContents().Count() == 1 )
 990     {
 991         ContentInfo* pC = GetContents()[0];
 992         if ( pC->GetText().Len() == 1 )
 993         {
 994             USHORT nAttribs = pC->GetAttribs().Count();
 995             for ( USHORT nAttr = nAttribs; nAttr; )
 996             {
 997                 XEditAttribute* pX = pC->GetAttribs().GetObject( --nAttr );
 998                 if ( pX->GetItem()->Which() == EE_FEATURE_FIELD )
 999                     return (const SvxFieldItem*)pX->GetItem();
1000             }
1001         }
1002     }
1003     return 0;
1004 }
1005
1006 BOOL BinTextObject::HasField( TypeId aType ) const
1007 {
1008     USHORT nParagraphs = GetContents().Count();
1009     for ( USHORT nPara = 0; nPara < nParagraphs; nPara++ )
1010     {
1011         ContentInfo* pC = GetContents().GetObject( nPara );
1012         USHORT nAttrs = pC->GetAttribs().Count();
1013         for ( USHORT nAttr = 0; nAttr < nAttrs; nAttr++ )
1014         {
1015             XEditAttribute* pAttr = pC->GetAttribs()[nAttr];
1016             if ( pAttr->GetItem()->Which() == EE_FEATURE_FIELD )
1017             {
1018                 if ( !aType )
1019                     return TRUE;
1020
1021                 const SvxFieldData* pFldData = ((const SvxFieldItem*)pAttr->GetItem())->GetField();
1022                 if ( pFldData && pFldData->IsA( aType ) )
1023                     return TRUE;
1024             }
1025         }
1026     }
1027     return FALSE;
1028 }
1029
1030 SfxItemSet BinTextObject::GetParaAttribs( USHORT nPara ) const
1031 {
1032     ContentInfo* pC = GetContents().GetObject( nPara );
1033     return pC->GetParaAttribs();
1034 }
1035
1036 void BinTextObject::SetParaAttribs( USHORT nPara, const SfxItemSet& rAttribs )
1037 {
1038     ContentInfo* pC = GetContents().GetObject( nPara );
1039     pC->GetParaAttribs().Set( rAttribs );
1040     ClearPortionInfo();
1041 }
1042
1043 BOOL BinTextObject::RemoveCharAttribs( USHORT _nWhich )
1044 {
1045     BOOL bChanged = FALSE;
1046
1047     for ( USHORT nPara = GetContents().Count(); nPara; )
1048     {
1049         ContentInfo* pC = GetContents().GetObject( --nPara );
1050
1051         for ( USHORT nAttr = pC->GetAttribs().Count(); nAttr; )
1052         {
1053             XEditAttribute* pAttr = pC->GetAttribs().GetObject( --nAttr );
1054             if ( !_nWhich || ( pAttr->GetItem()->Which() == _nWhich ) )
1055             {
1056                 pC->GetAttribs().Remove( nAttr );
1057                 DestroyAttrib( pAttr );
1058                 bChanged = TRUE;
1059             }
1060         }
1061     }
1062
1063     if ( bChanged )
1064         ClearPortionInfo();
1065
1066     return bChanged;
1067 }
1068
1069 BOOL BinTextObject::RemoveParaAttribs( USHORT _nWhich )
1070 {
1071     BOOL bChanged = FALSE;
1072
1073     for ( USHORT nPara = GetContents().Count(); nPara; )
1074     {
1075         ContentInfo* pC = GetContents().GetObject( --nPara );
1076
1077         if ( !_nWhich )
1078         {
1079             if( pC->GetParaAttribs().Count() )
1080                 bChanged = TRUE;
1081             pC->GetParaAttribs().ClearItem();
1082         }
1083         else
1084         {
1085             if ( pC->GetParaAttribs().GetItemState( _nWhich ) == SFX_ITEM_ON )
1086             {
1087                 pC->GetParaAttribs().ClearItem( _nWhich );
1088                 bChanged = TRUE;
1089             }
1090         }
1091     }
1092
1093     if ( bChanged )
1094         ClearPortionInfo();
1095
1096     return bChanged;
1097 }
1098
1099 BOOL BinTextObject::HasStyleSheet( const XubString& rName, SfxStyleFamily eFamily ) const
1100 {
1101     USHORT nParagraphs = GetContents().Count();
1102     for ( USHORT nPara = 0; nPara < nParagraphs; nPara++ )
1103     {
1104         ContentInfo* pC = GetContents().GetObject( nPara );
1105         if ( ( pC->GetFamily() == eFamily ) && ( pC->GetStyle() == rName ) )
1106             return TRUE;
1107     }
1108     return FALSE;
1109 }
1110
1111 void BinTextObject::GetStyleSheet( USHORT nPara, XubString& rName, SfxStyleFamily& rFamily ) const
1112 {
1113     if ( nPara < aContents.Count() )
1114     {
1115         ContentInfo* pC = aContents[ nPara ];
1116         rName = pC->GetStyle();
1117         rFamily = pC->GetFamily();
1118     }
1119 }
1120
1121 void BinTextObject::SetStyleSheet( USHORT nPara, const XubString& rName, const SfxStyleFamily& rFamily )
1122 {
1123     if ( nPara < aContents.Count() )
1124     {
1125         ContentInfo* pC = aContents[ nPara ];
1126         pC->GetStyle() = rName;
1127         pC->GetFamily() = rFamily;
1128     }
1129 }
1130
1131 BOOL BinTextObject::ImpChangeStyleSheets(
1132                     const XubString& rOldName, SfxStyleFamily eOldFamily,
1133                     const XubString& rNewName, SfxStyleFamily eNewFamily )
1134 {
1135     const USHORT nParagraphs = GetContents().Count();
1136     BOOL bChanges = FALSE;
1137
1138     for ( USHORT nPara = 0; nPara < nParagraphs; nPara++ )
1139     {
1140         ContentInfo* pC = GetContents().GetObject( nPara );
1141         if ( pC->GetFamily() == eOldFamily )
1142         {
1143             if ( pC->GetStyle() == rOldName )
1144             {
1145                 pC->GetStyle() = rNewName;
1146                 pC->GetFamily() = eNewFamily;
1147                 bChanges = TRUE;
1148             }
1149         }
1150     }
1151     return bChanges;
1152 }
1153
1154 BOOL __EXPORT BinTextObject::ChangeStyleSheets(
1155                     const XubString& rOldName, SfxStyleFamily eOldFamily,
1156                     const XubString& rNewName, SfxStyleFamily eNewFamily )
1157 {
1158     BOOL bChanges = ImpChangeStyleSheets( rOldName, eOldFamily, rNewName, eNewFamily );
1159     if ( bChanges )
1160         ClearPortionInfo();
1161
1162     return bChanges;
1163 }
1164
1165 void __EXPORT BinTextObject::ChangeStyleSheetName( SfxStyleFamily eFamily,
1166                 const XubString& rOldName, const XubString& rNewName )
1167 {
1168     ImpChangeStyleSheets( rOldName, eFamily, rNewName, eFamily );
1169 }
1170
1171 void __EXPORT BinTextObject::StoreData( SvStream& rOStream ) const
1172 {
1173     USHORT nVer = 602;
1174     rOStream << nVer;
1175
1176     rOStream << bOwnerOfPool;
1177
1178     // Erst den Pool speichern, spaeter nur noch Surregate
1179     if ( bOwnerOfPool )
1180     {
1181         GetPool()->SetFileFormatVersion( SOFFICE_FILEFORMAT_50 );
1182         GetPool()->Store( rOStream );
1183     }
1184
1185     // Aktuelle Zeichensatz speichern...
1186     // #90477# GetSOStoreTextEncoding: Bug in 5.2, when default char set is multi byte text encoding
1187     rtl_TextEncoding eEncoding = GetSOStoreTextEncoding( gsl_getSystemTextEncoding(), (USHORT) rOStream.GetVersion() );
1188     rOStream << (USHORT) eEncoding;
1189
1190     // Die Anzahl der Absaetze...
1191     USHORT nParagraphs = GetContents().Count();
1192     rOStream << nParagraphs;
1193
1194     char cFeatureConverted = ByteString( CH_FEATURE, eEncoding ).GetChar(0);
1195
1196     // Die einzelnen Absaetze...
1197     for ( USHORT nPara = 0; nPara < nParagraphs; nPara++ )
1198     {
1199         ContentInfo* pC = GetContents().GetObject( nPara );
1200
1201         // Text...
1202         ByteString aText( pC->GetText(), eEncoding );
1203
1204         // Symbols?
1205         BOOL bSymbolPara = FALSE;
1206         if ( pC->GetParaAttribs().GetItemState( EE_CHAR_FONTINFO ) == SFX_ITEM_ON )
1207         {
1208             const SvxFontItem& rFontItem = (const SvxFontItem&)pC->GetParaAttribs().Get( EE_CHAR_FONTINFO );
1209             if ( rFontItem.GetCharSet() == RTL_TEXTENCODING_SYMBOL )
1210             {
1211                 aText = ByteString( pC->GetText(), RTL_TEXTENCODING_SYMBOL );
1212                 bSymbolPara = TRUE;
1213             }
1214         }
1215         for ( USHORT nA = 0; nA < pC->GetAttribs().Count(); nA++ )
1216         {
1217             XEditAttribute* pAttr = pC->GetAttribs().GetObject( nA );
1218
1219             if ( pAttr->GetItem()->Which() == EE_CHAR_FONTINFO )
1220             {
1221                 const SvxFontItem& rFontItem = (const SvxFontItem&)*pAttr->GetItem();
1222                 if ( ( !bSymbolPara && ( rFontItem.GetCharSet() == RTL_TEXTENCODING_SYMBOL ) )
1223                       || ( bSymbolPara && ( rFontItem.GetCharSet() != RTL_TEXTENCODING_SYMBOL ) ) )
1224                 {
1225                     // Not correctly converted
1226                     String aPart( pC->GetText(), pAttr->GetStart(), pAttr->GetEnd() - pAttr->GetStart() );
1227                     ByteString aNew( aPart, rFontItem.GetCharSet() );
1228                     aText.Erase( pAttr->GetStart(), pAttr->GetEnd() - pAttr->GetStart() );
1229                     aText.Insert( aNew, pAttr->GetStart() );
1230                 }
1231
1232                 // #88414# Convert StarSymbol back to StarBats
1233                 FontToSubsFontConverter hConv = CreateFontToSubsFontConverter( rFontItem.GetFamilyName(), FONTTOSUBSFONT_EXPORT | FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS );
1234                 if ( hConv )
1235                 {
1236                     // Don't create a new Attrib with StarBats font, MBR changed the
1237                     // SvxFontItem::Store() to store StarBats instead of StarSymbol!
1238                     for ( USHORT nChar = pAttr->GetStart(); nChar < pAttr->GetEnd(); nChar++ )
1239                     {
1240                         sal_Unicode cOld = pC->GetText().GetChar( nChar );
1241                         char cConv = ByteString::ConvertFromUnicode( ConvertFontToSubsFontChar( hConv, cOld ), RTL_TEXTENCODING_SYMBOL );
1242                         if ( cConv )
1243                             aText.SetChar( nChar, cConv );
1244                     }
1245
1246                     DestroyFontToSubsFontConverter( hConv );
1247                 }
1248             }
1249         }
1250
1251         // #88414# Convert StarSymbol back to StarBats
1252         // StarSymbol as paragraph attribute or in StyleSheet?
1253
1254         FontToSubsFontConverter hConv = NULL;
1255         if ( pC->GetParaAttribs().GetItemState( EE_CHAR_FONTINFO ) == SFX_ITEM_ON )
1256         {
1257             hConv = CreateFontToSubsFontConverter( ((const SvxFontItem&)pC->GetParaAttribs().Get( EE_CHAR_FONTINFO )).GetFamilyName(), FONTTOSUBSFONT_EXPORT | FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS );
1258         }
1259 /* cl removed because not needed anymore since binfilter
1260
1261         else if ( pC->GetStyle().Len() && pC->GetLoadStoreTempInfos() )
1262         {
1263             hConv = pC->GetLoadStoreTempInfos()->hOldSymbolConv_Store;
1264         }
1265 */
1266         if ( hConv )
1267         {
1268             for ( USHORT nChar = 0; nChar < pC->GetText().Len(); nChar++ )
1269             {
1270                 if ( !pC->GetAttribs().FindAttrib( EE_CHAR_FONTINFO, nChar ) )
1271                 {
1272                     sal_Unicode cOld = pC->GetText().GetChar( nChar );
1273                     char cConv = ByteString::ConvertFromUnicode( ConvertFontToSubsFontChar( hConv, cOld ), RTL_TEXTENCODING_SYMBOL );
1274                     if ( cConv )
1275                         aText.SetChar( nChar, cConv );
1276                 }
1277             }
1278
1279             DestroyFontToSubsFontConverter( hConv );
1280
1281         }
1282
1283
1284         // Convert CH_FEATURE to CH_FEATURE_OLD
1285         aText.SearchAndReplaceAll( cFeatureConverted, CH_FEATURE_OLD );
1286         rOStream.WriteByteString( aText );
1287
1288         // StyleName und Family...
1289         rOStream.WriteByteString( ByteString( pC->GetStyle(), eEncoding ) );
1290         rOStream << (USHORT)pC->GetFamily();
1291
1292         // Absatzattribute...
1293         pC->GetParaAttribs().Store( rOStream );
1294
1295         // Die Anzahl der Attribute...
1296         USHORT nAttribs = pC->GetAttribs().Count();
1297         rOStream << nAttribs;
1298
1299         // Und die einzelnen Attribute
1300         // Items als Surregate => immer 8 Byte pro Attrib
1301         // Which = 2; Surregat = 2; Start = 2; End = 2;
1302         for ( USHORT nAttr = 0; nAttr < nAttribs; nAttr++ )
1303         {
1304             XEditAttribute* pX = pC->GetAttribs().GetObject( nAttr );
1305
1306             rOStream << pX->GetItem()->Which();
1307             GetPool()->StoreSurrogate( rOStream, pX->GetItem() );
1308             rOStream << pX->GetStart();
1309             rOStream << pX->GetEnd();
1310         }
1311     }
1312
1313     // Ab 400:
1314     rOStream << nMetric;
1315
1316     // Ab 600
1317     rOStream << nUserType;
1318     rOStream << nObjSettings;
1319
1320     // Ab 601
1321     rOStream << bVertical;
1322
1323     // Ab 602
1324     rOStream << nScriptType;
1325
1326     rOStream << bStoreUnicodeStrings;
1327     if ( bStoreUnicodeStrings )
1328     {
1329         for ( USHORT nPara = 0; nPara < nParagraphs; nPara++ )
1330         {
1331             ContentInfo* pC = GetContents().GetObject( nPara );
1332             USHORT nL = pC->GetText().Len();
1333             rOStream << nL;
1334             rOStream.Write( pC->GetText().GetBuffer(), nL*sizeof(sal_Unicode) );
1335
1336             // #91575# StyleSheetName must be Unicode too!
1337             // Copy/Paste from EA3 to BETA or from BETA to EA3 not possible, not needed...
1338             // If needed, change nL back to ULONG and increase version...
1339             nL = pC->GetStyle().Len();
1340             rOStream << nL;
1341             rOStream.Write( pC->GetStyle().GetBuffer(), nL*sizeof(sal_Unicode) );
1342         }
1343     }
1344 }
1345
1346 void __EXPORT BinTextObject::CreateData( SvStream& rIStream )
1347 {
1348     rIStream >> nVersion;
1349
1350     // Das Textobject wurde erstmal mit der aktuellen Einstellung
1351     // von pTextObjectPool erzeugt.
1352     BOOL bOwnerOfCurrent = bOwnerOfPool;
1353     rIStream >> bOwnerOfPool;
1354
1355     if ( bOwnerOfCurrent && !bOwnerOfPool )
1356     {
1357         // Es wurde ein globaler Pool verwendet, mir jetzt nicht uebergeben,
1358         // aber ich brauche ihn!
1359         DBG_ERROR( "Man gebe mir den globalen TextObjectPool!" );
1360         return;
1361     }
1362     else if ( !bOwnerOfCurrent && bOwnerOfPool )
1363     {
1364         // Es soll ein globaler Pool verwendet werden, aber dieses
1365         // Textobject hat einen eigenen.
1366         pPool = EditEngine::CreatePool();
1367     }
1368
1369     if ( bOwnerOfPool )
1370         GetPool()->Load( rIStream );
1371
1372     // CharSet, in dem gespeichert wurde:
1373     USHORT nCharSet;
1374     rIStream >> nCharSet;
1375
1376     rtl_TextEncoding eSrcEncoding = GetSOLoadTextEncoding( (rtl_TextEncoding)nCharSet, (USHORT)rIStream.GetVersion() );
1377
1378     // Die Anzahl der Absaetze...
1379     USHORT nParagraphs;
1380     rIStream >> nParagraphs;
1381
1382     // Die einzelnen Absaetze...
1383     for ( ULONG nPara = 0; nPara < nParagraphs; nPara++ )
1384     {
1385         ContentInfo* pC = CreateAndInsertContent();
1386
1387         // Der Text...
1388         ByteString aByteString;
1389         rIStream.ReadByteString( aByteString );
1390         pC->GetText() = String( aByteString, eSrcEncoding );
1391
1392         // StyleName und Family...
1393         rIStream.ReadByteString( pC->GetStyle(), eSrcEncoding );
1394         USHORT nStyleFamily;
1395         rIStream >> nStyleFamily;
1396         pC->GetFamily() = (SfxStyleFamily)nStyleFamily;
1397
1398         // Absatzattribute...
1399         pC->GetParaAttribs().Load( rIStream );
1400
1401         // Die Anzahl der Attribute...
1402         USHORT nAttribs;
1403         rIStream >> nAttribs;
1404
1405         // Und die einzelnen Attribute
1406         // Items als Surregate => immer 8 Byte pro Attrib
1407         // Which = 2; Surregat = 2; Start = 2; End = 2;
1408         USHORT nAttr;
1409         for ( nAttr = 0; nAttr < nAttribs; nAttr++ )
1410         {
1411             USHORT _nWhich, nStart, nEnd;
1412             const SfxPoolItem* pItem;
1413
1414             rIStream >> _nWhich;
1415             _nWhich = pPool->GetNewWhich( _nWhich );
1416             pItem = pPool->LoadSurrogate( rIStream, _nWhich, 0 );
1417             rIStream >> nStart;
1418             rIStream >> nEnd;
1419             if ( pItem )
1420             {
1421                 if ( pItem->Which() == EE_FEATURE_NOTCONV )
1422                 {
1423                     pC->GetText().SetChar( nStart, ByteString::ConvertToUnicode( aByteString.GetChar( nStart ), ((SvxCharSetColorItem*)pItem)->GetCharSet() ) );
1424                 }
1425                 else
1426                 {
1427                     XEditAttribute* pAttr = new XEditAttribute( *pItem, nStart, nEnd );
1428                     pC->GetAttribs().Insert( pAttr, pC->GetAttribs().Count() );
1429
1430                     if ( ( _nWhich >= EE_FEATURE_START ) && ( _nWhich <= EE_FEATURE_END ) )
1431                     {
1432                         // Convert CH_FEATURE to CH_FEATURE_OLD
1433                         DBG_ASSERT( (BYTE) aByteString.GetChar( nStart ) == CH_FEATURE_OLD, "CreateData: CH_FEATURE expected!" );
1434                         if ( (BYTE) aByteString.GetChar( nStart ) == CH_FEATURE_OLD )
1435                             pC->GetText().SetChar( nStart, CH_FEATURE );
1436                     }
1437                 }
1438             }
1439         }
1440
1441         // But check for paragraph and character symbol attribs here,
1442         // FinishLoad will not be called in OpenOffice Calc, no StyleSheets...
1443
1444         BOOL bSymbolPara = FALSE;
1445         if ( pC->GetParaAttribs().GetItemState( EE_CHAR_FONTINFO ) == SFX_ITEM_ON )
1446         {
1447             const SvxFontItem& rFontItem = (const SvxFontItem&)pC->GetParaAttribs().Get( EE_CHAR_FONTINFO );
1448             if ( rFontItem.GetCharSet() == RTL_TEXTENCODING_SYMBOL )
1449             {
1450                 pC->GetText() = String( aByteString, RTL_TEXTENCODING_SYMBOL );
1451                 bSymbolPara = TRUE;
1452             }
1453         }
1454
1455         for ( nAttr = pC->GetAttribs().Count(); nAttr; )
1456         {
1457             XEditAttribute* pAttr = pC->GetAttribs().GetObject( --nAttr );
1458             if ( pAttr->GetItem()->Which() == EE_CHAR_FONTINFO )
1459             {
1460                 const SvxFontItem& rFontItem = (const SvxFontItem&)*pAttr->GetItem();
1461                 if ( ( !bSymbolPara && ( rFontItem.GetCharSet() == RTL_TEXTENCODING_SYMBOL ) )
1462                       || ( bSymbolPara && ( rFontItem.GetCharSet() != RTL_TEXTENCODING_SYMBOL ) ) )
1463                 {
1464                     // Not correctly converted
1465                     ByteString aPart( aByteString, pAttr->GetStart(), pAttr->GetEnd()-pAttr->GetStart() );
1466                     String aNew( aPart, rFontItem.GetCharSet() );
1467                     pC->GetText().Erase( pAttr->GetStart(), pAttr->GetEnd()-pAttr->GetStart() );
1468                     pC->GetText().Insert( aNew, pAttr->GetStart() );
1469                 }
1470
1471                 // #88414# Convert StarMath and StarBats to StarSymbol
1472                 FontToSubsFontConverter hConv = CreateFontToSubsFontConverter( rFontItem.GetFamilyName(), FONTTOSUBSFONT_IMPORT | FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS );
1473                 if ( hConv )
1474                 {
1475                     SvxFontItem aNewFontItem( rFontItem );
1476                     aNewFontItem.GetFamilyName() = GetFontToSubsFontName( hConv );
1477
1478                     pC->GetAttribs().Remove( nAttr );
1479                     XEditAttribute* pNewAttr = CreateAttrib( aNewFontItem, pAttr->GetStart(), pAttr->GetEnd() );
1480                     pC->GetAttribs().Insert( pNewAttr, nAttr );
1481                     DestroyAttrib( pAttr );
1482
1483                     for ( USHORT nChar = pNewAttr->GetStart(); nChar < pNewAttr->GetEnd(); nChar++ )
1484                     {
1485                         sal_Unicode cOld = pC->GetText().GetChar( nChar );
1486                         DBG_ASSERT( cOld >= 0xF000, "cOld not converted?!" );
1487                         sal_Unicode cConv = ConvertFontToSubsFontChar( hConv, cOld );
1488                         if ( cConv )
1489                             pC->GetText().SetChar( nChar, cConv );
1490                     }
1491
1492                     DestroyFontToSubsFontConverter( hConv );
1493                 }
1494             }
1495         }
1496
1497
1498         // #88414# Convert StarMath and StarBats to StarSymbol
1499         // Maybe old symbol font as paragraph attribute?
1500         if ( pC->GetParaAttribs().GetItemState( EE_CHAR_FONTINFO ) == SFX_ITEM_ON )
1501         {
1502             const SvxFontItem& rFontItem = (const SvxFontItem&)pC->GetParaAttribs().Get( EE_CHAR_FONTINFO );
1503             FontToSubsFontConverter hConv = CreateFontToSubsFontConverter( rFontItem.GetFamilyName(), FONTTOSUBSFONT_IMPORT | FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS );
1504             if ( hConv )
1505             {
1506                 SvxFontItem aNewFontItem( rFontItem );
1507                 aNewFontItem.GetFamilyName() = GetFontToSubsFontName( hConv );
1508                 pC->GetParaAttribs().Put( aNewFontItem );
1509
1510                 for ( USHORT nChar = 0; nChar < pC->GetText().Len(); nChar++ )
1511                 {
1512                     if ( !pC->GetAttribs().FindAttrib( EE_CHAR_FONTINFO, nChar ) )
1513                     {
1514                         sal_Unicode cOld = pC->GetText().GetChar( nChar );
1515                         DBG_ASSERT( cOld >= 0xF000, "cOld not converted?!" );
1516                         sal_Unicode cConv = ConvertFontToSubsFontChar( hConv, cOld );
1517                         if ( cConv )
1518                             pC->GetText().SetChar( nChar, cConv );
1519                     }
1520                 }
1521
1522                 DestroyFontToSubsFontConverter( hConv );
1523             }
1524         }
1525     }
1526
1527     // Ab 400 auch die DefMetric:
1528     if ( nVersion >= 400 )
1529     {
1530         USHORT nTmpMetric;
1531         rIStream >> nTmpMetric;
1532         if ( nVersion >= 401 )
1533         {
1534             // In der 400 gab es noch einen Bug bei Textobjekten mit eigenem
1535             // Pool, deshalb erst ab 401 auswerten.
1536             nMetric = nTmpMetric;
1537             if ( bOwnerOfPool && pPool && ( nMetric != 0xFFFF ) )
1538                 pPool->SetDefaultMetric( (SfxMapUnit)nMetric );
1539         }
1540     }
1541
1542     if ( nVersion >= 600 )
1543     {
1544         rIStream >> nUserType;
1545         rIStream >> nObjSettings;
1546     }
1547
1548     if ( nVersion >= 601 )
1549     {
1550         rIStream >> bVertical;
1551     }
1552
1553     if ( nVersion >= 602 )
1554     {
1555         rIStream >> nScriptType;
1556
1557         BOOL bUnicodeStrings;
1558         rIStream >> bUnicodeStrings;
1559         if ( bUnicodeStrings )
1560         {
1561             for ( USHORT nPara = 0; nPara < nParagraphs; nPara++ )
1562             {
1563                 ContentInfo* pC = GetContents().GetObject( nPara );
1564                 USHORT nL;
1565
1566                 // Text
1567                 rIStream >> nL;
1568                 if ( nL )
1569                 {
1570                     pC->GetText().AllocBuffer( nL );
1571                     rIStream.Read( pC->GetText().GetBufferAccess(), nL*sizeof(sal_Unicode) );
1572                     pC->GetText().ReleaseBufferAccess( (USHORT)nL );
1573                 }
1574
1575                 // StyleSheetName
1576                 rIStream >> nL;
1577                 if ( nL )
1578                 {
1579                     pC->GetStyle().AllocBuffer( nL );
1580                     rIStream.Read( pC->GetStyle().GetBufferAccess(), nL*sizeof(sal_Unicode) );
1581                     pC->GetStyle().ReleaseBufferAccess( (USHORT)nL );
1582                 }
1583             }
1584         }
1585     }
1586
1587
1588     // Ab 500 werden die Tabs anders interpretiert: TabPos + LI, vorher nur TabPos.
1589     // Wirkt nur wenn auch Tab-Positionen eingestellt wurden, nicht beim DefTab.
1590     if ( nVersion < 500 )
1591     {
1592         for ( USHORT n = 0; n < aContents.Count(); n++ )
1593         {
1594             ContentInfo* pC = aContents.GetObject( n );
1595             const SvxLRSpaceItem& rLRSpace = (const SvxLRSpaceItem&) pC->GetParaAttribs().Get( EE_PARA_LRSPACE );
1596             if ( rLRSpace.GetTxtLeft() && ( pC->GetParaAttribs().GetItemState( EE_PARA_TABS ) == SFX_ITEM_ON ) )
1597             {
1598                 const SvxTabStopItem& rTabs = (const SvxTabStopItem&) pC->GetParaAttribs().Get( EE_PARA_TABS );
1599                 SvxTabStopItem aNewTabs( 0, 0, SVX_TAB_ADJUST_LEFT, EE_PARA_TABS );
1600                 for ( USHORT t = 0; t < rTabs.Count(); t++ )
1601                 {
1602                     const SvxTabStop& rT = rTabs[ t ];
1603                     aNewTabs.Insert( SvxTabStop( rT.GetTabPos() - rLRSpace.GetTxtLeft(),
1604                                 rT.GetAdjustment(), rT.GetDecimal(), rT.GetFill() ) );
1605                 }
1606                 pC->GetParaAttribs().Put( aNewTabs );
1607             }
1608         }
1609     }
1610 }
1611
1612 USHORT BinTextObject::GetVersion() const
1613 {
1614     return nVersion;
1615 }
1616
1617 bool BinTextObject::operator==( const BinTextObject& rCompare ) const
1618 {
1619     if( this == &rCompare )
1620         return true;
1621
1622     if( ( aContents.Count() != rCompare.aContents.Count() ) ||
1623             ( pPool != rCompare.pPool ) ||
1624             ( nMetric != rCompare.nMetric ) ||
1625             ( nUserType!= rCompare.nUserType ) ||
1626             ( nScriptType != rCompare.nScriptType ) ||
1627             ( bVertical != rCompare.bVertical ) )
1628         return false;
1629
1630     USHORT n;
1631     for( n = 0; n < aContents.Count(); n++ )
1632     {
1633         if( !( *aContents.GetObject( n ) == *rCompare.aContents.GetObject( n ) ) )
1634             return false;
1635     }
1636
1637     return true;
1638 }
1639
1640 // #i102062#
1641 bool BinTextObject::isWrongListEqual(const BinTextObject& rCompare) const
1642 {
1643     if(GetContents().Count() != rCompare.GetContents().Count())
1644     {
1645         return false;
1646     }
1647
1648     for(USHORT a(0); a < GetContents().Count(); a++)
1649     {
1650         const ContentInfo& rCandA(*GetContents().GetObject(a));
1651         const ContentInfo& rCandB(*rCompare.GetContents().GetObject(a));
1652
1653         if(!rCandA.isWrongListEqual(rCandB))
1654         {
1655             return false;
1656         }
1657     }
1658
1659     return true;
1660 }
1661
1662 #define CHARSETMARKER   0x9999
1663
1664 void __EXPORT BinTextObject::CreateData300( SvStream& rIStream )
1665 {
1666     // Fuer Aufwaertskompatibilitaet.
1667
1668     // Erst den Pool laden...
1669     // Ist in der 300 immer gespeichert worden!
1670     GetPool()->Load( rIStream );
1671
1672     // Die Anzahl der Absaetze...
1673     sal_uInt32 nParagraphs;
1674     rIStream >> nParagraphs;
1675
1676     // Die einzelnen Absaetze...
1677     for ( ULONG nPara = 0; nPara < nParagraphs; nPara++ )
1678     {
1679         ContentInfo* pC = CreateAndInsertContent();
1680
1681         // Der Text...
1682         rIStream.ReadByteString( pC->GetText() );
1683
1684         // StyleName und Family...
1685         rIStream.ReadByteString( pC->GetStyle() );
1686         USHORT nStyleFamily;
1687         rIStream >> nStyleFamily;
1688         pC->GetFamily() = (SfxStyleFamily)nStyleFamily;
1689
1690         // Absatzattribute...
1691         pC->GetParaAttribs().Load( rIStream );
1692
1693         // Die Anzahl der Attribute...
1694         sal_uInt32 nAttribs;
1695         rIStream >> nAttribs;
1696
1697         // Und die einzelnen Attribute
1698         // Items als Surregate => immer 8 Byte pro Attrib
1699         // Which = 2; Surregat = 2; Start = 2; End = 2;
1700         for ( ULONG nAttr = 0; nAttr < nAttribs; nAttr++ )
1701         {
1702             USHORT _nWhich, nStart, nEnd;
1703             const SfxPoolItem* pItem;
1704
1705             rIStream >> _nWhich;
1706             _nWhich = pPool->GetNewWhich( _nWhich );
1707             pItem = pPool->LoadSurrogate( rIStream, _nWhich, 0 );
1708             rIStream >> nStart;
1709             rIStream >> nEnd;
1710             if ( pItem )
1711             {
1712                 XEditAttribute* pAttr = new XEditAttribute( *pItem, nStart, nEnd );
1713                 pC->GetAttribs().Insert( pAttr, pC->GetAttribs().Count() );
1714             }
1715         }
1716     }
1717
1718     // Prueffen, ob ein Zeichensatz gespeichert wurde
1719     USHORT nCharSetMarker;
1720     rIStream >> nCharSetMarker;
1721     if ( nCharSetMarker == CHARSETMARKER )
1722     {
1723         USHORT nCharSet;
1724         rIStream >> nCharSet;
1725     }
1726 }