starmath/source/cfgitem.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_starmath.hxx"
  30
  31
  32 #include <vcl/svapp.hxx>
  33
  34 #include "cfgitem.hxx"
  35
  36 #include "starmath.hrc"
  37 #include "smdll.hxx"
  38 #include "format.hxx"
  39
  40 using namespace rtl;
  41 using namespace com::sun::star;
  42 using namespace com::sun::star::uno;
  43 using namespace com::sun::star::beans;
  44
  45
  46 static const char* aRootName = "Office.Math";
  47
  48 #define SYMBOL_LIST         "SymbolList"
  49 #define FONT_FORMAT_LIST    "FontFormatList"
  50
  51 SV_IMPL_OBJARR( SmFntFmtListEntryArr, SmFntFmtListEntry );
  52
  53 /////////////////////////////////////////////////////////////////
  54
  55
  56 static Sequence< OUString > lcl_GetFontPropertyNames()
  57 {
  58     static const char * aPropNames[] =
  59     {
  60         "Name",
  61         "CharSet",
  62         "Family",
  63         "Pitch",
  64         "Weight",
  65         "Italic",
  66         0
  67     };
  68
  69     const char** ppPropName = aPropNames;
  70
  71     Sequence< OUString > aNames( 6 );
  72     OUString *pNames = aNames.getArray();
  73     for( INT32 i = 0; *ppPropName;  ++i, ++ppPropName )
  74     {
  75         pNames[i] = A2OU( *ppPropName );
  76     }
  77     //aNames.realloc( i );
  78     return aNames;
  79 }
  80
  81 /////////////////////////////////////////////////////////////////
  82
  83
  84 static Sequence< OUString > lcl_GetSymbolPropertyNames()
  85 {
  86     static const char * aPropNames[] =
  87     {
  88         "Char",
  89         "Set",
  90         "Predefined",
  91         "FontFormatId",
  92         0
  93     };
  94
  95     const char** ppPropName = aPropNames;
  96
  97     Sequence< OUString > aNames( 4 );
  98     OUString *pNames = aNames.getArray();
  99     for( INT32 i = 0; *ppPropName;  ++i, ++ppPropName )
 100     {
 101         pNames[i] = A2OU( *ppPropName );
 102     }
 103     //aNames.realloc( i );
 104     return aNames;
 105 }
 106
 107 /////////////////////////////////////////////////////////////////
 108
 109 static const char * aMathPropNames[] =
 110 {
 111     "Print/Title",
 112     "Print/FormulaText",
 113     "Print/Frame",
 114     "Print/Size",
 115     "Print/ZoomFactor",
 116     //"Misc/NoSymbolsWarning",
 117     "Misc/IgnoreSpacesRight",
 118     "View/ToolboxVisible",
 119     "View/AutoRedraw",
 120     "View/FormulaCursor"
 121 };
 122
 123
 124 //! Beware of order according to *_BEGIN *_END defines in format.hxx !
 125 //! see respective load/save routines here
 126 static const char * aFormatPropNames[] =
 127 {
 128     "StandardFormat/Textmode",
 129     "StandardFormat/GreekCharStyle",
 130     "StandardFormat/ScaleNormalBracket",
 131     "StandardFormat/HorizontalAlignment",
 132     "StandardFormat/BaseSize",
 133     "StandardFormat/TextSize",
 134     "StandardFormat/IndexSize",
 135     "StandardFormat/FunctionSize",
 136     "StandardFormat/OperatorSize",
 137     "StandardFormat/LimitsSize",
 138     "StandardFormat/Distance/Horizontal",
 139     "StandardFormat/Distance/Vertical",
 140     "StandardFormat/Distance/Root",
 141     "StandardFormat/Distance/SuperScript",
 142     "StandardFormat/Distance/SubScript",
 143     "StandardFormat/Distance/Numerator",
 144     "StandardFormat/Distance/Denominator",
 145     "StandardFormat/Distance/Fraction",
 146     "StandardFormat/Distance/StrokeWidth",
 147     "StandardFormat/Distance/UpperLimit",
 148     "StandardFormat/Distance/LowerLimit",
 149     "StandardFormat/Distance/BracketSize",
 150     "StandardFormat/Distance/BracketSpace",
 151     "StandardFormat/Distance/MatrixRow",
 152     "StandardFormat/Distance/MatrixColumn",
 153     "StandardFormat/Distance/OrnamentSize",
 154     "StandardFormat/Distance/OrnamentSpace",
 155     "StandardFormat/Distance/OperatorSize",
 156     "StandardFormat/Distance/OperatorSpace",
 157     "StandardFormat/Distance/LeftSpace",
 158     "StandardFormat/Distance/RightSpace",
 159     "StandardFormat/Distance/TopSpace",
 160     "StandardFormat/Distance/BottomSpace",
 161     "StandardFormat/Distance/NormalBracketSize",
 162     "StandardFormat/VariableFont",
 163     "StandardFormat/FunctionFont",
 164     "StandardFormat/NumberFont",
 165     "StandardFormat/TextFont",
 166     "StandardFormat/SerifFont",
 167     "StandardFormat/SansFont",
 168     "StandardFormat/FixedFont"
 169 };
 170
 171
 172 static Sequence< OUString > lcl_GetPropertyNames(
 173         const char * aPropNames[], USHORT nCount )
 174 {
 175
 176     const char** ppPropName = aPropNames;
 177
 178     Sequence< OUString > aNames( nCount );
 179     OUString *pNames = aNames.getArray();
 180     for (INT32 i = 0;  i < nCount;  ++i, ++ppPropName)
 181     {
 182         pNames[i] = A2OU( *ppPropName );
 183     }
 184     //aNames.realloc( i );
 185     return aNames;
 186 }
 187
 188
 189 static Sequence< OUString > GetFormatPropertyNames()
 190 {
 191     USHORT nCnt = sizeof(aFormatPropNames) / sizeof(aFormatPropNames[0]);
 192     return lcl_GetPropertyNames( aFormatPropNames, nCnt );
 193 }
 194
 195
 196 static Sequence< OUString > GetOtherPropertyNames()
 197 {
 198     USHORT nCnt = sizeof(aMathPropNames) / sizeof(aMathPropNames[0]);
 199     return lcl_GetPropertyNames( aMathPropNames, nCnt );
 200 }
 201
 202 /////////////////////////////////////////////////////////////////
 203
 204 struct SmCfgOther
 205 {
 206     SmPrintSize     ePrintSize;
 207     USHORT          nPrintZoomFactor;
 208     BOOL            bPrintTitle;
 209     BOOL            bPrintFormulaText;
 210     BOOL            bPrintFrame;
 211     BOOL            bIgnoreSpacesRight;
 212     BOOL            bToolboxVisible;
 213     BOOL            bAutoRedraw;
 214     BOOL            bFormulaCursor;
 215     //BOOL            bNoSymbolsWarning;
 216
 217     SmCfgOther();
 218 };
 219
 220
 221 SmCfgOther::SmCfgOther()
 222 {
 223     ePrintSize          = PRINT_SIZE_NORMAL;
 224     nPrintZoomFactor    = 100;
 225     bPrintTitle         = bPrintFormulaText   =
 226     bPrintFrame         = bIgnoreSpacesRight  =
 227     bToolboxVisible     = bAutoRedraw         =
 228     bFormulaCursor      = /*bNoSymbolsWarning   =*/ TRUE;
 229 }
 230
 231 /////////////////////////////////////////////////////////////////
 232
 233
 234 SmFontFormat::SmFontFormat()
 235 {
 236     aName.AssignAscii( FONTNAME_MATH );
 237     nCharSet    = RTL_TEXTENCODING_UNICODE;
 238     nFamily     = FAMILY_DONTKNOW;
 239     nPitch      = PITCH_DONTKNOW;
 240     nWeight     = WEIGHT_DONTKNOW;
 241     nItalic     = ITALIC_NONE;
 242 }
 243
 244
 245 SmFontFormat::SmFontFormat( const Font &rFont )
 246 {
 247     aName       = rFont.GetName();
 248     nCharSet    = (INT16) rFont.GetCharSet();
 249     nFamily     = (INT16) rFont.GetFamily();
 250     nPitch      = (INT16) rFont.GetPitch();
 251     nWeight     = (INT16) rFont.GetWeight();
 252     nItalic     = (INT16) rFont.GetItalic();
 253 }
 254
 255
 256 const Font SmFontFormat::GetFont() const
 257 {
 258     Font aRes;
 259     aRes.SetName( aName );
 260     aRes.SetCharSet( (rtl_TextEncoding) nCharSet );
 261     aRes.SetFamily( (FontFamily) nFamily );
 262     aRes.SetPitch( (FontPitch) nPitch );
 263     aRes.SetWeight( (FontWeight) nWeight );
 264     aRes.SetItalic( (FontItalic) nItalic );
 265     return aRes;
 266 }
 267
 268
 269 BOOL SmFontFormat::operator == ( const SmFontFormat &rFntFmt ) const
 270 {
 271     return  aName    == rFntFmt.aName       &&
 272             nCharSet == rFntFmt.nCharSet    &&
 273             nFamily  == rFntFmt.nFamily     &&
 274             nPitch   == rFntFmt.nPitch      &&
 275             nWeight  == rFntFmt.nWeight     &&
 276             nItalic  == rFntFmt.nItalic;
 277 }
 278
 279
 280 /////////////////////////////////////////////////////////////////
 281
 282 SmFntFmtListEntry::SmFntFmtListEntry( const String &rId, const SmFontFormat &rFntFmt ) :
 283     aId     (rId),
 284     aFntFmt (rFntFmt)
 285 {
 286 }
 287
 288
 289 SmFontFormatList::SmFontFormatList()
 290 {
 291     bModified = FALSE;
 292 }
 293
 294
 295 void SmFontFormatList::Clear()
 296 {
 297     USHORT nCnt = aEntries.Count();
 298     if (nCnt)
 299     {
 300         aEntries.Remove( 0, nCnt );
 301         SetModified( TRUE );
 302     }
 303 }
 304
 305
 306 void SmFontFormatList::AddFontFormat( const String &rFntFmtId,
 307         const SmFontFormat &rFntFmt )
 308 {
 309     const SmFontFormat *pFntFmt = GetFontFormat( rFntFmtId );
 310     DBG_ASSERT( !pFntFmt, "FontFormatId already exists" );
 311     if (!pFntFmt)
 312     {
 313         SmFntFmtListEntry aEntry( rFntFmtId, rFntFmt );
 314         aEntries.Insert( aEntry, aEntries.Count() );
 315         SetModified( TRUE );
 316     }
 317 }
 318
 319
 320 void SmFontFormatList::RemoveFontFormat( const String &rFntFmtId )
 321 {
 322     USHORT nPos = 0xFFFF;
 323
 324     // search for entry
 325     USHORT nCnt = aEntries.Count();
 326     for (USHORT i = 0;  i < nCnt  &&  nPos == 0xFFFF;  ++i)
 327     {
 328         if (aEntries[i].aId == rFntFmtId)
 329             nPos = i;
 330     }
 331
 332     // remove entry if found
 333     if (nPos != 0xFFFF)
 334     {
 335         aEntries.Remove( nPos );
 336         SetModified( TRUE );
 337     }
 338 }
 339
 340
 341 const SmFontFormat * SmFontFormatList::GetFontFormat( const String &rFntFmtId ) const
 342 {
 343     SmFontFormat *pRes = 0;
 344
 345     USHORT nCnt = aEntries.Count();
 346     USHORT i;
 347     for (i = 0;  i < nCnt  &&  !pRes;  ++i)
 348     {
 349         if (aEntries[i].aId == rFntFmtId)
 350             pRes = &aEntries[i].aFntFmt;
 351     }
 352
 353     return pRes;
 354 }
 355
 356
 357
 358 const SmFontFormat * SmFontFormatList::GetFontFormat( USHORT nPos ) const
 359 {
 360     SmFontFormat *pRes = 0;
 361     if (nPos < aEntries.Count())
 362         pRes = &aEntries[ nPos ].aFntFmt;
 363     return pRes;
 364 }
 365
 366
 367 const String SmFontFormatList::GetFontFormatId( const SmFontFormat &rFntFmt ) const
 368 {
 369     String aRes;
 370
 371     USHORT nCnt = aEntries.Count();
 372     USHORT i;
 373     for (i = 0;  i < nCnt  &&  0 == aRes.Len();  ++i)
 374     {
 375         if (aEntries[i].aFntFmt == rFntFmt)
 376             aRes = aEntries[i].aId;
 377     }
 378
 379     return aRes;
 380 }
 381
 382
 383 const String SmFontFormatList::GetFontFormatId( const SmFontFormat &rFntFmt, BOOL bAdd )
 384 {
 385     String aRes( GetFontFormatId( rFntFmt) );
 386     if (0 == aRes.Len()  &&  bAdd)
 387     {
 388         aRes = GetNewFontFormatId();
 389         AddFontFormat( aRes, rFntFmt );
 390     }
 391     return aRes;
 392 }
 393
 394
 395 const String SmFontFormatList::GetFontFormatId( USHORT nPos ) const
 396 {
 397     String aRes;
 398     if (nPos < aEntries.Count())
 399         aRes = aEntries[nPos].aId;
 400     return aRes;
 401 }
 402
 403
 404 const String SmFontFormatList::GetNewFontFormatId() const
 405 {
 406     // returns first unused FormatId
 407
 408     String aRes;
 409
 410     String aPrefix( RTL_CONSTASCII_STRINGPARAM( "Id" ) );
 411     INT32 nCnt = GetCount();
 412     for (INT32 i = 1;  i <= nCnt + 1  &&  0 == aRes.Len();  ++i)
 413     {
 414         String aTmpId( aPrefix );
 415         aTmpId += String::CreateFromInt32( i );
 416         if (!GetFontFormat( aTmpId ))
 417             aRes = aTmpId;
 418     }
 419     DBG_ASSERT( 0 != aRes.Len(), "failed to create new FontFormatId" );
 420
 421     return aRes;
 422 }
 423
 424 /////////////////////////////////////////////////////////////////
 425
 426 SmMathConfig::SmMathConfig() :
 427     ConfigItem( String::CreateFromAscii( aRootName ))
 428 {
 429     pFormat         = 0;
 430     pOther          = 0;
 431     pFontFormatList = 0;
 432     pSymbolMgr      = 0;
 433
 434     bIsOtherModified = bIsFormatModified = FALSE;
 435 }
 436
 437
 438 SmMathConfig::~SmMathConfig()
 439 {
 440     Save();
 441     delete pFormat;
 442     delete pOther;
 443     delete pFontFormatList;
 444     delete pSymbolMgr;
 445 }
 446
 447
 448 void SmMathConfig::SetOtherModified( BOOL bVal )
 449 {
 450     bIsOtherModified = bVal;
 451 }
 452
 453
 454 void SmMathConfig::SetFormatModified( BOOL bVal )
 455 {
 456     bIsFormatModified = bVal;
 457 }
 458
 459
 460 void SmMathConfig::SetFontFormatListModified( BOOL bVal )
 461 {
 462     if (pFontFormatList)
 463         pFontFormatList->SetModified( bVal );
 464 }
 465
 466
 467 void SmMathConfig::ReadSymbol( SmSym &rSymbol,
 468                         const rtl::OUString &rSymbolName,
 469                         const rtl::OUString &rBaseNode ) const
 470 {
 471     Sequence< OUString > aNames = lcl_GetSymbolPropertyNames();
 472     INT32 nProps = aNames.getLength();
 473
 474     OUString aDelim( OUString::valueOf( (sal_Unicode) '/' ) );
 475     OUString *pName = aNames.getArray();
 476     for (INT32 i = 0;  i < nProps;  ++i)
 477     {
 478         OUString &rName = pName[i];
 479         OUString aTmp( rName );
 480         rName = rBaseNode;
 481         rName += aDelim;
 482         rName += rSymbolName;
 483         rName += aDelim;
 484         rName += aTmp;
 485     }
 486
 487     const Sequence< Any > aValues = ((SmMathConfig*) this)->GetProperties( aNames );
 488
 489     if (nProps  &&  aValues.getLength() == nProps)
 490     {
 491         const Any * pValue = aValues.getConstArray();
 492         Font        aFont;
 493         sal_Unicode cChar = '\0';
 494         String      aSet;
 495         BOOL        bPredefined = FALSE;
 496
 497         OUString    aTmpStr;
 498         INT32       nTmp32 = 0;
 499         BOOL        bTmp = FALSE;
 500
 501         BOOL bOK = TRUE;
 502         if (pValue->hasValue()  &&  (*pValue >>= nTmp32))
 503             cChar = (sal_Unicode) nTmp32;
 504         else
 505             bOK = FALSE;
 506         ++pValue;
 507         if (pValue->hasValue()  &&  (*pValue >>= aTmpStr))
 508             aSet = aTmpStr;
 509         else
 510             bOK = FALSE;
 511         ++pValue;
 512         if (pValue->hasValue()  &&  (*pValue >>= bTmp))
 513             bPredefined = bTmp;
 514         else
 515             bOK = FALSE;
 516         ++pValue;
 517         if (pValue->hasValue()  &&  (*pValue >>= aTmpStr))
 518         {
 519             const SmFontFormat *pFntFmt = GetFontFormatList().GetFontFormat( aTmpStr );
 520             DBG_ASSERT( pFntFmt, "unknown FontFormat" );
 521             if (pFntFmt)
 522                 aFont = pFntFmt->GetFont();
 523         }
 524         else
 525             bOK = FALSE;
 526         ++pValue;
 527
 528         if (bOK)
 529         {
 530             String aUiName( rSymbolName );
 531             String aUiSetName( aSet );
 532             if (bPredefined)
 533             {
 534                 String aTmp;
 535                 aTmp = GetUiSymbolName( rSymbolName );
 536                 DBG_ASSERT( aTmp.Len(), "localized symbol-name not found" );
 537                 if (aTmp.Len())
 538                     aUiName = aTmp;
 539                 aTmp = GetUiSymbolSetName( aSet );
 540                 DBG_ASSERT( aTmp.Len(), "localized symbolset-name not found" );
 541                 if (aTmp.Len())
 542                     aUiSetName = aTmp;
 543             }
 544
 545             rSymbol = SmSym( aUiName, aFont, cChar, aUiSetName, bPredefined );
 546             if (aUiName != String(rSymbolName))
 547                 rSymbol.SetExportName( rSymbolName );
 548         }
 549         else
 550         {
 551             DBG_ERROR( "symbol read error" );
 552         }
 553     }
 554 }
 555
 556
 557 SmSymbolManager & SmMathConfig::GetSymbolManager()
 558 {
 559     if (!pSymbolMgr)
 560     {
 561         pSymbolMgr = new SmSymbolManager;
 562         pSymbolMgr->Load();
 563     }
 564     return *pSymbolMgr;
 565 }
 566
 567
 568 void SmMathConfig::Commit()
 569 {
 570     Save();
 571 }
 572
 573
 574 void SmMathConfig::Save()
 575 {
 576     SaveOther();
 577     SaveFormat();
 578     SaveFontFormatList();
 579 }
 580
 581
 582 void SmMathConfig::GetSymbols( std::vector< SmSym > &rSymbols ) const
 583 {
 584     Sequence< OUString > aNodes( ((SmMathConfig*) this)->GetNodeNames( A2OU( SYMBOL_LIST ) ) );
 585     const OUString *pNode = aNodes.getConstArray();
 586     INT32 nNodes = aNodes.getLength();
 587
 588     rSymbols.resize( nNodes );
 589     std::vector< SmSym >::iterator aIt( rSymbols.begin() );
 590     std::vector< SmSym >::iterator aEnd( rSymbols.end() );
 591     while (aIt != aEnd)
 592     {
 593         ReadSymbol( *aIt++, *pNode++, A2OU( SYMBOL_LIST ) );
 594     }
 595 }
 596
 597
 598 void SmMathConfig::SetSymbols( const std::vector< SmSym > &rNewSymbols )
 599 {
 600     sal_uIntPtr nCount = rNewSymbols.size();
 601
 602     Sequence< OUString > aNames = lcl_GetSymbolPropertyNames();
 603     const OUString *pNames = aNames.getConstArray();
 604     sal_uIntPtr nSymbolProps = sal::static_int_cast< UINT32 >(aNames.getLength());
 605
 606     Sequence< PropertyValue > aValues( nCount * nSymbolProps );
 607     PropertyValue *pValues = aValues.getArray();
 608
 609     PropertyValue *pVal = pValues;
 610     OUString aDelim( OUString::valueOf( (sal_Unicode) '/' ) );
 611     std::vector< SmSym >::const_iterator aIt( rNewSymbols.begin() );
 612     std::vector< SmSym >::const_iterator aEnd( rNewSymbols.end() );
 613     while (aIt != aEnd)
 614     {
 615         const SmSym &rSymbol = *aIt++;
 616         //const Font  &rFont = rSymbol.GetFace();
 617         OUString  aNodeNameDelim( A2OU( SYMBOL_LIST ) );
 618         aNodeNameDelim += aDelim;
 619         aNodeNameDelim += rSymbol.GetExportName();
 620         aNodeNameDelim += aDelim;
 621
 622         const OUString *pName = pNames;
 623
 624         // Char
 625         pVal->Name  = aNodeNameDelim;
 626         pVal->Name += *pName++;
 627         pVal->Value <<= (INT32) rSymbol.GetCharacter();
 628         pVal++;
 629         // Set
 630         pVal->Name  = aNodeNameDelim;
 631         pVal->Name += *pName++;
 632         OUString aTmp( rSymbol.GetSymbolSetName() );
 633         if (rSymbol.IsPredefined())
 634             aTmp = GetExportSymbolSetName( aTmp );
 635         pVal->Value <<= aTmp;
 636         pVal++;
 637         // Predefined
 638         pVal->Name  = aNodeNameDelim;
 639         pVal->Name += *pName++;
 640         pVal->Value <<= (BOOL) rSymbol.IsPredefined();
 641         pVal++;
 642         // FontFormatId
 643         SmFontFormat aFntFmt( rSymbol.GetFace() );
 644         String aFntFmtId( GetFontFormatList().GetFontFormatId( aFntFmt, TRUE ) );
 645         DBG_ASSERT( aFntFmtId.Len(), "FontFormatId not found" );
 646         pVal->Name  = aNodeNameDelim;
 647         pVal->Name += *pName++;
 648         pVal->Value <<= OUString( aFntFmtId );
 649         pVal++;
 650     }
 651     DBG_ASSERT( pVal - pValues == sal::static_int_cast< ptrdiff_t >(nCount * nSymbolProps), "properties missing" );
 652     ReplaceSetProperties( A2OU( SYMBOL_LIST ) , aValues );
 653
 654     StripFontFormatList( rNewSymbols );
 655     SaveFontFormatList();
 656 }
 657
 658
 659 SmFontFormatList & SmMathConfig::GetFontFormatList()
 660 {
 661     if (!pFontFormatList)
 662     {
 663         LoadFontFormatList();
 664     }
 665     return *pFontFormatList;
 666 }
 667
 668
 669 void SmMathConfig::LoadFontFormatList()
 670 {
 671     if (!pFontFormatList)
 672         pFontFormatList = new SmFontFormatList;
 673     else
 674         pFontFormatList->Clear();
 675
 676     Sequence< OUString > aNodes( GetNodeNames( A2OU( FONT_FORMAT_LIST ) ) );
 677     const OUString *pNode = aNodes.getConstArray();
 678     INT32 nNodes = aNodes.getLength();
 679
 680     for (INT32 i = 0;  i < nNodes;  ++i)
 681     {
 682         SmFontFormat aFntFmt;
 683         ReadFontFormat( aFntFmt, pNode[i], A2OU( FONT_FORMAT_LIST ) );
 684         if (!pFontFormatList->GetFontFormat( pNode[i] ))
 685         {
 686             DBG_ASSERT( 0 == pFontFormatList->GetFontFormat( pNode[i] ),
 687                     "FontFormat ID already exists" );
 688             pFontFormatList->AddFontFormat( pNode[i], aFntFmt );
 689         }
 690     }
 691     pFontFormatList->SetModified( FALSE );
 692 }
 693
 694
 695 void SmMathConfig::ReadFontFormat( SmFontFormat &rFontFormat,
 696         const OUString &rSymbolName, const OUString &rBaseNode ) const
 697 {
 698     Sequence< OUString > aNames = lcl_GetFontPropertyNames();
 699     INT32 nProps = aNames.getLength();
 700
 701     OUString aDelim( OUString::valueOf( (sal_Unicode) '/' ) );
 702     OUString *pName = aNames.getArray();
 703     for (INT32 i = 0;  i < nProps;  ++i)
 704     {
 705         OUString &rName = pName[i];
 706         OUString aTmp( rName );
 707         rName = rBaseNode;
 708         rName += aDelim;
 709         rName += rSymbolName;
 710         rName += aDelim;
 711         rName += aTmp;
 712     }
 713
 714     const Sequence< Any > aValues = ((SmMathConfig*) this)->GetProperties( aNames );
 715
 716     if (nProps  &&  aValues.getLength() == nProps)
 717     {
 718         const Any * pValue = aValues.getConstArray();
 719
 720         OUString    aTmpStr;
 721         INT16       nTmp16 = 0;
 722
 723         BOOL bOK = TRUE;
 724         if (pValue->hasValue()  &&  (*pValue >>= aTmpStr))
 725             rFontFormat.aName = aTmpStr;
 726         else
 727             bOK = FALSE;
 728         ++pValue;
 729         if (pValue->hasValue()  &&  (*pValue >>= nTmp16))
 730             rFontFormat.nCharSet = nTmp16; // 6.0 file-format GetSOLoadTextEncoding not needed
 731         else
 732             bOK = FALSE;
 733         ++pValue;
 734         if (pValue->hasValue()  &&  (*pValue >>= nTmp16))
 735             rFontFormat.nFamily = nTmp16;
 736         else
 737             bOK = FALSE;
 738         ++pValue;
 739         if (pValue->hasValue()  &&  (*pValue >>= nTmp16))
 740             rFontFormat.nPitch = nTmp16;
 741         else
 742             bOK = FALSE;
 743         ++pValue;
 744         if (pValue->hasValue()  &&  (*pValue >>= nTmp16))
 745             rFontFormat.nWeight = nTmp16;
 746         else
 747             bOK = FALSE;
 748         ++pValue;
 749         if (pValue->hasValue()  &&  (*pValue >>= nTmp16))
 750             rFontFormat.nItalic = nTmp16;
 751         else
 752             bOK = FALSE;
 753         ++pValue;
 754
 755         DBG_ASSERT( bOK, "read FontFormat failed" );
 756     }
 757 }
 758
 759
 760 void SmMathConfig::SaveFontFormatList()
 761 {
 762     SmFontFormatList &rFntFmtList = GetFontFormatList();
 763
 764     if (!rFntFmtList.IsModified())
 765         return;
 766
 767     Sequence< OUString > aNames = lcl_GetFontPropertyNames();
 768     INT32 nSymbolProps = aNames.getLength();
 769
 770     USHORT nCount = rFntFmtList.GetCount();
 771
 772     Sequence< PropertyValue > aValues( nCount * nSymbolProps );
 773     PropertyValue *pValues = aValues.getArray();
 774
 775     PropertyValue *pVal = pValues;
 776     OUString aDelim( OUString::valueOf( (sal_Unicode) '/' ) );
 777     for (USHORT i = 0;  i < nCount;  ++i)
 778     {
 779         String aFntFmtId( rFntFmtList.GetFontFormatId( i ) );
 780         const SmFontFormat aFntFmt( *rFntFmtList.GetFontFormat( aFntFmtId ) );
 781
 782         OUString  aNodeNameDelim( A2OU( FONT_FORMAT_LIST ) );
 783         aNodeNameDelim += aDelim;
 784         aNodeNameDelim += aFntFmtId;
 785         aNodeNameDelim += aDelim;
 786
 787         const OUString *pName = aNames.getConstArray();;
 788
 789         // Name
 790         pVal->Name  = aNodeNameDelim;
 791         pVal->Name += *pName++;
 792         pVal->Value <<= OUString( aFntFmt.aName );
 793         pVal++;
 794         // CharSet
 795         pVal->Name  = aNodeNameDelim;
 796         pVal->Name += *pName++;
 797         pVal->Value <<= (INT16) aFntFmt.nCharSet; // 6.0 file-format GetSOStoreTextEncoding not needed
 798         pVal++;
 799         // Family
 800         pVal->Name  = aNodeNameDelim;
 801         pVal->Name += *pName++;
 802         pVal->Value <<= (INT16) aFntFmt.nFamily;
 803         pVal++;
 804         // Pitch
 805         pVal->Name  = aNodeNameDelim;
 806         pVal->Name += *pName++;
 807         pVal->Value <<= (INT16) aFntFmt.nPitch;
 808         pVal++;
 809         // Weight
 810         pVal->Name  = aNodeNameDelim;
 811         pVal->Name += *pName++;
 812         pVal->Value <<= (INT16) aFntFmt.nWeight;
 813         pVal++;
 814         // Italic
 815         pVal->Name  = aNodeNameDelim;
 816         pVal->Name += *pName++;
 817         pVal->Value <<= (INT16) aFntFmt.nItalic;
 818         pVal++;
 819     }
 820     DBG_ASSERT( pVal - pValues == nCount * nSymbolProps, "properties missing" );
 821     ReplaceSetProperties( A2OU( FONT_FORMAT_LIST ) , aValues );
 822
 823     rFntFmtList.SetModified( FALSE );
 824 }
 825
 826
 827 void SmMathConfig::StripFontFormatList( const std::vector< SmSym > &rSymbols )
 828 {
 829     size_t nCount = rSymbols.size();
 830     USHORT i;
 831
 832     // build list of used font-formats only
 833     //!! font-format IDs may be different !!
 834     SmFontFormatList aUsedList;
 835     for (i = 0;  i < nCount;  ++i)
 836     {
 837         DBG_ASSERT( rSymbols[i].GetName().Len() > 0, "non named symbol" );
 838         aUsedList.GetFontFormatId( SmFontFormat( rSymbols[i].GetFace() ) , TRUE );
 839     }
 840     const SmFormat & rStdFmt = GetStandardFormat();
 841     for (i = FNT_BEGIN;  i <= FNT_END;  ++i)
 842     {
 843         aUsedList.GetFontFormatId( SmFontFormat( rStdFmt.GetFont( i ) ) , TRUE );
 844     }
 845
 846     // remove unused font-formats from list
 847     SmFontFormatList &rFntFmtList = GetFontFormatList();
 848     USHORT nCnt = rFntFmtList.GetCount();
 849     SmFontFormat *pTmpFormat = new SmFontFormat[ nCnt ];
 850     String       *pId     = new String      [ nCnt ];
 851     INT32 k;
 852     for (k = 0;  k < nCnt;  ++k)
 853     {
 854         pTmpFormat[k] = *rFntFmtList.GetFontFormat( (USHORT) k );
 855         pId[k]     = rFntFmtList.GetFontFormatId( (USHORT) k );
 856     }
 857     for (k = 0;  k < nCnt;  ++k)
 858     {
 859         if (0 == aUsedList.GetFontFormatId( pTmpFormat[k] ).Len())
 860         {
 861             rFntFmtList.RemoveFontFormat( pId[k] );
 862         }
 863     }
 864     delete [] pId;
 865     delete [] pTmpFormat;
 866 }
 867
 868
 869 void SmMathConfig::LoadOther()
 870 {
 871     if (!pOther)
 872         pOther = new SmCfgOther;
 873
 874     Sequence< OUString > aNames( GetOtherPropertyNames() );
 875     INT32 nProps = aNames.getLength();
 876
 877     Sequence< Any > aValues( GetProperties( aNames ) );
 878     if (nProps  &&  aValues.getLength() == nProps)
 879     {
 880         const Any *pValues = aValues.getConstArray();
 881         const Any *pVal = pValues;
 882
 883         INT16   nTmp16 = 0;
 884         BOOL    bTmp = FALSE;
 885
 886         // Print/Title
 887         if (pVal->hasValue()  &&  (*pVal >>= bTmp))
 888             pOther->bPrintTitle = bTmp;
 889         ++pVal;
 890         // Print/FormulaText
 891         if (pVal->hasValue()  &&  (*pVal >>= bTmp))
 892             pOther->bPrintFormulaText = bTmp;
 893         ++pVal;
 894         // Print/Frame
 895         if (pVal->hasValue()  &&  (*pVal >>= bTmp))
 896             pOther->bPrintFrame = bTmp;
 897         ++pVal;
 898         // Print/Size
 899         if (pVal->hasValue()  &&  (*pVal >>= nTmp16))
 900             pOther->ePrintSize = (SmPrintSize) nTmp16;
 901         ++pVal;
 902         // Print/ZoomFactor
 903         if (pVal->hasValue()  &&  (*pVal >>= nTmp16))
 904             pOther->nPrintZoomFactor = nTmp16;
 905 /*        ++pVal;
 906         // Misc/NoSymbolsWarning
 907         if (pVal->hasValue()  &&  (*pVal >>= bTmp))
 908             pOther->bNoSymbolsWarning = bTmp;
 909 */
 910         ++pVal;
 911         // Misc/IgnoreSpacesRight
 912         if (pVal->hasValue()  &&  (*pVal >>= bTmp))
 913             pOther->bIgnoreSpacesRight = bTmp;
 914         ++pVal;
 915         // View/ToolboxVisible
 916         if (pVal->hasValue()  &&  (*pVal >>= bTmp))
 917             pOther->bToolboxVisible = bTmp;
 918         ++pVal;
 919         // View/AutoRedraw
 920         if (pVal->hasValue()  &&  (*pVal >>= bTmp))
 921             pOther->bAutoRedraw = bTmp;
 922         ++pVal;
 923         // View/FormulaCursor
 924         if (pVal->hasValue()  &&  (*pVal >>= bTmp))
 925             pOther->bFormulaCursor = bTmp;
 926         ++pVal;
 927
 928         DBG_ASSERT( pVal - pValues == nProps, "property mismatch" );
 929         SetOtherModified( FALSE );
 930     }
 931 }
 932
 933
 934 void SmMathConfig::SaveOther()
 935 {
 936     if (!pOther || !IsOtherModified())
 937         return;
 938
 939     const Sequence< OUString > aNames( GetOtherPropertyNames() );
 940     INT32 nProps = aNames.getLength();
 941
 942     Sequence< Any > aValues( nProps );
 943     Any *pValues = aValues.getArray();
 944     Any *pValue  = pValues;
 945
 946     // Print/Title
 947     *pValue++ <<= (BOOL) pOther->bPrintTitle;
 948     // Print/FormulaText
 949     *pValue++ <<= (BOOL) pOther->bPrintFormulaText;
 950     // Print/Frame
 951     *pValue++ <<= (BOOL) pOther->bPrintFrame;
 952     // Print/Size
 953     *pValue++ <<= (INT16) pOther->ePrintSize;
 954     // Print/ZoomFactor
 955     *pValue++ <<= (INT16) pOther->nPrintZoomFactor;
 956 /*    // Misc/NoSymbolsWarning
 957     *pValue++ <<= (BOOL) pOther->bNoSymbolsWarning;
 958 */
 959     // Misc/IgnoreSpacesRight
 960     *pValue++ <<= (BOOL) pOther->bIgnoreSpacesRight;
 961     // View/ToolboxVisible
 962     *pValue++ <<= (BOOL) pOther->bToolboxVisible;
 963     // View/AutoRedraw
 964     *pValue++ <<= (BOOL) pOther->bAutoRedraw;
 965     // View/FormulaCursor
 966     *pValue++ <<= (BOOL) pOther->bFormulaCursor;
 967
 968     DBG_ASSERT( pValue - pValues == nProps, "property mismatch" );
 969     PutProperties( aNames , aValues );
 970
 971     SetOtherModified( FALSE );
 972 }
 973
 974 void SmMathConfig::LoadFormat()
 975 {
 976     if (!pFormat)
 977         pFormat = new SmFormat;
 978
 979
 980     Sequence< OUString > aNames( GetFormatPropertyNames() );
 981     INT32 nProps = aNames.getLength();
 982
 983     Sequence< Any > aValues( GetProperties( aNames ) );
 984     if (nProps  &&  aValues.getLength() == nProps)
 985     {
 986         const Any *pValues = aValues.getConstArray();
 987         const Any *pVal = pValues;
 988
 989         OUString    aTmpStr;
 990         INT16       nTmp16 = 0;
 991         BOOL        bTmp = FALSE;
 992
 993         // StandardFormat/Textmode
 994         if (pVal->hasValue()  &&  (*pVal >>= bTmp))
 995             pFormat->SetTextmode( bTmp );
 996         ++pVal;
 997         // StandardFormat/GreekCharStyle
 998         if (pVal->hasValue()  &&  (*pVal >>= nTmp16))
 999             pFormat->SetGreekCharStyle( nTmp16 );
1000         ++pVal;
1001         // StandardFormat/ScaleNormalBracket
1002         if (pVal->hasValue()  &&  (*pVal >>= bTmp))
1003             pFormat->SetScaleNormalBrackets( bTmp );
1004         ++pVal;
1005         // StandardFormat/HorizontalAlignment
1006         if (pVal->hasValue()  &&  (*pVal >>= nTmp16))
1007             pFormat->SetHorAlign( (SmHorAlign) nTmp16 );
1008         ++pVal;
1009         // StandardFormat/BaseSize
1010         if (pVal->hasValue()  &&  (*pVal >>= nTmp16))
1011             pFormat->SetBaseSize( Size(0, SmPtsTo100th_mm( nTmp16 )) );
1012         ++pVal;
1013
1014         USHORT i;
1015         for (i = SIZ_BEGIN;  i <= SIZ_END;  ++i)
1016         {
1017             if (pVal->hasValue()  &&  (*pVal >>= nTmp16))
1018                 pFormat->SetRelSize( i, nTmp16 );
1019             ++pVal;
1020         }
1021
1022         for (i = DIS_BEGIN;  i <= DIS_END;  ++i)
1023         {
1024             if (pVal->hasValue()  &&  (*pVal >>= nTmp16))
1025                 pFormat->SetDistance( i, nTmp16 );
1026             ++pVal;
1027         }
1028
1029         LanguageType nLang = Application::GetSettings().GetUILanguage();
1030         for (i = FNT_BEGIN;  i < FNT_END;  ++i)
1031         {
1032             Font aFnt;
1033             BOOL bUseDefaultFont = TRUE;
1034             if (pVal->hasValue()  &&  (*pVal >>= aTmpStr))
1035             {
1036                 bUseDefaultFont = 0 == aTmpStr.getLength();
1037                 if (bUseDefaultFont)
1038                 {
1039                     aFnt = pFormat->GetFont( i );
1040                     aFnt.SetName( GetDefaultFontName( nLang, i ) );
1041                 }
1042                 else
1043                 {
1044                     const SmFontFormat *pFntFmt = GetFontFormatList().GetFontFormat( aTmpStr );
1045                     DBG_ASSERT( pFntFmt, "unknown FontFormat" );
1046                     if (pFntFmt)
1047                         aFnt = pFntFmt->GetFont();
1048                 }
1049             }
1050             ++pVal;
1051
1052             aFnt.SetSize( pFormat->GetBaseSize() );
1053             pFormat->SetFont( i, aFnt, bUseDefaultFont );
1054         }
1055
1056         DBG_ASSERT( pVal - pValues == nProps, "property mismatch" );
1057         SetFormatModified( FALSE );
1058     }
1059 }
1060
1061
1062 void SmMathConfig::SaveFormat()
1063 {
1064     if (!pFormat || !IsFormatModified())
1065         return;
1066
1067     const Sequence< OUString > aNames( GetFormatPropertyNames() );
1068     INT32 nProps = aNames.getLength();
1069
1070     Sequence< Any > aValues( nProps );
1071     Any *pValues = aValues.getArray();
1072     Any *pValue  = pValues;
1073
1074     // StandardFormat/Textmode
1075     *pValue++ <<= (BOOL) pFormat->IsTextmode();
1076     // StandardFormat/GreekCharStyle
1077     *pValue++ <<= (INT16) pFormat->GetGreekCharStyle();
1078     // StandardFormat/ScaleNormalBracket
1079     *pValue++ <<= (BOOL) pFormat->IsScaleNormalBrackets();
1080     // StandardFormat/HorizontalAlignment
1081     *pValue++ <<= (INT16) pFormat->GetHorAlign();
1082     // StandardFormat/BaseSize
1083     *pValue++ <<= (INT16) SmRoundFraction( Sm100th_mmToPts(
1084                                     pFormat->GetBaseSize().Height() ) );
1085
1086     USHORT i;
1087     for (i = SIZ_BEGIN;  i <= SIZ_END;  ++i)
1088         *pValue++ <<= (INT16) pFormat->GetRelSize( i );
1089
1090     for (i = DIS_BEGIN;  i <= DIS_END;  ++i)
1091         *pValue++ <<= (INT16) pFormat->GetDistance( i );
1092
1093     for (i = FNT_BEGIN;  i < FNT_END;  ++i)
1094     {
1095         OUString aFntFmtId;
1096
1097         if (!pFormat->IsDefaultFont( i ))
1098         {
1099             SmFontFormat aFntFmt( pFormat->GetFont( i ) );
1100             aFntFmtId = GetFontFormatList().GetFontFormatId( aFntFmt, TRUE );
1101             DBG_ASSERT( aFntFmtId.getLength(), "FontFormatId not found" );
1102         }
1103
1104         *pValue++ <<= aFntFmtId;
1105     }
1106
1107     DBG_ASSERT( pValue - pValues == nProps, "property mismatch" );
1108     PutProperties( aNames , aValues );
1109
1110     SetFormatModified( FALSE );
1111 }
1112
1113
1114 const SmFormat & SmMathConfig::GetStandardFormat() const
1115 {
1116     if (!pFormat)
1117         ((SmMathConfig *) this)->LoadFormat();
1118     return *pFormat;
1119 }
1120
1121
1122 void SmMathConfig::SetStandardFormat( const SmFormat &rFormat, BOOL bSaveFontFormatList )
1123 {
1124     if (!pFormat)
1125         LoadFormat();
1126     if (rFormat != *pFormat)
1127     {
1128         *pFormat = rFormat;
1129         SetFormatModified( TRUE );
1130         SaveFormat();
1131
1132         if (bSaveFontFormatList)
1133         {
1134             // needed for SmFontTypeDialog's DefaultButtonClickHdl
1135             SetFontFormatListModified( TRUE );
1136             SaveFontFormatList();
1137         }
1138     }
1139 }
1140
1141
1142 SmPrintSize SmMathConfig::GetPrintSize() const
1143 {
1144     if (!pOther)
1145         ((SmMathConfig *) this)->LoadOther();
1146     return pOther->ePrintSize;
1147 }
1148
1149
1150 void SmMathConfig::SetPrintSize( SmPrintSize eSize )
1151 {
1152     if (!pOther)
1153         LoadOther();
1154     if (eSize != pOther->ePrintSize)
1155     {
1156         pOther->ePrintSize = eSize;
1157         SetOtherModified( TRUE );
1158     }
1159 }
1160
1161
1162 USHORT SmMathConfig::GetPrintZoomFactor() const
1163 {
1164     if (!pOther)
1165         ((SmMathConfig *) this)->LoadOther();
1166     return pOther->nPrintZoomFactor;
1167 }
1168
1169
1170 void SmMathConfig::SetPrintZoomFactor( USHORT nVal )
1171 {
1172     if (!pOther)
1173         LoadOther();
1174     if (nVal != pOther->nPrintZoomFactor)
1175     {
1176         pOther->nPrintZoomFactor = nVal;
1177         SetOtherModified( TRUE );
1178     }
1179 }
1180
1181
1182 void SmMathConfig::SetOtherIfNotEqual( BOOL &rbItem, BOOL bNewVal )
1183 {
1184     if (bNewVal != rbItem)
1185     {
1186         rbItem = bNewVal;
1187         SetOtherModified( TRUE );
1188     }
1189 }
1190
1191
1192 BOOL SmMathConfig::IsPrintTitle() const
1193 {
1194     if (!pOther)
1195         ((SmMathConfig *) this)->LoadOther();
1196     return pOther->bPrintTitle;
1197 }
1198
1199
1200 void SmMathConfig::SetPrintTitle( BOOL bVal )
1201 {
1202     if (!pOther)
1203         LoadOther();
1204     SetOtherIfNotEqual( pOther->bPrintTitle, bVal );
1205 }
1206
1207
1208 BOOL SmMathConfig::IsPrintFormulaText() const
1209 {
1210     if (!pOther)
1211         ((SmMathConfig *) this)->LoadOther();
1212     return pOther->bPrintFormulaText;
1213 }
1214
1215
1216 void SmMathConfig::SetPrintFormulaText( BOOL bVal )
1217 {
1218     if (!pOther)
1219         LoadOther();
1220     SetOtherIfNotEqual( pOther->bPrintFormulaText, bVal );
1221 }
1222
1223
1224 BOOL SmMathConfig::IsPrintFrame() const
1225 {
1226     if (!pOther)
1227         ((SmMathConfig *) this)->LoadOther();
1228     return pOther->bPrintFrame;
1229 }
1230
1231
1232 void SmMathConfig::SetPrintFrame( BOOL bVal )
1233 {
1234     if (!pOther)
1235         LoadOther();
1236     SetOtherIfNotEqual( pOther->bPrintFrame, bVal );
1237 }
1238
1239
1240 BOOL SmMathConfig::IsIgnoreSpacesRight() const
1241 {
1242     if (!pOther)
1243         ((SmMathConfig *) this)->LoadOther();
1244     return pOther->bIgnoreSpacesRight;
1245 }
1246
1247
1248 void SmMathConfig::SetIgnoreSpacesRight( BOOL bVal )
1249 {
1250     if (!pOther)
1251         LoadOther();
1252     SetOtherIfNotEqual( pOther->bIgnoreSpacesRight, bVal );
1253 }
1254
1255
1256 BOOL SmMathConfig::IsAutoRedraw() const
1257 {
1258     if (!pOther)
1259         ((SmMathConfig *) this)->LoadOther();
1260     return pOther->bAutoRedraw;
1261 }
1262
1263
1264 void SmMathConfig::SetAutoRedraw( BOOL bVal )
1265 {
1266     if (!pOther)
1267         LoadOther();
1268     SetOtherIfNotEqual( pOther->bAutoRedraw, bVal );
1269 }
1270
1271
1272 BOOL SmMathConfig::IsShowFormulaCursor() const
1273 {
1274     if (!pOther)
1275         ((SmMathConfig *) this)->LoadOther();
1276     return pOther->bFormulaCursor;
1277 }
1278
1279
1280 void SmMathConfig::SetShowFormulaCursor( BOOL bVal )
1281 {
1282     if (!pOther)
1283         LoadOther();
1284     SetOtherIfNotEqual( pOther->bFormulaCursor, bVal );
1285 }
1286
1287 void SmMathConfig::Notify( const com::sun::star::uno::Sequence< rtl::OUString >& )
1288 {}
1289
1290 /////////////////////////////////////////////////////////////////
1291