starmath/source/symbol.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: symbol.cxx,v $
  10  * $Revision: 1.31 $
  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_starmath.hxx"
  33
  34
  35 #include <vector>
  36 #include <osl/mutex.hxx>
  37 #include <ucbhelper/content.hxx>
  38 #include <vcl/msgbox.hxx>
  39
  40 #ifndef _SV_RESARY_HXX
  41 #include <tools/resary.hxx>
  42 #endif
  43 #include <sfx2/dispatch.hxx>
  44 #include <sfx2/docfile.hxx>
  45
  46 #include "symbol.hxx"
  47 #include "view.hxx"
  48 #include "utility.hxx"
  49 #include "dialog.hxx"
  50 #include "config.hxx"
  51 #include "cfgitem.hxx"
  52 #include "smmod.hxx"
  53 #include "starmath.hrc"
  54
  55
  56 using namespace ::com::sun::star;
  57 using namespace ::com::sun::star::ucb;
  58 using namespace ::com::sun::star::uno;
  59 using namespace ::rtl;
  60
  61 // Das hier muss auch mal alles "uberarbeitet werden. Insbesondere die nicht
  62 // funktionierende und bei l"oschen/"andern von Symbolen nicht gepflegte
  63 // Hash Tabelle!!!  Diese aktualisert sich erst im Wertzuweisungsoperator
  64 // beim Verlassen des 'SmSymDefineDialog's!
  65
  66 /**************************************************************************/
  67 /*
  68 **
  69 **      MACRO DEFINTION
  70 **
  71 **/
  72
  73 #define SF_SM20IDENT 0x03031963L
  74 #define SF_IDENT         0x30334D53L
  75
  76
  77 SV_IMPL_PTRARR( SymbolArray, SmSym * );
  78
  79 /**************************************************************************/
  80 /*
  81 **
  82 **      DATA DEFINITION
  83 **
  84 **/
  85
  86 long                            SF_Ident = SF_IDENT;
  87
  88 /**************************************************************************/
  89 /*
  90 **
  91 **      CLASS IMPLEMENTATION
  92 **
  93 **/
  94
  95 SmSym::SmSym() :
  96     Name(C2S("unknown")),
  97     aSetName(C2S("unknown")),
  98     pHashNext(0),
  99     pSymSetManager(0),
 100     Character('\0'),
 101     bPredefined(FALSE),
 102     bDocSymbol(FALSE)
 103 {
 104     aExportName = Name;
 105     Face.SetTransparent(TRUE);
 106     Face.SetAlign(ALIGN_BASELINE);
 107 }
 108
 109
 110 SmSym::SmSym(const SmSym& rSymbol)
 111 {
 112     pSymSetManager = 0;
 113     *this = rSymbol;
 114 }
 115
 116
 117 SmSym::SmSym(const String& rName, const Font& rFont, sal_Unicode aChar,
 118              const String& rSet, BOOL bIsPredefined)
 119 {
 120     Name                = aExportName   = rName;
 121
 122     Face        = rFont;
 123     Face.SetTransparent(TRUE);
 124     Face.SetAlign(ALIGN_BASELINE);
 125
 126     Character   = aChar;
 127 //! according to HDU this should not be used anymore now
 128 //! since this was necessary in the early days but should
 129 //! not be done now since this is handled now at a more
 130 //! bottom layer by HDU.
 131 //! He can still imagine scenarios where this will be wrong
 132 //! now though, for example when importing *some* old documents.
 133 //! But overall it should be a large improvement, and
 134 //! likely everything will still work... #_- (eyes shut and "go"!)
 135 //
 136 //    if (RTL_TEXTENCODING_SYMBOL == rFont.GetCharSet())
 137 //        Character |= 0xF000;
 138     aSetName    = rSet;
 139     bPredefined = bIsPredefined;
 140     bDocSymbol  = FALSE;
 141
 142     pHashNext      = 0;
 143     pSymSetManager = 0;
 144 }
 145
 146
 147 SmSym& SmSym::operator = (const SmSym& rSymbol)
 148 {
 149     Name                = rSymbol.Name;
 150     Face                = rSymbol.Face;
 151     Character   = rSymbol.Character;
 152     aSetName    = rSymbol.aSetName;
 153     bPredefined = rSymbol.bPredefined;
 154     bDocSymbol  = rSymbol.bDocSymbol;
 155     aExportName = rSymbol.aExportName;
 156
 157     pHashNext = 0;
 158
 159     if (pSymSetManager)
 160         pSymSetManager->SetModified(TRUE);
 161
 162     return *this;
 163 }
 164
 165 /**************************************************************************/
 166
 167 SmSymSet::SmSymSet() :
 168     Name(C2S("unknown")),
 169     pSymSetManager(0)
 170 {
 171     SymbolList.Clear();
 172 }
 173
 174 SmSymSet::SmSymSet(const SmSymSet& rSymbolSet)
 175 {
 176     pSymSetManager = 0;
 177     *this = rSymbolSet;
 178 }
 179
 180 SmSymSet::SmSymSet(const String& rName)
 181 {
 182     Name = rName;
 183     SymbolList.Clear();
 184
 185     pSymSetManager = 0;
 186 }
 187
 188 SmSymSet::~SmSymSet()
 189 {
 190     for (USHORT i = 0; i < GetCount(); i++)
 191         delete SymbolList.GetObject(i);
 192 }
 193
 194 SmSymSet& SmSymSet::operator = (const SmSymSet& rSymbolSet)
 195 {
 196     USHORT i;
 197     for (i = 0; i < GetCount(); i++)
 198         delete SymbolList.GetObject(i);
 199
 200     Name = rSymbolSet.Name;
 201     SymbolList.Clear();
 202     for (i = 0; i < rSymbolSet.GetCount(); i++)
 203         AddSymbol(new SmSym(rSymbolSet.GetSymbol(i)));
 204
 205     if (pSymSetManager)
 206         pSymSetManager->SetModified(TRUE);
 207
 208     return *this;
 209 }
 210
 211 USHORT SmSymSet::AddSymbol(SmSym* pSymbol)
 212 {
 213     DBG_ASSERT(pSymbol, "Kein Symbol");
 214
 215     if (pSymbol)
 216         pSymbol->SetSetName( GetName() );
 217     SymbolList.Insert(pSymbol, LIST_APPEND);
 218     DBG_ASSERT(SymbolList.GetPos(pSymbol) == SymbolList.Count() - 1,
 219         "Sm : ... ergibt falschen return Wert");
 220
 221     if (pSymSetManager)
 222         pSymSetManager->SetModified(TRUE);
 223
 224     return (USHORT) SymbolList.Count() - 1;
 225 }
 226
 227 void SmSymSet::DeleteSymbol(USHORT SymbolNo)
 228 {
 229     delete RemoveSymbol(SymbolNo);
 230 }
 231
 232 SmSym * SmSymSet::RemoveSymbol(USHORT SymbolNo)
 233 {
 234     DBG_ASSERT(SymbolList.GetObject(SymbolNo), "Symbol nicht vorhanden");
 235
 236     SmSym *pSym = SymbolList.GetObject(SymbolNo);
 237     SymbolList.Remove(SymbolNo);
 238
 239     if (pSymSetManager)
 240         pSymSetManager->SetModified(TRUE);
 241
 242     return pSym;
 243 }
 244
 245 USHORT SmSymSet::GetSymbolPos(const String& rName)
 246 {
 247     for (USHORT i = 0; i < GetCount(); i++)
 248         if (SymbolList.GetObject(i)->GetName() == rName)
 249             return (i);
 250
 251     return SYMBOL_NONE;
 252 }
 253
 254 /**************************************************************************/
 255
 256 SmSymSetManager_Impl::SmSymSetManager_Impl(
 257         SmSymSetManager &rMgr, USHORT HashTableSize ) :
 258
 259     rSymSetMgr    (rMgr)
 260 {
 261     NoSymbolSets    = 0;
 262     NoHashEntries   = HashTableSize;
 263     HashEntries     = new SmSym *[NoHashEntries];
 264     memset( HashEntries, 0, sizeof(SmSym *) * NoHashEntries );
 265     Modified        = FALSE;
 266 }
 267
 268
 269 SmSymSetManager_Impl::~SmSymSetManager_Impl()
 270 {
 271     for (USHORT i = 0;  i < NoSymbolSets;  ++i)
 272         delete SymbolSets.Get(i);
 273     SymbolSets.Clear();
 274
 275     NoSymbolSets = 0;
 276     if (HashEntries)
 277     {
 278         delete[] HashEntries;
 279         HashEntries = 0;
 280     }
 281     NoHashEntries = 0;
 282     Modified = FALSE;
 283 }
 284
 285
 286 SmSymSetManager_Impl & SmSymSetManager_Impl::operator = ( const SmSymSetManager_Impl &rImpl )
 287 {
 288     //! rMySymSetMgr remains unchanged
 289
 290     NoHashEntries   = rImpl.NoHashEntries;
 291     if (HashEntries)
 292         delete [] HashEntries;
 293     HashEntries = new SmSym *[NoHashEntries];
 294     memset( HashEntries, 0, sizeof(SmSym *) * NoHashEntries );
 295
 296     NoSymbolSets    = 0;
 297     SymbolSets.Clear();
 298     for (USHORT i = 0;  i < rImpl.NoSymbolSets;  ++i)
 299     {
 300         rSymSetMgr.AddSymbolSet( new SmSymSet( *rImpl.rSymSetMgr.GetSymbolSet(i) ) );
 301     }
 302     DBG_ASSERT( NoSymbolSets == rImpl.NoSymbolSets,
 303             "incorrect number of symbolsets" );
 304
 305     Modified        = TRUE;
 306     return *this;
 307 }
 308
 309 /**************************************************************************/
 310
 311 void SmSymSetManager::SFX_NOTIFY(SfxBroadcaster& /*rBC*/, const TypeId& rBCType,
 312                               const SfxHint& /*rHint*/, const TypeId& rHintType)
 313 {
 314 }
 315
 316
 317 UINT32 SmSymSetManager::GetHashIndex(const String& rSymbolName)
 318 {
 319     UINT32 x = 1;
 320     for (xub_StrLen i = 0; i < rSymbolName.Len(); i++)
 321         x += x * rSymbolName.GetChar(i) + i;
 322
 323     return x % pImpl->NoHashEntries;
 324 }
 325
 326
 327 void SmSymSetManager::EnterHashTable(SmSym& rSymbol)
 328 {
 329     int j = GetHashIndex( rSymbol.GetName() );
 330     if (pImpl->HashEntries[j] == 0)
 331         pImpl->HashEntries[j] = &rSymbol;
 332     else
 333     {
 334         SmSym *p = pImpl->HashEntries[j];
 335         while (p->pHashNext)
 336             p = p->pHashNext;
 337         p->pHashNext = &rSymbol;
 338     }
 339     rSymbol.pHashNext = 0;
 340 }
 341
 342
 343 void SmSymSetManager::EnterHashTable(SmSymSet& rSymbolSet)
 344 {
 345     for (USHORT i = 0; i < rSymbolSet.GetCount(); i++)
 346         EnterHashTable( *rSymbolSet.SymbolList.GetObject(i) );
 347 }
 348
 349 void SmSymSetManager::FillHashTable()
 350 {
 351     if (pImpl->HashEntries)
 352     {
 353         memset( pImpl->HashEntries, 0, pImpl->NoHashEntries * sizeof(SmSym *) );
 354
 355         for (UINT32 i = 0; i < pImpl->NoSymbolSets; i++)
 356             EnterHashTable( *GetSymbolSet( (USHORT) i ) );
 357     }
 358 }
 359
 360 void SmSymSetManager::Init()
 361 {
 362     SmModule *pp = SM_MOD1();
 363     StartListening(*pp->GetConfig());
 364 }
 365
 366
 367 void SmSymSetManager::Exit()
 368 {
 369     SmModule *pp = SM_MOD1();
 370     EndListening(*pp->GetConfig());
 371 }
 372
 373
 374 SmSymSetManager::SmSymSetManager(USHORT HashTableSize)
 375 {
 376     pImpl = new SmSymSetManager_Impl( *this, HashTableSize );
 377 }
 378
 379
 380 SmSymSetManager::SmSymSetManager(const SmSymSetManager& rSymbolSetManager) :
 381     SfxListener()
 382 {
 383     pImpl = new SmSymSetManager_Impl( *this, rSymbolSetManager.pImpl->NoHashEntries );
 384     *pImpl = *rSymbolSetManager.pImpl;
 385 }
 386
 387
 388 SmSymSetManager::~SmSymSetManager()
 389 {
 390     delete pImpl;
 391     pImpl = 0;
 392 }
 393
 394 SmSymSetManager& SmSymSetManager::operator = (const SmSymSetManager& rSymbolSetManager)
 395 {
 396     *pImpl = *rSymbolSetManager.pImpl;
 397     return *this;
 398 }
 399
 400 USHORT SmSymSetManager::AddSymbolSet(SmSymSet* pSymbolSet)
 401 {
 402     if (pImpl->NoSymbolSets >= pImpl->SymbolSets.GetSize())
 403         pImpl->SymbolSets.SetSize(pImpl->NoSymbolSets + 1);
 404
 405     pImpl->SymbolSets.Put(pImpl->NoSymbolSets++, pSymbolSet);
 406
 407     pSymbolSet->pSymSetManager = this;
 408
 409     for (USHORT i = 0; i < pSymbolSet->GetCount(); i++)
 410         pSymbolSet->SymbolList.GetObject(i)->pSymSetManager = this;
 411
 412     FillHashTable();
 413     pImpl->Modified = TRUE;
 414
 415     return (USHORT) (pImpl->NoSymbolSets - 1);
 416 }
 417
 418 void SmSymSetManager::ChangeSymbolSet(SmSymSet* pSymbolSet)
 419 {
 420     if (pSymbolSet)
 421     {
 422         FillHashTable();
 423         pImpl->Modified = TRUE;
 424     }
 425 }
 426
 427 void SmSymSetManager::DeleteSymbolSet(USHORT SymbolSetNo)
 428 {
 429     delete pImpl->SymbolSets.Get(SymbolSetNo);
 430     pImpl->NoSymbolSets--;
 431
 432     for (UINT32 i = SymbolSetNo; i < pImpl->NoSymbolSets; i++)
 433         pImpl->SymbolSets.Put(i, pImpl->SymbolSets.Get(i + 1));
 434
 435     FillHashTable();
 436
 437     pImpl->Modified = TRUE;
 438 }
 439
 440
 441 USHORT SmSymSetManager::GetSymbolSetPos(const String& rSymbolSetName) const
 442 {
 443     for (USHORT i = 0; i < pImpl->NoSymbolSets; i++)
 444         if (pImpl->SymbolSets.Get(i)->GetName() == rSymbolSetName)
 445             return (i);
 446
 447     return SYMBOLSET_NONE;
 448 }
 449
 450 SmSym *SmSymSetManager::GetSymbolByName(const String& rSymbolName)
 451 {
 452     SmSym *pSym = pImpl->HashEntries[GetHashIndex(rSymbolName)];
 453     while (pSym)
 454     {
 455         if (pSym->Name == rSymbolName)
 456             break;
 457         pSym = pSym->pHashNext;
 458     }
 459
 460     return pSym;
 461 }
 462
 463
 464 void SmSymSetManager::AddReplaceSymbol( const SmSym &rSymbol )
 465 {
 466     SmSym *pSym = GetSymbolByName( rSymbol.GetName() );
 467     if (pSym)
 468     {
 469         *pSym = rSymbol;
 470     }
 471     else
 472     {
 473         USHORT nPos = GetSymbolSetPos( rSymbol.GetSetName() );
 474         if (SYMBOLSET_NONE == nPos)
 475         {
 476             AddSymbolSet( new SmSymSet( rSymbol.GetSetName() ) );
 477             nPos = GetSymbolSetPos( rSymbol.GetSetName() );
 478         }
 479         DBG_ASSERT( nPos != SYMBOLSET_NONE, "SymbolSet not found");
 480         SmSym *pTmpSym = new SmSym( rSymbol );
 481         GetSymbolSet( nPos )->AddSymbol( pTmpSym );
 482         EnterHashTable( *pTmpSym );
 483     }
 484     SetModified( TRUE );
 485 }
 486
 487
 488 USHORT SmSymSetManager::GetSymbolCount() const
 489 {
 490     USHORT nRes = 0;
 491     USHORT nSets = GetSymbolSetCount();
 492     for (USHORT i = 0;  i < nSets;  ++i)
 493         nRes = nRes + GetSymbolSet(i)->GetCount();
 494     return nRes;
 495 }
 496
 497
 498 const SmSym * SmSymSetManager::GetSymbolByPos( USHORT nPos ) const
 499 {
 500     const SmSym *pRes = 0;
 501
 502     INT16 nIdx = 0;
 503     USHORT nSets = GetSymbolSetCount();
 504     USHORT i = 0;
 505     while (i < nSets  &&  !pRes)
 506     {
 507         USHORT nEntries = GetSymbolSet(i)->GetCount();
 508         if (nPos < nIdx + nEntries)
 509             pRes = &GetSymbolSet(i)->GetSymbol( nPos - nIdx );
 510         else
 511             nIdx = nIdx + nEntries;
 512         ++i;
 513     }
 514
 515     return pRes;
 516 }
 517
 518
 519 void SmSymSetManager::GetSymbols( std::vector< SmSym > &rSymbols ) const
 520 {
 521     INT32 nCount = GetSymbolCount();
 522     rSymbols.resize( nCount );
 523     USHORT nPos = 0;
 524     std::vector< SmSym >::iterator aIt( rSymbols.begin() );
 525     std::vector< SmSym >::iterator aEnd( rSymbols.end() );
 526     while (aIt != aEnd)
 527     {
 528         const SmSym *pSym = GetSymbolByPos( nPos++ );
 529         DBG_ASSERT( pSym, "symbol missing" );
 530         if (pSym)
 531             *aIt++ = *pSym;
 532     }
 533     DBG_ASSERT( nPos == nCount, "index out of range?" );
 534 }
 535
 536
 537 void SmSymSetManager::Load()
 538 {
 539     std::vector< SmSym > aSymbols;
 540     SmMathConfig &rCfg = *SM_MOD1()->GetConfig();
 541     rCfg.GetSymbols( aSymbols );
 542     INT32 nSymbolCount = aSymbols.size();
 543
 544     USHORT i;
 545     for (i = 0;  i < nSymbolCount;  ++i)
 546     {
 547         const SmSym &rSym = aSymbols[i];
 548         DBG_ASSERT( rSym.Name.Len() > 0, "symbol without name!" );
 549         if (rSym.Name.Len() > 0)
 550         {
 551             SmSymSet *pSymSet = 0;
 552             const String &rSetName = rSym.GetSetName();
 553             USHORT nSetPos = GetSymbolSetPos( rSetName );
 554             if (SYMBOLSET_NONE != nSetPos)
 555                 pSymSet = GetSymbolSet( nSetPos );
 556             else
 557             {
 558                 pSymSet = new SmSymSet( rSetName );
 559                 AddSymbolSet( pSymSet );
 560             }
 561
 562             pSymSet->AddSymbol( new SmSym( rSym ) );
 563         }
 564     }
 565     // build HashTables
 566     INT32 nSymbolSetCount = GetSymbolSetCount();
 567     for (i = 0;  i < nSymbolSetCount;  ++i)
 568         ChangeSymbolSet( GetSymbolSet( i ) );
 569
 570     if (0 == nSymbolCount)
 571     {
 572         DBG_ERROR( "no symbol set found" );
 573         pImpl->Modified = FALSE;
 574     }
 575 }
 576
 577 void SmSymSetManager::Save()
 578 {
 579     SmMathConfig &rCfg = *SM_MOD1()->GetConfig();
 580
 581     // get number of Symbols
 582     USHORT nSymbolCount = 0;
 583     USHORT nSetCount = GetSymbolSetCount();
 584     USHORT i;
 585     for (i = 0;  i < nSetCount;  ++i)
 586         nSymbolCount = nSymbolCount + GetSymbolSet( i )->GetCount();
 587
 588     if (nSymbolCount)
 589     {
 590         USHORT nSaveSymbolCnt = 0;
 591         const SmSym **pSymbols = new const SmSym* [ nSymbolCount ];
 592         const SmSym **pSym = pSymbols;
 593         for (i = 0;  i < nSetCount;  ++i)
 594         {
 595             const SmSymSet *pSymSet = GetSymbolSet( i );
 596             USHORT n = pSymSet->GetCount();
 597             for (USHORT j = 0;  j < n;  ++j)
 598             {
 599                 const SmSym &rSym = pSymSet->GetSymbol( j );
 600                 if (!rSym.IsDocSymbol())
 601                 {
 602                     *pSym++ = &rSym;
 603                     ++nSaveSymbolCnt;
 604                 }
 605             }
 606         }
 607         DBG_ASSERT(pSym - pSymbols == nSaveSymbolCnt, "wrong number of symbols" );
 608
 609         std::vector< SmSym > aSymbols;
 610         GetSymbols( aSymbols );
 611         rCfg.SetSymbols( aSymbols );
 612         delete [] pSymbols;
 613     }
 614 }
 615
 616