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