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