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