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 "tools/rcid.h"
21 : #include <comphelper/string.hxx>
22 : #include <svl/eitem.hxx>
23 : #include <svl/intitem.hxx>
24 : #include <svl/stritem.hxx>
25 : #include <sfx2/app.hxx>
26 : #include <vcl/builderfactory.hxx>
27 : #include <vcl/layout.hxx>
28 : #include <vcl/msgbox.hxx>
29 : #include <svtools/ctrltool.hxx>
30 : #include <sfx2/printer.hxx>
31 : #include <vcl/help.hxx>
32 : #include <vcl/waitobj.hxx>
33 : #include <vcl/settings.hxx>
34 : #include <vcl/wall.hxx>
35 : #include <sfx2/dispatch.hxx>
36 : #include <sfx2/sfx.hrc>
37 : #include <osl/diagnose.h>
38 : #include <svx/ucsubset.hxx>
39 :
40 : #include "dialog.hxx"
41 : #include "starmath.hrc"
42 : #include "cfgitem.hxx"
43 : #include "smmod.hxx"
44 : #include "symbol.hxx"
45 : #include "view.hxx"
46 : #include "document.hxx"
47 : #include "unomodel.hxx"
48 :
49 :
50 : namespace
51 : {
52 :
53 0 : void lclGetSettingColors(Color& rBackgroundColor, Color& rTextColor)
54 : {
55 0 : const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
56 0 : if (rStyleSettings.GetHighContrastMode())
57 : {
58 0 : rBackgroundColor = rStyleSettings.GetFieldColor().GetColor();
59 0 : rTextColor = rStyleSettings.GetFieldTextColor().GetColor();
60 : }
61 : else
62 : {
63 0 : rBackgroundColor = COL_WHITE;
64 0 : rTextColor = COL_BLACK;
65 : }
66 0 : }
67 :
68 : } // end anonymous namespace
69 :
70 : // Since it's better to set/query the FontStyle via its attributes rather
71 : // than via the StyleName we create a way to translate
72 : // Attribute <-> StyleName
73 :
74 0 : class SmFontStyles
75 : {
76 : OUString aNormal;
77 : OUString aBold;
78 : OUString aItalic;
79 : OUString aBoldItalic;
80 : OUString aEmpty;
81 :
82 : public:
83 : SmFontStyles();
84 :
85 0 : static sal_uInt16 GetCount() { return 4; }
86 : const OUString& GetStyleName(const vcl::Font& rFont) const;
87 : const OUString& GetStyleName(sal_uInt16 nIdx) const;
88 : };
89 :
90 0 : SmFontStyles::SmFontStyles() :
91 0 : aNormal (ResId(RID_FONTREGULAR, *SM_MOD()->GetResMgr())),
92 0 : aBold (ResId(RID_FONTBOLD, *SM_MOD()->GetResMgr())),
93 0 : aItalic (ResId(RID_FONTITALIC, *SM_MOD()->GetResMgr()))
94 : {
95 :
96 0 : aBoldItalic = aBold;
97 0 : aBoldItalic += ", ";
98 0 : aBoldItalic += aItalic;
99 0 : }
100 :
101 0 : const OUString& SmFontStyles::GetStyleName(const vcl::Font& rFont) const
102 : {
103 : //! compare also SmSpecialNode::Prepare
104 0 : bool bBold = IsBold( rFont ),
105 0 : bItalic = IsItalic( rFont );
106 :
107 0 : if (bBold && bItalic)
108 0 : return aBoldItalic;
109 0 : else if (bItalic)
110 0 : return aItalic;
111 0 : else if (bBold)
112 0 : return aBold;
113 0 : return aNormal;
114 : }
115 :
116 0 : const OUString& SmFontStyles::GetStyleName( sal_uInt16 nIdx ) const
117 : {
118 : // 0 = "normal", 1 = "italic",
119 : // 2 = "bold", 3 = "bold italic"
120 :
121 : #if OSL_DEBUG_LEVEL > 1
122 : OSL_ENSURE( nIdx < GetCount(), "index out of range" );
123 : #endif
124 0 : switch (nIdx)
125 : {
126 0 : case 0 : return aNormal;
127 0 : case 1 : return aItalic;
128 0 : case 2 : return aBold;
129 0 : case 3 : return aBoldItalic;
130 : }
131 0 : return aEmpty;
132 : }
133 :
134 0 : const SmFontStyles & GetFontStyles()
135 : {
136 0 : static const SmFontStyles aImpl;
137 0 : return aImpl;
138 : }
139 :
140 0 : void SetFontStyle(const OUString &rStyleName, vcl::Font &rFont)
141 : {
142 : // Find index related to StyleName. For an empty StyleName it's assumed to be
143 : // 0 (neither bold nor italic).
144 0 : sal_uInt16 nIndex = 0;
145 0 : if (!rStyleName.isEmpty())
146 : {
147 : sal_uInt16 i;
148 0 : const SmFontStyles &rStyles = GetFontStyles();
149 0 : for (i = 0; i < SmFontStyles::GetCount(); ++i)
150 0 : if (rStyleName == rStyles.GetStyleName(i))
151 0 : break;
152 : #if OSL_DEBUG_LEVEL > 1
153 : OSL_ENSURE(i < rStyles.GetCount(), "style-name unknown");
154 : #endif
155 0 : nIndex = i;
156 : }
157 :
158 0 : rFont.SetItalic((nIndex & 0x1) ? ITALIC_NORMAL : ITALIC_NONE);
159 0 : rFont.SetWeight((nIndex & 0x2) ? WEIGHT_BOLD : WEIGHT_NORMAL);
160 0 : }
161 :
162 0 : IMPL_LINK( SmPrintOptionsTabPage, SizeButtonClickHdl, Button *,/*pButton*/ )
163 : {
164 0 : m_pZoom->Enable(m_pSizeZoomed->IsChecked());
165 0 : return 0;
166 : }
167 :
168 0 : SmPrintOptionsTabPage::SmPrintOptionsTabPage(vcl::Window* pParent, const SfxItemSet& rOptions)
169 0 : : SfxTabPage(pParent, "SmathSettings", "modules/smath/ui/smathsettings.ui", &rOptions)
170 : {
171 0 : get( m_pTitle, "title");
172 0 : get( m_pText, "text");
173 0 : get( m_pFrame, "frame");
174 0 : get( m_pSizeNormal, "sizenormal");
175 0 : get( m_pSizeScaled, "sizescaled");
176 0 : get( m_pSizeZoomed, "sizezoomed");
177 0 : get( m_pZoom, "zoom");
178 0 : get( m_pNoRightSpaces, "norightspaces");
179 0 : get( m_pSaveOnlyUsedSymbols, "saveonlyusedsymbols");
180 :
181 0 : m_pSizeNormal->SetClickHdl(LINK(this, SmPrintOptionsTabPage, SizeButtonClickHdl));
182 0 : m_pSizeScaled->SetClickHdl(LINK(this, SmPrintOptionsTabPage, SizeButtonClickHdl));
183 0 : m_pSizeZoomed->SetClickHdl(LINK(this, SmPrintOptionsTabPage, SizeButtonClickHdl));
184 :
185 0 : Reset(&rOptions);
186 0 : }
187 :
188 0 : SmPrintOptionsTabPage::~SmPrintOptionsTabPage()
189 : {
190 0 : disposeOnce();
191 0 : }
192 :
193 0 : void SmPrintOptionsTabPage::dispose()
194 : {
195 0 : m_pTitle.clear();
196 0 : m_pText.clear();
197 0 : m_pFrame.clear();
198 0 : m_pSizeNormal.clear();
199 0 : m_pSizeScaled.clear();
200 0 : m_pSizeZoomed.clear();
201 0 : m_pZoom.clear();
202 0 : m_pNoRightSpaces.clear();
203 0 : m_pSaveOnlyUsedSymbols.clear();
204 0 : SfxTabPage::dispose();
205 0 : }
206 :
207 :
208 0 : bool SmPrintOptionsTabPage::FillItemSet(SfxItemSet* rSet)
209 : {
210 : sal_uInt16 nPrintSize;
211 0 : if (m_pSizeNormal->IsChecked())
212 0 : nPrintSize = PRINT_SIZE_NORMAL;
213 0 : else if (m_pSizeScaled->IsChecked())
214 0 : nPrintSize = PRINT_SIZE_SCALED;
215 : else
216 0 : nPrintSize = PRINT_SIZE_ZOOMED;
217 :
218 0 : rSet->Put(SfxUInt16Item(GetWhich(SID_PRINTSIZE), (sal_uInt16) nPrintSize));
219 0 : rSet->Put(SfxUInt16Item(GetWhich(SID_PRINTZOOM), (sal_uInt16) m_pZoom->GetValue()));
220 0 : rSet->Put(SfxBoolItem(GetWhich(SID_PRINTTITLE), m_pTitle->IsChecked()));
221 0 : rSet->Put(SfxBoolItem(GetWhich(SID_PRINTTEXT), m_pText->IsChecked()));
222 0 : rSet->Put(SfxBoolItem(GetWhich(SID_PRINTFRAME), m_pFrame->IsChecked()));
223 0 : rSet->Put(SfxBoolItem(GetWhich(SID_NO_RIGHT_SPACES), m_pNoRightSpaces->IsChecked()));
224 0 : rSet->Put(SfxBoolItem(GetWhich(SID_SAVE_ONLY_USED_SYMBOLS), m_pSaveOnlyUsedSymbols->IsChecked()));
225 :
226 0 : return true;
227 : }
228 :
229 :
230 0 : void SmPrintOptionsTabPage::Reset(const SfxItemSet* rSet)
231 : {
232 0 : SmPrintSize ePrintSize = (SmPrintSize)static_cast<const SfxUInt16Item &>(rSet->Get(GetWhich(SID_PRINTSIZE))).GetValue();
233 :
234 0 : m_pSizeNormal->Check(ePrintSize == PRINT_SIZE_NORMAL);
235 0 : m_pSizeScaled->Check(ePrintSize == PRINT_SIZE_SCALED);
236 0 : m_pSizeZoomed->Check(ePrintSize == PRINT_SIZE_ZOOMED);
237 :
238 0 : m_pZoom->Enable(m_pSizeZoomed->IsChecked());
239 :
240 0 : m_pZoom->SetValue(static_cast<const SfxUInt16Item &>(rSet->Get(GetWhich(SID_PRINTZOOM))).GetValue());
241 :
242 0 : m_pTitle->Check(static_cast<const SfxBoolItem &>(rSet->Get(GetWhich(SID_PRINTTITLE))).GetValue());
243 0 : m_pText->Check(static_cast<const SfxBoolItem &>(rSet->Get(GetWhich(SID_PRINTTEXT))).GetValue());
244 0 : m_pFrame->Check(static_cast<const SfxBoolItem &>(rSet->Get(GetWhich(SID_PRINTFRAME))).GetValue());
245 0 : m_pNoRightSpaces->Check(static_cast<const SfxBoolItem &>(rSet->Get(GetWhich(SID_NO_RIGHT_SPACES))).GetValue());
246 0 : m_pSaveOnlyUsedSymbols->Check(static_cast<const SfxBoolItem &>(rSet->Get(GetWhich(SID_SAVE_ONLY_USED_SYMBOLS))).GetValue());
247 0 : }
248 :
249 0 : VclPtr<SfxTabPage> SmPrintOptionsTabPage::Create(vcl::Window* pWindow, const SfxItemSet& rSet)
250 : {
251 0 : return VclPtr<SmPrintOptionsTabPage>::Create(pWindow, rSet).get();
252 : }
253 :
254 0 : void SmShowFont::Paint(vcl::RenderContext& rRenderContext, const Rectangle& rRect)
255 : {
256 0 : Window::Paint(rRenderContext, rRect);
257 :
258 0 : Color aBackColor;
259 0 : Color aTextColor;
260 0 : lclGetSettingColors(aBackColor, aTextColor);
261 :
262 0 : rRenderContext.SetBackground(Wallpaper(aBackColor));
263 :
264 0 : vcl::Font aFont(maFont);
265 0 : aFont.SetSize(Size(0, 24 * rRenderContext.GetDPIScaleFactor()));
266 0 : aFont.SetAlign(ALIGN_TOP);
267 0 : rRenderContext.SetFont(aFont);
268 0 : rRenderContext.SetTextColor(aTextColor);
269 :
270 0 : OUString sText(rRenderContext.GetFont().GetName());
271 0 : Size aTextSize(rRenderContext.GetTextWidth(sText), rRenderContext.GetTextHeight());
272 :
273 0 : rRenderContext.DrawText(Point((rRenderContext.GetOutputSize().Width() - aTextSize.Width()) / 2,
274 0 : (rRenderContext.GetOutputSize().Height() - aTextSize.Height()) / 2), sText);
275 0 : }
276 :
277 0 : VCL_BUILDER_DECL_FACTORY(SmShowFont)
278 : {
279 0 : WinBits nWinStyle = 0;
280 :
281 0 : OString sBorder = VclBuilder::extractCustomProperty(rMap);
282 0 : if (!sBorder.isEmpty())
283 0 : nWinStyle |= WB_BORDER;
284 :
285 0 : rRet = VclPtr<SmShowFont>::Create(pParent, nWinStyle);
286 0 : }
287 :
288 0 : Size SmShowFont::GetOptimalSize() const
289 : {
290 0 : return LogicToPixel(Size(111 , 31), MapMode(MAP_APPFONT));
291 : }
292 :
293 0 : void SmShowFont::SetFont(const vcl::Font& rFont)
294 : {
295 0 : maFont = rFont;
296 0 : Invalidate();
297 0 : }
298 :
299 0 : IMPL_LINK( SmFontDialog, FontSelectHdl, ComboBox *, pComboBox )
300 : {
301 0 : maFont.SetName(pComboBox->GetText());
302 0 : m_pShowFont->SetFont(maFont);
303 0 : return 0;
304 : }
305 :
306 0 : IMPL_LINK( SmFontDialog, FontModifyHdl, ComboBox *, pComboBox )
307 : {
308 : // if font is available in list then use it
309 0 : sal_Int32 nPos = pComboBox->GetEntryPos( pComboBox->GetText() );
310 0 : if (COMBOBOX_ENTRY_NOTFOUND != nPos)
311 : {
312 0 : FontSelectHdl( pComboBox );
313 : }
314 0 : return 0;
315 : }
316 :
317 0 : IMPL_LINK( SmFontDialog, AttrChangeHdl, CheckBox *, /*pCheckBox*/ )
318 : {
319 0 : if (m_pBoldCheckBox->IsChecked())
320 0 : maFont.SetWeight(FontWeight(WEIGHT_BOLD));
321 : else
322 0 : maFont.SetWeight(FontWeight(WEIGHT_NORMAL));
323 :
324 0 : if (m_pItalicCheckBox->IsChecked())
325 0 : maFont.SetItalic(ITALIC_NORMAL);
326 : else
327 0 : maFont.SetItalic(ITALIC_NONE);
328 :
329 0 : m_pShowFont->SetFont(maFont);
330 0 : return 0;
331 : }
332 :
333 0 : void SmFontDialog::SetFont(const vcl::Font &rFont)
334 : {
335 0 : maFont = rFont;
336 :
337 0 : m_pFontBox->SetText(maFont.GetName());
338 0 : m_pBoldCheckBox->Check(IsBold(maFont));
339 0 : m_pItalicCheckBox->Check(IsItalic(maFont));
340 0 : m_pShowFont->SetFont(maFont);
341 0 : }
342 :
343 0 : SmFontDialog::SmFontDialog(vcl::Window * pParent, OutputDevice *pFntListDevice, bool bHideCheckboxes)
344 0 : : ModalDialog(pParent, "FontDialog", "modules/smath/ui/fontdialog.ui")
345 : {
346 0 : get(m_pFontBox, "font");
347 0 : m_pFontBox->set_height_request(8 * m_pFontBox->GetTextHeight());
348 0 : get(m_pAttrFrame, "attrframe");
349 0 : get(m_pBoldCheckBox, "bold");
350 0 : get(m_pItalicCheckBox, "italic");
351 0 : get(m_pShowFont, "preview");
352 :
353 : {
354 0 : WaitObject aWait( this );
355 :
356 0 : FontList aFontList( pFntListDevice );
357 :
358 0 : sal_uInt16 nCount = aFontList.GetFontNameCount();
359 0 : for (sal_uInt16 i = 0; i < nCount; ++i)
360 : {
361 0 : m_pFontBox->InsertEntry( aFontList.GetFontName(i).GetName() );
362 : }
363 0 : maFont.SetSize(Size(0, 24));
364 0 : maFont.SetWeight(WEIGHT_NORMAL);
365 0 : maFont.SetItalic(ITALIC_NONE);
366 0 : maFont.SetFamily(FAMILY_DONTKNOW);
367 0 : maFont.SetPitch(PITCH_DONTKNOW);
368 0 : maFont.SetCharSet(RTL_TEXTENCODING_DONTKNOW);
369 0 : maFont.SetTransparent(true);
370 :
371 : // preview like controls should have a 2D look
372 0 : m_pShowFont->SetBorderStyle( WindowBorderStyle::MONO );
373 : }
374 :
375 0 : m_pFontBox->SetSelectHdl(LINK(this, SmFontDialog, FontSelectHdl));
376 0 : m_pFontBox->SetModifyHdl(LINK(this, SmFontDialog, FontModifyHdl));
377 0 : m_pBoldCheckBox->SetClickHdl(LINK(this, SmFontDialog, AttrChangeHdl));
378 0 : m_pItalicCheckBox->SetClickHdl(LINK(this, SmFontDialog, AttrChangeHdl));
379 :
380 0 : if (bHideCheckboxes)
381 : {
382 0 : m_pBoldCheckBox->Check( false );
383 0 : m_pBoldCheckBox->Enable( false );
384 0 : m_pItalicCheckBox->Check( false );
385 0 : m_pItalicCheckBox->Enable( false );
386 0 : m_pAttrFrame->Show(false);
387 : }
388 0 : }
389 :
390 0 : SmFontDialog::~SmFontDialog()
391 : {
392 0 : disposeOnce();
393 0 : }
394 :
395 0 : void SmFontDialog::dispose()
396 : {
397 0 : m_pFontBox.clear();
398 0 : m_pAttrFrame.clear();
399 0 : m_pBoldCheckBox.clear();
400 0 : m_pItalicCheckBox.clear();
401 0 : m_pShowFont.clear();
402 0 : ModalDialog::dispose();
403 0 : }
404 :
405 0 : void SmFontDialog::DataChanged( const DataChangedEvent& rDCEvt )
406 : {
407 0 : if (rDCEvt.GetType() == DataChangedEventType::SETTINGS && (rDCEvt.GetFlags() & AllSettingsFlags::STYLE))
408 0 : m_pShowFont->Invalidate();
409 :
410 0 : ModalDialog::DataChanged( rDCEvt );
411 0 : }
412 :
413 0 : class SaveDefaultsQuery : public MessageDialog
414 : {
415 : public:
416 0 : explicit SaveDefaultsQuery(vcl::Window *pParent)
417 : : MessageDialog(pParent, "SaveDefaultsDialog",
418 0 : "modules/smath/ui/savedefaultsdialog.ui")
419 : {
420 0 : }
421 : };
422 :
423 0 : IMPL_LINK( SmFontSizeDialog, DefaultButtonClickHdl, Button *, /*pButton*/ )
424 : {
425 0 : if (ScopedVclPtr<SaveDefaultsQuery>::Create(this)->Execute() == RET_YES)
426 : {
427 0 : SmModule *pp = SM_MOD();
428 0 : SmFormat aFmt( pp->GetConfig()->GetStandardFormat() );
429 0 : WriteTo( aFmt );
430 0 : pp->GetConfig()->SetStandardFormat( aFmt );
431 : }
432 0 : return 0;
433 : }
434 :
435 0 : SmFontSizeDialog::SmFontSizeDialog(vcl::Window * pParent)
436 0 : : ModalDialog(pParent, "FontSizeDialog", "modules/smath/ui/fontsizedialog.ui")
437 : {
438 0 : get(m_pTextSize, "spinB_text");
439 0 : get(m_pIndexSize, "spinB_index");
440 0 : get(m_pFunctionSize, "spinB_function");
441 0 : get(m_pOperatorSize, "spinB_operator");
442 0 : get(m_pBorderSize, "spinB_limit");
443 0 : get(m_pBaseSize, "spinB_baseSize");
444 0 : get(m_pDefaultButton, "default");
445 :
446 0 : m_pDefaultButton->SetClickHdl(LINK(this, SmFontSizeDialog, DefaultButtonClickHdl));
447 0 : }
448 :
449 0 : SmFontSizeDialog::~SmFontSizeDialog()
450 : {
451 0 : disposeOnce();
452 0 : }
453 :
454 0 : void SmFontSizeDialog::dispose()
455 : {
456 0 : m_pBaseSize.clear();
457 0 : m_pTextSize.clear();
458 0 : m_pIndexSize.clear();
459 0 : m_pFunctionSize.clear();
460 0 : m_pOperatorSize.clear();
461 0 : m_pBorderSize.clear();
462 0 : m_pDefaultButton.clear();
463 0 : ModalDialog::dispose();
464 0 : }
465 :
466 :
467 0 : void SmFontSizeDialog::ReadFrom(const SmFormat &rFormat)
468 : {
469 : //! aufpassen: richtig runden!
470 0 : m_pBaseSize->SetValue( SmRoundFraction(
471 0 : Sm100th_mmToPts( rFormat.GetBaseSize().Height() ) ) );
472 :
473 0 : m_pTextSize->SetValue( rFormat.GetRelSize(SIZ_TEXT) );
474 0 : m_pIndexSize->SetValue( rFormat.GetRelSize(SIZ_INDEX) );
475 0 : m_pFunctionSize->SetValue( rFormat.GetRelSize(SIZ_FUNCTION) );
476 0 : m_pOperatorSize->SetValue( rFormat.GetRelSize(SIZ_OPERATOR) );
477 0 : m_pBorderSize->SetValue( rFormat.GetRelSize(SIZ_LIMITS) );
478 0 : }
479 :
480 :
481 0 : void SmFontSizeDialog::WriteTo(SmFormat &rFormat) const
482 : {
483 0 : rFormat.SetBaseSize( Size(0, SmPtsTo100th_mm( static_cast< long >(m_pBaseSize->GetValue()))) );
484 :
485 0 : rFormat.SetRelSize(SIZ_TEXT, (sal_uInt16) m_pTextSize->GetValue());
486 0 : rFormat.SetRelSize(SIZ_INDEX, (sal_uInt16) m_pIndexSize->GetValue());
487 0 : rFormat.SetRelSize(SIZ_FUNCTION, (sal_uInt16) m_pFunctionSize->GetValue());
488 0 : rFormat.SetRelSize(SIZ_OPERATOR, (sal_uInt16) m_pOperatorSize->GetValue());
489 0 : rFormat.SetRelSize(SIZ_LIMITS, (sal_uInt16) m_pBorderSize->GetValue());
490 :
491 0 : const Size aTmp (rFormat.GetBaseSize());
492 0 : for (sal_uInt16 i = FNT_BEGIN; i <= FNT_END; i++)
493 0 : rFormat.SetFontSize(i, aTmp);
494 :
495 0 : rFormat.RequestApplyChanges();
496 0 : }
497 :
498 0 : IMPL_LINK( SmFontTypeDialog, MenuSelectHdl, Menu *, pMenu )
499 : {
500 : SmFontPickListBox *pActiveListBox;
501 :
502 0 : bool bHideCheckboxes = false;
503 0 : switch (pMenu->GetCurItemId())
504 : {
505 0 : case 1: pActiveListBox = m_pVariableFont; break;
506 0 : case 2: pActiveListBox = m_pFunctionFont; break;
507 0 : case 3: pActiveListBox = m_pNumberFont; break;
508 0 : case 4: pActiveListBox = m_pTextFont; break;
509 0 : case 5: pActiveListBox = m_pSerifFont; bHideCheckboxes = true; break;
510 0 : case 6: pActiveListBox = m_pSansFont; bHideCheckboxes = true; break;
511 0 : case 7: pActiveListBox = m_pFixedFont; bHideCheckboxes = true; break;
512 0 : default:pActiveListBox = NULL;
513 : }
514 :
515 0 : if (pActiveListBox)
516 : {
517 0 : ScopedVclPtrInstance<SmFontDialog> pFontDialog(this, pFontListDev, bHideCheckboxes);
518 :
519 0 : pActiveListBox->WriteTo(*pFontDialog);
520 0 : if (pFontDialog->Execute() == RET_OK)
521 0 : pActiveListBox->ReadFrom(*pFontDialog);
522 : }
523 0 : return 0;
524 : }
525 :
526 :
527 0 : IMPL_LINK( SmFontTypeDialog, DefaultButtonClickHdl, Button *, /*pButton*/ )
528 : {
529 0 : if (ScopedVclPtr<SaveDefaultsQuery>::Create(this)->Execute() == RET_YES)
530 : {
531 0 : SmModule *pp = SM_MOD();
532 0 : SmFormat aFmt( pp->GetConfig()->GetStandardFormat() );
533 0 : WriteTo( aFmt );
534 0 : pp->GetConfig()->SetStandardFormat( aFmt, true );
535 : }
536 0 : return 0;
537 : }
538 :
539 0 : SmFontTypeDialog::SmFontTypeDialog(vcl::Window * pParent, OutputDevice *pFntListDevice)
540 : : ModalDialog(pParent, "FontsDialog", "modules/smath/ui/fonttypedialog.ui"),
541 0 : pFontListDev (pFntListDevice)
542 : {
543 0 : get(m_pVariableFont, "variableCB");
544 0 : get(m_pFunctionFont, "functionCB");
545 0 : get(m_pNumberFont, "numberCB");
546 0 : get(m_pTextFont, "textCB");
547 0 : get(m_pSerifFont, "serifCB");
548 0 : get(m_pSansFont, "sansCB");
549 0 : get(m_pFixedFont, "fixedCB");
550 0 : get(m_pMenuButton, "modify");
551 0 : get(m_pDefaultButton, "default");
552 :
553 0 : m_pDefaultButton->SetClickHdl(LINK(this, SmFontTypeDialog, DefaultButtonClickHdl));
554 :
555 0 : m_pMenuButton->GetPopupMenu()->SetSelectHdl(LINK(this, SmFontTypeDialog, MenuSelectHdl));
556 0 : }
557 :
558 0 : SmFontTypeDialog::~SmFontTypeDialog()
559 : {
560 0 : disposeOnce();
561 0 : }
562 :
563 0 : void SmFontTypeDialog::dispose()
564 : {
565 0 : m_pVariableFont.clear();
566 0 : m_pFunctionFont.clear();
567 0 : m_pNumberFont.clear();
568 0 : m_pTextFont.clear();
569 0 : m_pSerifFont.clear();
570 0 : m_pSansFont.clear();
571 0 : m_pFixedFont.clear();
572 0 : m_pMenuButton.clear();
573 0 : m_pDefaultButton.clear();
574 0 : ModalDialog::dispose();
575 0 : }
576 :
577 0 : void SmFontTypeDialog::ReadFrom(const SmFormat &rFormat)
578 : {
579 0 : SmModule *pp = SM_MOD();
580 :
581 0 : *m_pVariableFont = pp->GetConfig()->GetFontPickList(FNT_VARIABLE);
582 0 : *m_pFunctionFont = pp->GetConfig()->GetFontPickList(FNT_FUNCTION);
583 0 : *m_pNumberFont = pp->GetConfig()->GetFontPickList(FNT_NUMBER);
584 0 : *m_pTextFont = pp->GetConfig()->GetFontPickList(FNT_TEXT);
585 0 : *m_pSerifFont = pp->GetConfig()->GetFontPickList(FNT_SERIF);
586 0 : *m_pSansFont = pp->GetConfig()->GetFontPickList(FNT_SANS);
587 0 : *m_pFixedFont = pp->GetConfig()->GetFontPickList(FNT_FIXED);
588 :
589 0 : m_pVariableFont->Insert( rFormat.GetFont(FNT_VARIABLE) );
590 0 : m_pFunctionFont->Insert( rFormat.GetFont(FNT_FUNCTION) );
591 0 : m_pNumberFont->Insert( rFormat.GetFont(FNT_NUMBER) );
592 0 : m_pTextFont->Insert( rFormat.GetFont(FNT_TEXT) );
593 0 : m_pSerifFont->Insert( rFormat.GetFont(FNT_SERIF) );
594 0 : m_pSansFont->Insert( rFormat.GetFont(FNT_SANS) );
595 0 : m_pFixedFont->Insert( rFormat.GetFont(FNT_FIXED) );
596 0 : }
597 :
598 :
599 0 : void SmFontTypeDialog::WriteTo(SmFormat &rFormat) const
600 : {
601 0 : SmModule *pp = SM_MOD();
602 :
603 0 : pp->GetConfig()->GetFontPickList(FNT_VARIABLE) = *m_pVariableFont;
604 0 : pp->GetConfig()->GetFontPickList(FNT_FUNCTION) = *m_pFunctionFont;
605 0 : pp->GetConfig()->GetFontPickList(FNT_NUMBER) = *m_pNumberFont;
606 0 : pp->GetConfig()->GetFontPickList(FNT_TEXT) = *m_pTextFont;
607 0 : pp->GetConfig()->GetFontPickList(FNT_SERIF) = *m_pSerifFont;
608 0 : pp->GetConfig()->GetFontPickList(FNT_SANS) = *m_pSansFont;
609 0 : pp->GetConfig()->GetFontPickList(FNT_FIXED) = *m_pFixedFont;
610 :
611 0 : rFormat.SetFont( FNT_VARIABLE, m_pVariableFont->Get(0) );
612 0 : rFormat.SetFont( FNT_FUNCTION, m_pFunctionFont->Get(0) );
613 0 : rFormat.SetFont( FNT_NUMBER, m_pNumberFont->Get(0) );
614 0 : rFormat.SetFont( FNT_TEXT, m_pTextFont->Get(0) );
615 0 : rFormat.SetFont( FNT_SERIF, m_pSerifFont->Get(0) );
616 0 : rFormat.SetFont( FNT_SANS, m_pSansFont->Get(0) );
617 0 : rFormat.SetFont( FNT_FIXED, m_pFixedFont->Get(0) );
618 :
619 0 : rFormat.RequestApplyChanges();
620 0 : }
621 :
622 : /**************************************************************************/
623 :
624 : struct FieldMinMax
625 : {
626 : sal_uInt16 nMin, nMax;
627 : };
628 :
629 : // Data for min and max values of the 4 metric fields
630 : // for each of the 10 categories
631 : static const FieldMinMax pMinMaxData[10][4] =
632 : {
633 : // 0
634 : {{ 0, 200 }, { 0, 200 }, { 0, 100 }, { 0, 0 }},
635 : // 1
636 : {{ 0, 100 }, { 0, 100 }, { 0, 0 }, { 0, 0 }},
637 : // 2
638 : {{ 0, 100 }, { 0, 100 }, { 0, 0 }, { 0, 0 }},
639 : // 3
640 : {{ 0, 100 }, { 1, 100 }, { 0, 0 }, { 0, 0 }},
641 : // 4
642 : {{ 0, 100 }, { 0, 100 }, { 0, 0 }, { 0, 0 }},
643 : // 5
644 : {{ 0, 100 }, { 0, 100 }, { 0, 0 }, { 0, 100 }},
645 : // 6
646 : {{ 0, 300 }, { 0, 300 }, { 0, 0 }, { 0, 0 }},
647 : // 7
648 : {{ 0, 100 }, { 0, 100 }, { 0, 0 }, { 0, 0 }},
649 : // 8
650 : {{ 0, 100 }, { 0, 100 }, { 0, 0 }, { 0, 0 }},
651 : // 9
652 : {{ 0, 10000 }, { 0, 10000 }, { 0, 10000 }, { 0, 10000 }}
653 : };
654 :
655 0 : SmCategoryDesc::SmCategoryDesc(VclBuilderContainer& rBuilder, sal_uInt16 nCategoryIdx)
656 : {
657 0 : ++nCategoryIdx;
658 0 : FixedText* pTitle = rBuilder.get<FixedText>(OString::number(nCategoryIdx)+"title");
659 0 : if (pTitle)
660 : {
661 0 : Name = pTitle->GetText();
662 : }
663 0 : for (int i = 0; i < 4; ++i)
664 : {
665 0 : FixedText* pLabel = rBuilder.get<FixedText>(OString::number(nCategoryIdx)+"label"+OString::number(i+1));
666 :
667 0 : if (pLabel)
668 : {
669 0 : Strings [i] = new OUString(pLabel->GetText());
670 0 : FixedImage* pImage = rBuilder.get<FixedImage>(OString::number(nCategoryIdx)+"image"+OString::number(i+1));
671 0 : Graphics [i] = new Image(pImage->GetImage());
672 : }
673 : else
674 : {
675 0 : Strings [i] = 0;
676 0 : Graphics [i] = 0;
677 : }
678 :
679 0 : const FieldMinMax& rMinMax = pMinMaxData[ nCategoryIdx-1 ][i];
680 0 : Value[i] = Minimum[i] = rMinMax.nMin;
681 0 : Maximum[i] = rMinMax.nMax;
682 : }
683 0 : }
684 :
685 0 : SmCategoryDesc::~SmCategoryDesc()
686 : {
687 0 : for (int i = 0; i < 4; ++i)
688 : {
689 0 : delete Strings [i];
690 0 : delete Graphics [i];
691 : }
692 0 : }
693 :
694 : /**************************************************************************/
695 :
696 0 : IMPL_LINK( SmDistanceDialog, GetFocusHdl, Control *, pControl )
697 : {
698 0 : if (Categories[nActiveCategory])
699 : {
700 : sal_uInt16 i;
701 :
702 0 : if (pControl == m_pMetricField1)
703 0 : i = 0;
704 0 : else if (pControl == m_pMetricField2)
705 0 : i = 1;
706 0 : else if (pControl == m_pMetricField3)
707 0 : i = 2;
708 0 : else if (pControl == m_pMetricField4)
709 0 : i = 3;
710 : else
711 0 : return 0;
712 0 : m_pBitmap->SetImage(*(Categories[nActiveCategory]->GetGraphic(i)));
713 : }
714 0 : return 0;
715 : }
716 :
717 0 : IMPL_LINK( SmDistanceDialog, MenuSelectHdl, Menu *, pMenu )
718 : {
719 0 : SetCategory(pMenu->GetCurItemId() - 1);
720 0 : return 0;
721 : }
722 :
723 :
724 0 : IMPL_LINK( SmDistanceDialog, DefaultButtonClickHdl, Button *, /*pButton*/ )
725 : {
726 0 : if (ScopedVclPtr<SaveDefaultsQuery>::Create(this)->Execute() == RET_YES)
727 : {
728 0 : SmModule *pp = SM_MOD();
729 0 : SmFormat aFmt( pp->GetConfig()->GetStandardFormat() );
730 0 : WriteTo( aFmt );
731 0 : pp->GetConfig()->SetStandardFormat( aFmt );
732 : }
733 0 : return 0;
734 : }
735 :
736 0 : IMPL_LINK( SmDistanceDialog, CheckBoxClickHdl, CheckBox *, pCheckBox )
737 : {
738 0 : if (pCheckBox == m_pCheckBox1)
739 : {
740 0 : m_pCheckBox1->Toggle();
741 :
742 0 : bool bChecked = m_pCheckBox1->IsChecked();
743 0 : m_pFixedText4->Enable( bChecked );
744 0 : m_pMetricField4->Enable( bChecked );
745 : }
746 0 : return 0;
747 : }
748 :
749 :
750 0 : void SmDistanceDialog::SetHelpId(MetricField &rField, const OString& sHelpId)
751 : {
752 0 : const OUString aEmptyText;
753 :
754 0 : rField.SetHelpId(sHelpId);
755 0 : rField.SetHelpText(aEmptyText);
756 :
757 : // since MetricField inherits from SpinField which has a sub Edit field
758 : // (which is actually the one we modify) we have to set the help-id
759 : // for it too.
760 0 : Edit *pSubEdit = rField.GetSubEdit();
761 0 : if (pSubEdit)
762 : {
763 0 : pSubEdit->SetHelpId(sHelpId);
764 0 : pSubEdit->SetHelpText(aEmptyText);
765 0 : }
766 0 : }
767 :
768 :
769 0 : void SmDistanceDialog::SetCategory(sal_uInt16 nCategory)
770 : {
771 : #if OSL_DEBUG_LEVEL > 1
772 : OSL_ENSURE(/*0 <= nCategory &&*/ nCategory < NOCATEGORIES,
773 : "Sm: wrong category number in SmDistanceDialog");
774 : #endif
775 :
776 : // array to convert category- and metricfield-number in help ids.
777 : // 0 is used in case of unused combinations.
778 : #if OSL_DEBUG_LEVEL > 1
779 : OSL_ENSURE(NOCATEGORIES == 10, "Sm : array doesn't fit into the number of categories");
780 : #endif
781 : static const char * aCatMf2Hid[10][4] =
782 : {
783 : { HID_SMA_DEFAULT_DIST, HID_SMA_LINE_DIST, HID_SMA_ROOT_DIST, 0 },
784 : { HID_SMA_SUP_DIST, HID_SMA_SUB_DIST , 0, 0 },
785 : { HID_SMA_NUMERATOR_DIST, HID_SMA_DENOMINATOR_DIST, 0, 0 },
786 : { HID_SMA_FRACLINE_EXCWIDTH, HID_SMA_FRACLINE_LINEWIDTH, 0, 0 },
787 : { HID_SMA_UPPERLIMIT_DIST, HID_SMA_LOWERLIMIT_DIST, 0, 0 },
788 : { HID_SMA_BRACKET_EXCHEIGHT, HID_SMA_BRACKET_DIST, 0, HID_SMA_BRACKET_EXCHEIGHT2 },
789 : { HID_SMA_MATRIXROW_DIST, HID_SMA_MATRIXCOL_DIST, 0, 0 },
790 : { HID_SMA_ATTRIBUT_DIST, HID_SMA_INTERATTRIBUT_DIST, 0, 0 },
791 : { HID_SMA_OPERATOR_EXCHEIGHT, HID_SMA_OPERATOR_DIST, 0, 0 },
792 : { HID_SMA_LEFTBORDER_DIST, HID_SMA_RIGHTBORDER_DIST, HID_SMA_UPPERBORDER_DIST, HID_SMA_LOWERBORDER_DIST }
793 : };
794 :
795 : // array to help iterate over the controls
796 : vcl::Window * const aWin[4][2] =
797 : {
798 : { m_pFixedText1, m_pMetricField1 },
799 : { m_pFixedText2, m_pMetricField2 },
800 : { m_pFixedText3, m_pMetricField3 },
801 : { m_pFixedText4, m_pMetricField4 }
802 0 : };
803 :
804 : SmCategoryDesc *pCat;
805 :
806 : // remember the (maybe new) settings of the active SmCategoryDesc
807 : // before switching to the new one
808 0 : if (nActiveCategory != CATEGORY_NONE)
809 : {
810 0 : pCat = Categories[nActiveCategory];
811 0 : pCat->SetValue(0, (sal_uInt16) m_pMetricField1->GetValue());
812 0 : pCat->SetValue(1, (sal_uInt16) m_pMetricField2->GetValue());
813 0 : pCat->SetValue(2, (sal_uInt16) m_pMetricField3->GetValue());
814 0 : pCat->SetValue(3, (sal_uInt16) m_pMetricField4->GetValue());
815 :
816 0 : if (nActiveCategory == 5)
817 0 : bScaleAllBrackets = m_pCheckBox1->IsChecked();
818 :
819 0 : m_pMenuButton->GetPopupMenu()->CheckItem(nActiveCategory + 1, false);
820 : }
821 :
822 : // activation/deactivation of the associated controls depending on the chosen category
823 : bool bActive;
824 0 : for (sal_uInt16 i = 0; i < 4; i++)
825 : {
826 0 : FixedText *pFT = static_cast<FixedText *> ( aWin[i][0] );
827 0 : MetricField *pMF = static_cast<MetricField *>( aWin[i][1] );
828 :
829 : // To determine which Controls should be active, the existence
830 : // of an associated HelpID is checked
831 0 : bActive = aCatMf2Hid[nCategory][i] != 0;
832 :
833 0 : pFT->Show(bActive);
834 0 : pFT->Enable(bActive);
835 0 : pMF->Show(bActive);
836 0 : pMF->Enable(bActive);
837 :
838 : // set measurement unit and number of decimal places
839 : FieldUnit eUnit;
840 : sal_uInt16 nDigits;
841 0 : if (nCategory < 9)
842 : {
843 0 : eUnit = FUNIT_PERCENT;
844 0 : nDigits = 0;
845 : }
846 : else
847 : {
848 0 : eUnit = FUNIT_100TH_MM;
849 0 : nDigits = 2;
850 : }
851 0 : pMF->SetUnit(eUnit); // changes the value
852 0 : pMF->SetDecimalDigits(nDigits);
853 :
854 0 : if (bActive)
855 : {
856 0 : pCat = Categories[nCategory];
857 0 : pFT->SetText(*pCat->GetString(i));
858 :
859 0 : pMF->SetMin(pCat->GetMinimum(i));
860 0 : pMF->SetMax(pCat->GetMaximum(i));
861 0 : pMF->SetValue(pCat->GetValue(i));
862 :
863 0 : SetHelpId(*pMF, aCatMf2Hid[nCategory][i]);
864 : }
865 : }
866 : // activate the CheckBox and the associated MetricField if we're dealing with the brackets menu
867 0 : bActive = nCategory == 5;
868 0 : m_pCheckBox1->Show(bActive);
869 0 : m_pCheckBox1->Enable(bActive);
870 0 : if (bActive)
871 : {
872 0 : m_pCheckBox1->Check( bScaleAllBrackets );
873 :
874 0 : bool bChecked = m_pCheckBox1->IsChecked();
875 0 : m_pFixedText4->Enable( bChecked );
876 0 : m_pMetricField4->Enable( bChecked );
877 : }
878 :
879 0 : m_pMenuButton->GetPopupMenu()->CheckItem(nCategory + 1, true);
880 0 : m_pFrame->set_label(Categories[nCategory]->GetName());
881 :
882 0 : nActiveCategory = nCategory;
883 :
884 0 : m_pMetricField1->GrabFocus();
885 0 : Invalidate();
886 0 : Update();
887 0 : }
888 :
889 :
890 0 : SmDistanceDialog::SmDistanceDialog(vcl::Window *pParent)
891 : : ModalDialog(pParent, "SpacingDialog",
892 0 : "modules/smath/ui/spacingdialog.ui")
893 : {
894 0 : get(m_pFrame, "template");
895 0 : get(m_pFixedText1, "label1");
896 0 : get(m_pMetricField1, "spinbutton1");
897 0 : get(m_pFixedText2, "label2");
898 0 : get(m_pMetricField2, "spinbutton2");
899 0 : get(m_pFixedText3, "label3");
900 0 : get(m_pMetricField3, "spinbutton3");
901 0 : get(m_pCheckBox1, "checkbutton");
902 0 : get(m_pFixedText4, "label4");
903 0 : get(m_pMetricField4, "spinbutton4");
904 0 : get(m_pMenuButton, "category");
905 0 : get(m_pDefaultButton, "default");
906 0 : get(m_pBitmap, "image");
907 :
908 0 : for (sal_uInt16 i = 0; i < NOCATEGORIES; ++i)
909 0 : Categories[i] = new SmCategoryDesc(*this, i);
910 0 : nActiveCategory = CATEGORY_NONE;
911 0 : bScaleAllBrackets = false;
912 :
913 : // preview like controls should have a 2D look
914 0 : m_pBitmap->SetBorderStyle( WindowBorderStyle::MONO );
915 :
916 0 : m_pMetricField1->SetGetFocusHdl(LINK(this, SmDistanceDialog, GetFocusHdl));
917 0 : m_pMetricField2->SetGetFocusHdl(LINK(this, SmDistanceDialog, GetFocusHdl));
918 0 : m_pMetricField3->SetGetFocusHdl(LINK(this, SmDistanceDialog, GetFocusHdl));
919 0 : m_pMetricField4->SetGetFocusHdl(LINK(this, SmDistanceDialog, GetFocusHdl));
920 0 : m_pCheckBox1->SetClickHdl(LINK(this, SmDistanceDialog, CheckBoxClickHdl));
921 :
922 0 : m_pMenuButton->GetPopupMenu()->SetSelectHdl(LINK(this, SmDistanceDialog, MenuSelectHdl));
923 :
924 0 : m_pDefaultButton->SetClickHdl(LINK(this, SmDistanceDialog, DefaultButtonClickHdl));
925 0 : }
926 :
927 :
928 0 : SmDistanceDialog::~SmDistanceDialog()
929 : {
930 0 : disposeOnce();
931 0 : }
932 :
933 0 : void SmDistanceDialog::dispose()
934 : {
935 0 : for (int i = 0; i < NOCATEGORIES; i++)
936 0 : DELETEZ(Categories[i]);
937 0 : m_pFrame.clear();
938 0 : m_pFixedText1.clear();
939 0 : m_pMetricField1.clear();
940 0 : m_pFixedText2.clear();
941 0 : m_pMetricField2.clear();
942 0 : m_pFixedText3.clear();
943 0 : m_pMetricField3.clear();
944 0 : m_pCheckBox1.clear();
945 0 : m_pFixedText4.clear();
946 0 : m_pMetricField4.clear();
947 0 : m_pMenuButton.clear();
948 0 : m_pDefaultButton.clear();
949 0 : m_pBitmap.clear();
950 0 : ModalDialog::dispose();
951 0 : }
952 :
953 0 : void SmDistanceDialog::DataChanged( const DataChangedEvent &rEvt )
954 : {
955 0 : ModalDialog::DataChanged( rEvt );
956 0 : }
957 :
958 0 : void SmDistanceDialog::ReadFrom(const SmFormat &rFormat)
959 : {
960 0 : Categories[0]->SetValue(0, rFormat.GetDistance(DIS_HORIZONTAL));
961 0 : Categories[0]->SetValue(1, rFormat.GetDistance(DIS_VERTICAL));
962 0 : Categories[0]->SetValue(2, rFormat.GetDistance(DIS_ROOT));
963 0 : Categories[1]->SetValue(0, rFormat.GetDistance(DIS_SUPERSCRIPT));
964 0 : Categories[1]->SetValue(1, rFormat.GetDistance(DIS_SUBSCRIPT));
965 0 : Categories[2]->SetValue(0, rFormat.GetDistance(DIS_NUMERATOR));
966 0 : Categories[2]->SetValue(1, rFormat.GetDistance(DIS_DENOMINATOR));
967 0 : Categories[3]->SetValue(0, rFormat.GetDistance(DIS_FRACTION));
968 0 : Categories[3]->SetValue(1, rFormat.GetDistance(DIS_STROKEWIDTH));
969 0 : Categories[4]->SetValue(0, rFormat.GetDistance(DIS_UPPERLIMIT));
970 0 : Categories[4]->SetValue(1, rFormat.GetDistance(DIS_LOWERLIMIT));
971 0 : Categories[5]->SetValue(0, rFormat.GetDistance(DIS_BRACKETSIZE));
972 0 : Categories[5]->SetValue(1, rFormat.GetDistance(DIS_BRACKETSPACE));
973 0 : Categories[5]->SetValue(3, rFormat.GetDistance(DIS_NORMALBRACKETSIZE));
974 0 : Categories[6]->SetValue(0, rFormat.GetDistance(DIS_MATRIXROW));
975 0 : Categories[6]->SetValue(1, rFormat.GetDistance(DIS_MATRIXCOL));
976 0 : Categories[7]->SetValue(0, rFormat.GetDistance(DIS_ORNAMENTSIZE));
977 0 : Categories[7]->SetValue(1, rFormat.GetDistance(DIS_ORNAMENTSPACE));
978 0 : Categories[8]->SetValue(0, rFormat.GetDistance(DIS_OPERATORSIZE));
979 0 : Categories[8]->SetValue(1, rFormat.GetDistance(DIS_OPERATORSPACE));
980 0 : Categories[9]->SetValue(0, rFormat.GetDistance(DIS_LEFTSPACE));
981 0 : Categories[9]->SetValue(1, rFormat.GetDistance(DIS_RIGHTSPACE));
982 0 : Categories[9]->SetValue(2, rFormat.GetDistance(DIS_TOPSPACE));
983 0 : Categories[9]->SetValue(3, rFormat.GetDistance(DIS_BOTTOMSPACE));
984 :
985 0 : bScaleAllBrackets = rFormat.IsScaleNormalBrackets();
986 :
987 : // force update (even of category 0) by setting nActiveCategory to a
988 : // non-existent category number
989 0 : nActiveCategory = CATEGORY_NONE;
990 0 : SetCategory(0);
991 0 : }
992 :
993 :
994 0 : void SmDistanceDialog::WriteTo(SmFormat &rFormat) /*const*/
995 : {
996 : // TODO can they actually be different?
997 : // if that's not the case 'const' could be used above!
998 0 : SetCategory(nActiveCategory);
999 :
1000 0 : rFormat.SetDistance( DIS_HORIZONTAL, Categories[0]->GetValue(0) );
1001 0 : rFormat.SetDistance( DIS_VERTICAL, Categories[0]->GetValue(1) );
1002 0 : rFormat.SetDistance( DIS_ROOT, Categories[0]->GetValue(2) );
1003 0 : rFormat.SetDistance( DIS_SUPERSCRIPT, Categories[1]->GetValue(0) );
1004 0 : rFormat.SetDistance( DIS_SUBSCRIPT, Categories[1]->GetValue(1) );
1005 0 : rFormat.SetDistance( DIS_NUMERATOR, Categories[2]->GetValue(0) );
1006 0 : rFormat.SetDistance( DIS_DENOMINATOR, Categories[2]->GetValue(1) );
1007 0 : rFormat.SetDistance( DIS_FRACTION, Categories[3]->GetValue(0) );
1008 0 : rFormat.SetDistance( DIS_STROKEWIDTH, Categories[3]->GetValue(1) );
1009 0 : rFormat.SetDistance( DIS_UPPERLIMIT, Categories[4]->GetValue(0) );
1010 0 : rFormat.SetDistance( DIS_LOWERLIMIT, Categories[4]->GetValue(1) );
1011 0 : rFormat.SetDistance( DIS_BRACKETSIZE, Categories[5]->GetValue(0) );
1012 0 : rFormat.SetDistance( DIS_BRACKETSPACE, Categories[5]->GetValue(1) );
1013 0 : rFormat.SetDistance( DIS_MATRIXROW, Categories[6]->GetValue(0) );
1014 0 : rFormat.SetDistance( DIS_MATRIXCOL, Categories[6]->GetValue(1) );
1015 0 : rFormat.SetDistance( DIS_ORNAMENTSIZE, Categories[7]->GetValue(0) );
1016 0 : rFormat.SetDistance( DIS_ORNAMENTSPACE, Categories[7]->GetValue(1) );
1017 0 : rFormat.SetDistance( DIS_OPERATORSIZE, Categories[8]->GetValue(0) );
1018 0 : rFormat.SetDistance( DIS_OPERATORSPACE, Categories[8]->GetValue(1) );
1019 0 : rFormat.SetDistance( DIS_LEFTSPACE, Categories[9]->GetValue(0) );
1020 0 : rFormat.SetDistance( DIS_RIGHTSPACE, Categories[9]->GetValue(1) );
1021 0 : rFormat.SetDistance( DIS_TOPSPACE, Categories[9]->GetValue(2) );
1022 0 : rFormat.SetDistance( DIS_BOTTOMSPACE, Categories[9]->GetValue(3) );
1023 0 : rFormat.SetDistance( DIS_NORMALBRACKETSIZE, Categories[5]->GetValue(3) );
1024 :
1025 0 : rFormat.SetScaleNormalBrackets( bScaleAllBrackets );
1026 :
1027 0 : rFormat.RequestApplyChanges();
1028 0 : }
1029 :
1030 0 : IMPL_LINK( SmAlignDialog, DefaultButtonClickHdl, Button *, /*pButton*/ )
1031 : {
1032 0 : if (ScopedVclPtr<SaveDefaultsQuery>::Create(this)->Execute() == RET_YES)
1033 : {
1034 0 : SmModule *pp = SM_MOD();
1035 0 : SmFormat aFmt( pp->GetConfig()->GetStandardFormat() );
1036 0 : WriteTo( aFmt );
1037 0 : pp->GetConfig()->SetStandardFormat( aFmt );
1038 : }
1039 0 : return 0;
1040 : }
1041 :
1042 0 : SmAlignDialog::SmAlignDialog(vcl::Window * pParent)
1043 : : ModalDialog(pParent, "AlignmentDialog",
1044 0 : "modules/smath/ui/alignmentdialog.ui")
1045 : {
1046 0 : get(m_pLeft, "left");
1047 0 : get(m_pCenter, "center");
1048 0 : get(m_pRight, "right");
1049 0 : get(m_pDefaultButton, "default");
1050 0 : m_pDefaultButton->SetClickHdl(LINK(this, SmAlignDialog, DefaultButtonClickHdl));
1051 0 : }
1052 :
1053 0 : SmAlignDialog::~SmAlignDialog()
1054 : {
1055 0 : disposeOnce();
1056 0 : }
1057 :
1058 0 : void SmAlignDialog::dispose()
1059 : {
1060 0 : m_pLeft.clear();
1061 0 : m_pCenter.clear();
1062 0 : m_pRight.clear();
1063 0 : m_pDefaultButton.clear();
1064 0 : ModalDialog::dispose();
1065 0 : }
1066 :
1067 0 : void SmAlignDialog::ReadFrom(const SmFormat &rFormat)
1068 : {
1069 0 : switch (rFormat.GetHorAlign())
1070 : {
1071 : case AlignLeft:
1072 0 : m_pLeft->Check(true);
1073 0 : m_pCenter->Check(false);
1074 0 : m_pRight->Check(false);
1075 0 : break;
1076 :
1077 : case AlignCenter:
1078 0 : m_pLeft->Check(false);
1079 0 : m_pCenter->Check(true);
1080 0 : m_pRight->Check(false);
1081 0 : break;
1082 :
1083 : case AlignRight:
1084 0 : m_pLeft->Check(false);
1085 0 : m_pCenter->Check(false);
1086 0 : m_pRight->Check(true);
1087 0 : break;
1088 : }
1089 0 : }
1090 :
1091 :
1092 0 : void SmAlignDialog::WriteTo(SmFormat &rFormat) const
1093 : {
1094 0 : if (m_pLeft->IsChecked())
1095 0 : rFormat.SetHorAlign(AlignLeft);
1096 0 : else if (m_pRight->IsChecked())
1097 0 : rFormat.SetHorAlign(AlignRight);
1098 : else
1099 0 : rFormat.SetHorAlign(AlignCenter);
1100 :
1101 0 : rFormat.RequestApplyChanges();
1102 0 : }
1103 :
1104 :
1105 0 : SmShowSymbolSetWindow::SmShowSymbolSetWindow(vcl::Window *pParent, WinBits nStyle)
1106 : : Control(pParent, nStyle)
1107 : , m_pVScrollBar(0)
1108 : , nLen(0)
1109 : , nRows(0)
1110 : , nColumns(0)
1111 : , nXOffset(0)
1112 : , nYOffset(0)
1113 0 : , nSelectSymbol(SYMBOL_NONE)
1114 : {
1115 0 : }
1116 :
1117 0 : SmShowSymbolSetWindow::~SmShowSymbolSetWindow()
1118 : {
1119 0 : disposeOnce();
1120 0 : }
1121 :
1122 0 : void SmShowSymbolSetWindow::dispose()
1123 : {
1124 0 : m_pVScrollBar.clear();
1125 0 : Control::dispose();
1126 0 : }
1127 :
1128 0 : Point SmShowSymbolSetWindow::OffsetPoint(const Point &rPoint) const
1129 : {
1130 0 : return Point(rPoint.X() + nXOffset, rPoint.Y() + nYOffset);
1131 : }
1132 :
1133 0 : void SmShowSymbolSetWindow::Paint(vcl::RenderContext& rRenderContext, const Rectangle&)
1134 : {
1135 0 : Color aBackgroundColor;
1136 0 : Color aTextColor;
1137 0 : lclGetSettingColors(aBackgroundColor, aTextColor);
1138 :
1139 0 : rRenderContext.SetBackground(Wallpaper(aBackgroundColor));
1140 0 : rRenderContext.SetTextColor(aTextColor);
1141 :
1142 0 : rRenderContext.Push(PushFlags::MAPMODE);
1143 :
1144 : // set MapUnit for which 'nLen' has been calculated
1145 0 : rRenderContext.SetMapMode(MapMode(MAP_PIXEL));
1146 :
1147 0 : sal_uInt16 v = sal::static_int_cast< sal_uInt16 >((m_pVScrollBar->GetThumbPos() * nColumns));
1148 0 : size_t nSymbols = aSymbolSet.size();
1149 :
1150 0 : Color aTxtColor(rRenderContext.GetTextColor());
1151 0 : for (size_t i = v; i < nSymbols ; i++)
1152 : {
1153 0 : SmSym aSymbol(*aSymbolSet[i]);
1154 0 : vcl::Font aFont(aSymbol.GetFace());
1155 0 : aFont.SetAlign(ALIGN_TOP);
1156 :
1157 : // taking a FontSize which is a bit smaller (compared to nLen) in order to have a buffer
1158 : // (hopefully enough for left and right, too)
1159 0 : aFont.SetSize(Size(0, nLen - (nLen / 3)));
1160 0 : rRenderContext.SetFont(aFont);
1161 : // keep text color
1162 0 : rRenderContext.SetTextColor(aTxtColor);
1163 :
1164 0 : int nIV = i - v;
1165 0 : sal_UCS4 cChar = aSymbol.GetCharacter();
1166 0 : OUString aText(&cChar, 1);
1167 0 : Size aSize(rRenderContext.GetTextWidth( aText ), rRenderContext.GetTextHeight());
1168 :
1169 0 : Point aPoint((nIV % nColumns) * nLen + (nLen - aSize.Width()) / 2,
1170 0 : (nIV / nColumns) * nLen + (nLen - aSize.Height()) / 2);
1171 :
1172 0 : rRenderContext.DrawText(OffsetPoint(aPoint), aText);
1173 0 : }
1174 :
1175 0 : if (nSelectSymbol != SYMBOL_NONE)
1176 : {
1177 0 : Point aPoint(((nSelectSymbol - v) % nColumns) * nLen,
1178 0 : ((nSelectSymbol - v) / nColumns) * nLen);
1179 :
1180 0 : Invert(Rectangle(OffsetPoint(aPoint), Size(nLen, nLen)));
1181 :
1182 : }
1183 :
1184 0 : rRenderContext.Pop();
1185 0 : }
1186 :
1187 :
1188 0 : void SmShowSymbolSetWindow::MouseButtonDown(const MouseEvent& rMEvt)
1189 : {
1190 0 : GrabFocus();
1191 :
1192 0 : Size aOutputSize(nColumns * nLen, nRows * nLen);
1193 0 : Point aPoint(rMEvt.GetPosPixel());
1194 0 : aPoint.X() -= nXOffset;
1195 0 : aPoint.Y() -= nYOffset;
1196 :
1197 0 : if (rMEvt.IsLeft() && Rectangle(Point(0, 0), aOutputSize).IsInside(rMEvt.GetPosPixel()))
1198 : {
1199 0 : long nPos = (aPoint.Y() / nLen) * nColumns + (aPoint.X() / nLen) +
1200 0 : m_pVScrollBar->GetThumbPos() * nColumns;
1201 0 : SelectSymbol( sal::static_int_cast< sal_uInt16 >(nPos) );
1202 :
1203 0 : aSelectHdlLink.Call(this);
1204 :
1205 0 : if (rMEvt.GetClicks() > 1)
1206 0 : aDblClickHdlLink.Call(this);
1207 : }
1208 0 : }
1209 :
1210 :
1211 0 : void SmShowSymbolSetWindow::KeyInput(const KeyEvent& rKEvt)
1212 : {
1213 0 : sal_uInt16 n = nSelectSymbol;
1214 :
1215 0 : if (n != SYMBOL_NONE)
1216 : {
1217 0 : switch (rKEvt.GetKeyCode().GetCode())
1218 : {
1219 0 : case KEY_DOWN: n = n + nColumns; break;
1220 0 : case KEY_UP: n = n - nColumns; break;
1221 0 : case KEY_LEFT: n -= 1; break;
1222 0 : case KEY_RIGHT: n += 1; break;
1223 0 : case KEY_HOME: n = 0; break;
1224 0 : case KEY_END: n = static_cast< sal_uInt16 >(aSymbolSet.size() - 1); break;
1225 0 : case KEY_PAGEUP: n -= nColumns * nRows; break;
1226 0 : case KEY_PAGEDOWN: n += nColumns * nRows; break;
1227 :
1228 : default:
1229 0 : Control::KeyInput(rKEvt);
1230 0 : return;
1231 : }
1232 : }
1233 : else
1234 0 : n = 0;
1235 :
1236 0 : if (n >= aSymbolSet.size())
1237 0 : n = nSelectSymbol;
1238 :
1239 : // adjust scrollbar
1240 0 : if ((n < (sal_uInt16) (m_pVScrollBar->GetThumbPos() * nColumns)) ||
1241 0 : (n >= (sal_uInt16) ((m_pVScrollBar->GetThumbPos() + nRows) * nColumns)))
1242 : {
1243 0 : m_pVScrollBar->SetThumbPos(n / nColumns);
1244 0 : Invalidate();
1245 0 : Update();
1246 : }
1247 :
1248 0 : SelectSymbol(n);
1249 0 : aSelectHdlLink.Call(this);
1250 : }
1251 :
1252 0 : void SmShowSymbolSetWindow::setScrollbar(ScrollBar *pVScrollBar)
1253 : {
1254 0 : m_pVScrollBar = pVScrollBar;
1255 0 : m_pVScrollBar->Enable(false);
1256 0 : m_pVScrollBar->Show();
1257 0 : m_pVScrollBar->SetScrollHdl(LINK(this, SmShowSymbolSetWindow, ScrollHdl));
1258 0 : }
1259 :
1260 0 : SmShowSymbolSet::SmShowSymbolSet(vcl::Window *pParent)
1261 : : VclHBox(pParent, false, 6)
1262 : , aSymbolWindow(VclPtr<SmShowSymbolSetWindow>::Create(this, WB_TABSTOP))
1263 0 : , aVScrollBar(VclPtr<ScrollBar>::Create(this, WinBits(WB_VSCROLL)))
1264 : {
1265 0 : aSymbolWindow->set_hexpand(true);
1266 0 : aSymbolWindow->set_vexpand(true);
1267 0 : aSymbolWindow->setScrollbar(aVScrollBar.get());
1268 0 : aSymbolWindow->calccols();
1269 0 : aSymbolWindow->Show();
1270 0 : }
1271 :
1272 0 : SmShowSymbolSet::~SmShowSymbolSet()
1273 : {
1274 0 : disposeOnce();
1275 0 : }
1276 :
1277 0 : void SmShowSymbolSet::dispose()
1278 : {
1279 0 : aSymbolWindow.disposeAndClear();
1280 0 : aVScrollBar.disposeAndClear();
1281 0 : VclHBox::dispose();
1282 0 : }
1283 :
1284 0 : VCL_BUILDER_FACTORY(SmShowSymbolSet)
1285 :
1286 0 : void SmShowSymbolSetWindow::calccols()
1287 : {
1288 : // Height of 16pt in pixels (matching 'aOutputSize')
1289 0 : nLen = LogicToPixel(Size(0, 16), MapMode(MAP_POINT)).Height();
1290 :
1291 0 : Size aOutputSize = GetOutputSizePixel();
1292 :
1293 0 : nColumns = aOutputSize.Width() / nLen;
1294 0 : if (nColumns > 2 && nColumns % 2 != 0)
1295 0 : --nColumns;
1296 0 : nRows = aOutputSize.Height() / nLen;
1297 0 : nColumns = std::max<long>(1, nColumns);
1298 0 : nRows = std::max<long>(1, nRows);
1299 :
1300 0 : nXOffset = (aOutputSize.Width() - (nColumns * nLen)) / 2;
1301 0 : nYOffset = (aOutputSize.Height() - (nRows * nLen)) / 2;
1302 :
1303 0 : SetScrollBarRange();
1304 0 : }
1305 :
1306 0 : Size SmShowSymbolSetWindow::GetOptimalSize() const
1307 : {
1308 0 : vcl::Window *pParent = GetParent();
1309 0 : return Size(pParent->approximate_char_width() * 24, pParent->GetTextHeight() * 8);
1310 : }
1311 :
1312 0 : void SmShowSymbolSetWindow::SetSymbolSet(const SymbolPtrVec_t& rSymbolSet)
1313 : {
1314 0 : aSymbolSet = rSymbolSet;
1315 :
1316 0 : SetScrollBarRange();
1317 0 : }
1318 :
1319 0 : void SmShowSymbolSetWindow::SetScrollBarRange()
1320 : {
1321 0 : if (aSymbolSet.size() > static_cast<size_t>(nColumns * nRows))
1322 : {
1323 0 : m_pVScrollBar->SetRange(Range(0, ((aSymbolSet.size() + (nColumns - 1)) / nColumns) - nRows));
1324 0 : m_pVScrollBar->Enable(true);
1325 : }
1326 : else
1327 : {
1328 0 : m_pVScrollBar->SetRange(Range(0,0));
1329 0 : m_pVScrollBar->Enable (false);
1330 : }
1331 :
1332 0 : Invalidate();
1333 0 : }
1334 :
1335 0 : void SmShowSymbolSetWindow::SelectSymbol(sal_uInt16 nSymbol)
1336 : {
1337 0 : int v = (int) (m_pVScrollBar->GetThumbPos() * nColumns);
1338 :
1339 0 : if (nSelectSymbol != SYMBOL_NONE)
1340 0 : Invalidate(Rectangle(OffsetPoint(Point(((nSelectSymbol - v) % nColumns) * nLen,
1341 0 : ((nSelectSymbol - v) / nColumns) * nLen)),
1342 0 : Size(nLen, nLen)));
1343 :
1344 0 : if (nSymbol < aSymbolSet.size())
1345 0 : nSelectSymbol = nSymbol;
1346 :
1347 0 : if (aSymbolSet.empty())
1348 0 : nSelectSymbol = SYMBOL_NONE;
1349 :
1350 0 : if (nSelectSymbol != SYMBOL_NONE)
1351 0 : Invalidate(Rectangle(OffsetPoint(Point(((nSelectSymbol - v) % nColumns) * nLen,
1352 0 : ((nSelectSymbol - v) / nColumns) * nLen)),
1353 0 : Size(nLen, nLen)));
1354 :
1355 0 : Update();
1356 0 : }
1357 :
1358 0 : void SmShowSymbolSetWindow::Resize()
1359 : {
1360 0 : Control::Resize();
1361 0 : calccols();
1362 0 : }
1363 :
1364 0 : IMPL_LINK( SmShowSymbolSetWindow, ScrollHdl, ScrollBar*, /*pScrollBar*/)
1365 : {
1366 0 : Invalidate();
1367 0 : return 0;
1368 : }
1369 :
1370 0 : VCL_BUILDER_DECL_FACTORY(SmShowSymbol)
1371 : {
1372 0 : WinBits nWinStyle = 0;
1373 :
1374 0 : OString sBorder = VclBuilder::extractCustomProperty(rMap);
1375 0 : if (!sBorder.isEmpty())
1376 0 : nWinStyle |= WB_BORDER;
1377 :
1378 0 : rRet = VclPtr<SmShowSymbol>::Create(pParent, nWinStyle);
1379 0 : }
1380 :
1381 0 : void SmShowSymbol::Resize()
1382 : {
1383 0 : Control::Resize();
1384 0 : Invalidate();
1385 0 : }
1386 :
1387 0 : void SmShowSymbol::setFontSize(vcl::Font &rFont) const
1388 : {
1389 0 : rFont.SetSize(Size(0, GetOutputSize().Height() - GetOutputSize().Height() / 3));
1390 0 : }
1391 :
1392 0 : void SmShowSymbol::Paint(vcl::RenderContext& rRenderContext, const Rectangle &rRect)
1393 : {
1394 0 : Control::Paint(rRenderContext, rRect);
1395 :
1396 0 : Color aBackgroundColor;
1397 0 : Color aTextColor;
1398 0 : lclGetSettingColors(aBackgroundColor, aTextColor);
1399 0 : SetBackground(Wallpaper(aBackgroundColor));
1400 0 : SetTextColor(aTextColor);
1401 :
1402 0 : vcl::Font aFont(rRenderContext.GetFont());
1403 0 : setFontSize(aFont);
1404 0 : rRenderContext.SetFont(aFont);
1405 :
1406 0 : const OUString &rText = GetText();
1407 0 : Size aTextSize(rRenderContext.GetTextWidth(rText), rRenderContext.GetTextHeight());
1408 :
1409 0 : rRenderContext.DrawText(Point((rRenderContext.GetOutputSize().Width() - aTextSize.Width()) / 2,
1410 0 : (rRenderContext.GetOutputSize().Height() * 7 / 10)), rText);
1411 0 : }
1412 :
1413 0 : void SmShowSymbol::MouseButtonDown(const MouseEvent& rMEvt)
1414 : {
1415 0 : if (rMEvt.GetClicks() > 1)
1416 0 : aDblClickHdlLink.Call(this);
1417 : else
1418 0 : Control::MouseButtonDown (rMEvt);
1419 0 : }
1420 :
1421 0 : void SmShowSymbol::SetSymbol(const SmSym *pSymbol)
1422 : {
1423 0 : if (pSymbol)
1424 : {
1425 0 : vcl::Font aFont (pSymbol->GetFace());
1426 0 : setFontSize(aFont);
1427 0 : aFont.SetAlign(ALIGN_BASELINE);
1428 0 : SetFont(aFont);
1429 :
1430 0 : sal_UCS4 cChar = pSymbol->GetCharacter();
1431 0 : OUString aText(&cChar, 1);
1432 0 : SetText( aText );
1433 : }
1434 :
1435 : // 'Invalidate' fills the background with the background color.
1436 : // If a NULL pointer has been passed that's already enough to clear the display
1437 0 : Invalidate();
1438 0 : }
1439 :
1440 :
1441 :
1442 :
1443 0 : void SmSymbolDialog::FillSymbolSets(bool bDeleteText)
1444 : // populate the entries of possible SymbolsSets in the dialog with
1445 : // current values of the SymbolSet manager but selects none of those
1446 : {
1447 0 : m_pSymbolSets->Clear();
1448 0 : if (bDeleteText)
1449 0 : m_pSymbolSets->SetNoSelection();
1450 :
1451 0 : std::set< OUString > aSybolSetNames( rSymbolMgr.GetSymbolSetNames() );
1452 0 : std::set< OUString >::const_iterator aIt( aSybolSetNames.begin() );
1453 0 : for ( ; aIt != aSybolSetNames.end(); ++aIt)
1454 0 : m_pSymbolSets->InsertEntry( *aIt );
1455 0 : }
1456 :
1457 :
1458 0 : IMPL_LINK_NOARG( SmSymbolDialog, SymbolSetChangeHdl )
1459 : {
1460 0 : SelectSymbolSet(m_pSymbolSets->GetSelectEntry());
1461 0 : return 0;
1462 : }
1463 :
1464 :
1465 0 : IMPL_LINK_NOARG( SmSymbolDialog, SymbolChangeHdl )
1466 : {
1467 0 : SelectSymbol(m_pSymbolSetDisplay->GetSelectSymbol());
1468 0 : return 0;
1469 : }
1470 :
1471 0 : IMPL_LINK_NOARG(SmSymbolDialog, EditClickHdl)
1472 : {
1473 0 : ScopedVclPtrInstance<SmSymDefineDialog> pDialog(this, pFontListDev, rSymbolMgr);
1474 :
1475 : // set current symbol and SymbolSet for the new dialog
1476 0 : const OUString aSymSetName (m_pSymbolSets->GetSelectEntry()),
1477 0 : aSymName (m_pSymbolName->GetText());
1478 0 : pDialog->SelectOldSymbolSet(aSymSetName);
1479 0 : pDialog->SelectOldSymbol(aSymName);
1480 0 : pDialog->SelectSymbolSet(aSymSetName);
1481 0 : pDialog->SelectSymbol(aSymName);
1482 :
1483 : // remember old SymbolSet
1484 0 : OUString aOldSymbolSet (m_pSymbolSets->GetSelectEntry());
1485 :
1486 0 : sal_uInt16 nSymPos = GetSelectedSymbol();
1487 :
1488 : // adapt dialog to data of the SymbolSet manager, which might have changed
1489 0 : if (pDialog->Execute() == RET_OK && rSymbolMgr.IsModified())
1490 : {
1491 0 : rSymbolMgr.Save();
1492 0 : FillSymbolSets();
1493 : }
1494 :
1495 : // if the old SymbolSet doesn't exist anymore, go to the first one SymbolSet (if one exists)
1496 0 : if (!SelectSymbolSet(aOldSymbolSet) && m_pSymbolSets->GetEntryCount() > 0)
1497 0 : SelectSymbolSet(m_pSymbolSets->GetEntry(0));
1498 : else
1499 : {
1500 : // just update display of current symbol set
1501 : assert(aSymSetName == aSymSetName); //unexpected change in symbol set name
1502 0 : aSymbolSet = rSymbolMgr.GetSymbolSet( aSymbolSetName );
1503 0 : m_pSymbolSetDisplay->SetSymbolSet( aSymbolSet );
1504 : }
1505 :
1506 0 : if (nSymPos >= aSymbolSet.size())
1507 0 : nSymPos = static_cast< sal_uInt16 >(aSymbolSet.size()) - 1;
1508 0 : SelectSymbol( nSymPos );
1509 :
1510 0 : return 0;
1511 : }
1512 :
1513 :
1514 0 : IMPL_LINK_NOARG( SmSymbolDialog, SymbolDblClickHdl )
1515 : {
1516 0 : GetClickHdl(m_pGetBtn);
1517 0 : EndDialog(RET_OK);
1518 0 : return 0;
1519 : }
1520 :
1521 :
1522 0 : IMPL_LINK_NOARG( SmSymbolDialog, GetClickHdl )
1523 : {
1524 0 : const SmSym *pSym = GetSymbol();
1525 0 : if (pSym)
1526 : {
1527 0 : OUStringBuffer aText;
1528 0 : aText.append('%').append(pSym->GetName()).append(' ');
1529 :
1530 : rViewSh.GetViewFrame()->GetDispatcher()->Execute(
1531 : SID_INSERTSYMBOL, SfxCallMode::RECORD,
1532 0 : new SfxStringItem(SID_INSERTSYMBOL, aText.makeStringAndClear()), 0L);
1533 : }
1534 :
1535 0 : return 0;
1536 : }
1537 :
1538 :
1539 0 : SmSymbolDialog::SmSymbolDialog(vcl::Window *pParent, OutputDevice *pFntListDevice,
1540 : SmSymbolManager &rMgr, SmViewShell &rViewShell)
1541 : : ModalDialog(pParent, "CatalogDialog",
1542 : "modules/smath/ui/catalogdialog.ui")
1543 :
1544 : ,
1545 :
1546 : rViewSh (rViewShell),
1547 : rSymbolMgr (rMgr),
1548 0 : pFontListDev (pFntListDevice)
1549 : {
1550 0 : get(m_pSymbolSets, "symbolset");
1551 0 : m_pSymbolSets->SetStyle(m_pSymbolSets->GetStyle()|WB_SORT);
1552 0 : get(m_pSymbolName, "symbolname");
1553 0 : get(m_pGetBtn, "insert");
1554 0 : get(m_pEditBtn, "edit");
1555 0 : get(m_pSymbolSetDisplay, "symbolsetdisplay");
1556 0 : get(m_pSymbolDisplay, "preview");
1557 :
1558 0 : aSymbolSetName.clear();
1559 0 : aSymbolSet.clear();
1560 0 : FillSymbolSets();
1561 0 : if (m_pSymbolSets->GetEntryCount() > 0)
1562 0 : SelectSymbolSet(m_pSymbolSets->GetEntry(0));
1563 :
1564 : // preview like controls should have a 2D look
1565 0 : m_pSymbolDisplay->SetBorderStyle( WindowBorderStyle::MONO );
1566 :
1567 0 : m_pSymbolSets->SetSelectHdl(LINK(this, SmSymbolDialog, SymbolSetChangeHdl));
1568 0 : m_pSymbolSetDisplay->SetSelectHdl(LINK(this, SmSymbolDialog, SymbolChangeHdl));
1569 0 : m_pSymbolSetDisplay->SetDblClickHdl(LINK(this, SmSymbolDialog, SymbolDblClickHdl));
1570 0 : m_pSymbolDisplay->SetDblClickHdl(LINK(this, SmSymbolDialog, SymbolDblClickHdl));
1571 0 : m_pEditBtn->SetClickHdl(LINK(this, SmSymbolDialog, EditClickHdl));
1572 0 : m_pGetBtn->SetClickHdl(LINK(this, SmSymbolDialog, GetClickHdl));
1573 0 : }
1574 :
1575 0 : SmSymbolDialog::~SmSymbolDialog()
1576 : {
1577 0 : disposeOnce();
1578 0 : }
1579 :
1580 0 : void SmSymbolDialog::dispose()
1581 : {
1582 0 : m_pSymbolSets.clear();
1583 0 : m_pSymbolSetDisplay.clear();
1584 0 : m_pSymbolName.clear();
1585 0 : m_pSymbolDisplay.clear();
1586 0 : m_pGetBtn.clear();
1587 0 : m_pEditBtn.clear();
1588 0 : ModalDialog::dispose();
1589 0 : }
1590 :
1591 0 : void SmSymbolDialog::DataChanged( const DataChangedEvent& rDCEvt )
1592 : {
1593 0 : if (rDCEvt.GetType() == DataChangedEventType::SETTINGS && (rDCEvt.GetFlags() & AllSettingsFlags::STYLE))
1594 : {
1595 0 : m_pSymbolDisplay->Invalidate();
1596 0 : m_pSymbolSetDisplay->Invalidate();
1597 : }
1598 :
1599 0 : ModalDialog::DataChanged( rDCEvt );
1600 0 : }
1601 :
1602 0 : bool SmSymbolDialog::SelectSymbolSet(const OUString &rSymbolSetName)
1603 : {
1604 0 : bool bRet = false;
1605 0 : sal_Int32 nPos = m_pSymbolSets->GetEntryPos(rSymbolSetName);
1606 :
1607 0 : aSymbolSetName.clear();
1608 0 : aSymbolSet.clear();
1609 0 : if (nPos != LISTBOX_ENTRY_NOTFOUND)
1610 : {
1611 0 : m_pSymbolSets->SelectEntryPos(nPos);
1612 :
1613 0 : aSymbolSetName = rSymbolSetName;
1614 0 : aSymbolSet = rSymbolMgr.GetSymbolSet( aSymbolSetName );
1615 :
1616 : // sort symbols by Unicode position (useful for displaying Greek characters alphabetically)
1617 0 : std::sort( aSymbolSet.begin(), aSymbolSet.end(), lt_SmSymPtr() );
1618 :
1619 0 : m_pSymbolSetDisplay->SetSymbolSet( aSymbolSet );
1620 0 : if (aSymbolSet.size() > 0)
1621 0 : SelectSymbol(0);
1622 :
1623 0 : bRet = true;
1624 : }
1625 : else
1626 0 : m_pSymbolSets->SetNoSelection();
1627 :
1628 0 : return bRet;
1629 : }
1630 :
1631 0 : void SmSymbolDialog::SelectSymbol(sal_uInt16 nSymbolNo)
1632 : {
1633 0 : const SmSym *pSym = NULL;
1634 0 : if (!aSymbolSetName.isEmpty() && nSymbolNo < static_cast< sal_uInt16 >(aSymbolSet.size()))
1635 0 : pSym = aSymbolSet[ nSymbolNo ];
1636 :
1637 0 : m_pSymbolSetDisplay->SelectSymbol(nSymbolNo);
1638 0 : m_pSymbolDisplay->SetSymbol(pSym);
1639 0 : m_pSymbolName->SetText(pSym ? pSym->GetName() : OUString());
1640 0 : }
1641 :
1642 0 : const SmSym* SmSymbolDialog::GetSymbol() const
1643 : {
1644 0 : sal_uInt16 nSymbolNo = m_pSymbolSetDisplay->GetSelectSymbol();
1645 0 : bool bValid = !aSymbolSetName.isEmpty() && nSymbolNo < static_cast< sal_uInt16 >(aSymbolSet.size());
1646 0 : return bValid ? aSymbolSet[ nSymbolNo ] : NULL;
1647 : }
1648 :
1649 0 : VCL_BUILDER_DECL_FACTORY(SmShowChar)
1650 : {
1651 0 : WinBits nWinStyle = 0;
1652 :
1653 0 : OString sBorder = VclBuilder::extractCustomProperty(rMap);
1654 0 : if (!sBorder.isEmpty())
1655 0 : nWinStyle |= WB_BORDER;
1656 :
1657 0 : rRet = VclPtr<SmShowChar>::Create(pParent, nWinStyle);
1658 0 : }
1659 :
1660 0 : void SmShowChar::Paint(vcl::RenderContext& rRenderContext, const Rectangle &rRect)
1661 : {
1662 0 : Control::Paint(rRenderContext, rRect);
1663 :
1664 0 : OUString aText( GetText() );
1665 0 : if (!aText.isEmpty())
1666 : {
1667 : #if OSL_DEBUG_LEVEL > 1
1668 : sal_Int32 nPos = 0;
1669 : sal_UCS4 cChar = aText.iterateCodePoints( &nPos );
1670 : (void) cChar;
1671 : #endif
1672 0 : Size aTextSize(rRenderContext.GetTextWidth(aText), rRenderContext.GetTextHeight());
1673 :
1674 0 : rRenderContext.DrawText(Point((GetOutputSize().Width() - aTextSize.Width()) / 2,
1675 0 : (GetOutputSize().Height() * 7/10)), aText);
1676 0 : }
1677 0 : }
1678 :
1679 :
1680 0 : void SmShowChar::SetSymbol( const SmSym *pSym )
1681 : {
1682 0 : if (pSym)
1683 0 : SetSymbol( pSym->GetCharacter(), pSym->GetFace() );
1684 0 : }
1685 :
1686 :
1687 0 : void SmShowChar::SetSymbol( sal_UCS4 cChar, const vcl::Font &rFont )
1688 : {
1689 0 : vcl::Font aFont( rFont );
1690 0 : aFont.SetSize( Size(0, GetOutputSize().Height() - GetOutputSize().Height() / 3) );
1691 0 : aFont.SetAlign(ALIGN_BASELINE);
1692 0 : SetFont(aFont);
1693 0 : aFont.SetTransparent(true);
1694 :
1695 0 : OUString aText(&cChar, 1);
1696 0 : SetText( aText );
1697 :
1698 0 : Invalidate();
1699 0 : }
1700 :
1701 0 : void SmShowChar::Resize()
1702 : {
1703 0 : Control::Resize();
1704 0 : const OUString &rText = GetText();
1705 0 : if (rText.isEmpty())
1706 0 : return;
1707 0 : sal_Int32 nStrIndex = 0;
1708 0 : sal_UCS4 cChar = rText.iterateCodePoints(&nStrIndex);
1709 0 : SetSymbol(cChar, GetFont()); //force recalculation of size
1710 : }
1711 :
1712 0 : void SmSymDefineDialog::FillSymbols(ComboBox &rComboBox, bool bDeleteText)
1713 : {
1714 : #if OSL_DEBUG_LEVEL > 1
1715 : OSL_ENSURE(&rComboBox == pOldSymbols || &rComboBox == pSymbols,
1716 : "Sm : wrong ComboBox");
1717 : #endif
1718 :
1719 0 : rComboBox.Clear();
1720 0 : if (bDeleteText)
1721 0 : rComboBox.SetText(OUString());
1722 :
1723 0 : ComboBox &rBox = &rComboBox == pOldSymbols ? *pOldSymbolSets : *pSymbolSets;
1724 0 : SymbolPtrVec_t aSymSet( aSymbolMgrCopy.GetSymbolSet( rBox.GetText() ) );
1725 0 : for (size_t i = 0; i < aSymSet.size(); ++i)
1726 0 : rComboBox.InsertEntry( aSymSet[i]->GetName() );
1727 0 : }
1728 :
1729 :
1730 0 : void SmSymDefineDialog::FillSymbolSets(ComboBox &rComboBox, bool bDeleteText)
1731 : {
1732 : #if OSL_DEBUG_LEVEL > 1
1733 : OSL_ENSURE(&rComboBox == pOldSymbolSets || &rComboBox == pSymbolSets,
1734 : "Sm : falsche ComboBox");
1735 : #endif
1736 :
1737 0 : rComboBox.Clear();
1738 0 : if (bDeleteText)
1739 0 : rComboBox.SetText(OUString());
1740 :
1741 0 : const std::set< OUString > aSymbolSetNames( aSymbolMgrCopy.GetSymbolSetNames() );
1742 0 : std::set< OUString >::const_iterator aIt( aSymbolSetNames.begin() );
1743 0 : for ( ; aIt != aSymbolSetNames.end(); ++aIt)
1744 0 : rComboBox.InsertEntry( *aIt );
1745 0 : }
1746 :
1747 :
1748 0 : void SmSymDefineDialog::FillFonts(bool bDelete)
1749 : {
1750 0 : pFonts->Clear();
1751 0 : if (bDelete)
1752 0 : pFonts->SetNoSelection();
1753 :
1754 : // Include all fonts of FontList into the font list.
1755 : // If there are duplicates, only include one entry of each font since the style will be
1756 : // already selected using the FontStyleBox.
1757 0 : if (pFontList)
1758 : {
1759 0 : sal_uInt16 nCount = pFontList->GetFontNameCount();
1760 0 : for (sal_uInt16 i = 0; i < nCount; i++)
1761 0 : pFonts->InsertEntry( pFontList->GetFontName(i).GetName() );
1762 : }
1763 0 : }
1764 :
1765 :
1766 0 : void SmSymDefineDialog::FillStyles(bool bDeleteText)
1767 : {
1768 0 : pStyles->Clear();
1769 0 : if (bDeleteText)
1770 0 : pStyles->SetText(OUString());
1771 :
1772 0 : OUString aText (pFonts->GetSelectEntry());
1773 0 : if (!aText.isEmpty())
1774 : {
1775 : // use own StyleNames
1776 0 : const SmFontStyles &rStyles = GetFontStyles();
1777 0 : for (sal_uInt16 i = 0; i < SmFontStyles::GetCount(); i++)
1778 0 : pStyles->InsertEntry( rStyles.GetStyleName(i) );
1779 :
1780 : #if OSL_DEBUG_LEVEL > 1
1781 : OSL_ENSURE(pStyles->GetEntryCount() > 0, "Sm : no styles available");
1782 : #endif
1783 0 : pStyles->SetText( pStyles->GetEntry(0) );
1784 0 : }
1785 0 : }
1786 :
1787 :
1788 0 : SmSym * SmSymDefineDialog::GetSymbol(const ComboBox &rComboBox)
1789 : {
1790 : #if OSL_DEBUG_LEVEL > 1
1791 : OSL_ENSURE(&rComboBox == pOldSymbols || &rComboBox == pSymbols,
1792 : "Sm : wrong combobox");
1793 : #endif
1794 0 : return aSymbolMgrCopy.GetSymbolByName(rComboBox.GetText());
1795 : }
1796 :
1797 :
1798 0 : IMPL_LINK( SmSymDefineDialog, OldSymbolChangeHdl, ComboBox *, pComboBox )
1799 : {
1800 : (void) pComboBox;
1801 : #if OSL_DEBUG_LEVEL > 1
1802 : OSL_ENSURE(pComboBox == pOldSymbols, "Sm : wrong argument");
1803 : #endif
1804 0 : SelectSymbol(*pOldSymbols, pOldSymbols->GetText(), false);
1805 0 : return 0;
1806 : }
1807 :
1808 :
1809 0 : IMPL_LINK( SmSymDefineDialog, OldSymbolSetChangeHdl, ComboBox *, pComboBox )
1810 : {
1811 : (void) pComboBox;
1812 : #if OSL_DEBUG_LEVEL > 1
1813 : OSL_ENSURE(pComboBox == pOldSymbolSets, "Sm : wrong argument");
1814 : #endif
1815 0 : SelectSymbolSet(*pOldSymbolSets, pOldSymbolSets->GetText(), false);
1816 0 : return 0;
1817 : }
1818 :
1819 :
1820 0 : IMPL_LINK( SmSymDefineDialog, ModifyHdl, ComboBox *, pComboBox )
1821 : {
1822 : // remember cursor position for later restoring of it
1823 0 : Selection aSelection (pComboBox->GetSelection());
1824 :
1825 0 : if (pComboBox == pSymbols)
1826 0 : SelectSymbol(*pSymbols, pSymbols->GetText(), false);
1827 0 : else if (pComboBox == pSymbolSets)
1828 0 : SelectSymbolSet(*pSymbolSets, pSymbolSets->GetText(), false);
1829 0 : else if (pComboBox == pOldSymbols)
1830 : // allow only names from the list
1831 0 : SelectSymbol(*pOldSymbols, pOldSymbols->GetText(), true);
1832 0 : else if (pComboBox == pOldSymbolSets)
1833 : // allow only names from the list
1834 0 : SelectSymbolSet(*pOldSymbolSets, pOldSymbolSets->GetText(), true);
1835 0 : else if (pComboBox == pStyles)
1836 : // allow only names from the list (that's the case here anyway)
1837 0 : SelectStyle(pStyles->GetText(), true);
1838 : else
1839 : SAL_WARN("starmath", "wrong combobox argument");
1840 :
1841 0 : pComboBox->SetSelection(aSelection);
1842 :
1843 0 : UpdateButtons();
1844 :
1845 0 : return 0;
1846 : }
1847 :
1848 :
1849 0 : IMPL_LINK( SmSymDefineDialog, FontChangeHdl, ListBox *, pListBox )
1850 : {
1851 : (void) pListBox;
1852 : #if OSL_DEBUG_LEVEL > 1
1853 : OSL_ENSURE(pListBox == pFonts, "Sm : wrong argument");
1854 : #endif
1855 :
1856 0 : SelectFont(pFonts->GetSelectEntry());
1857 0 : return 0;
1858 : }
1859 :
1860 :
1861 0 : IMPL_LINK( SmSymDefineDialog, SubsetChangeHdl, ListBox *, pListBox )
1862 : {
1863 : (void) pListBox;
1864 0 : sal_Int32 nPos = pFontsSubsetLB->GetSelectEntryPos();
1865 0 : if (LISTBOX_ENTRY_NOTFOUND != nPos)
1866 : {
1867 0 : const Subset* pSubset = static_cast<const Subset*> (pFontsSubsetLB->GetEntryData( nPos ));
1868 0 : if (pSubset)
1869 : {
1870 0 : pCharsetDisplay->SelectCharacter( pSubset->GetRangeMin() );
1871 : }
1872 : }
1873 0 : return 0;
1874 : }
1875 :
1876 :
1877 0 : IMPL_LINK( SmSymDefineDialog, StyleChangeHdl, ComboBox *, pComboBox )
1878 : {
1879 : (void) pComboBox;
1880 : #if OSL_DEBUG_LEVEL > 1
1881 : OSL_ENSURE(pComboBox == pStyles, "Sm : falsches Argument");
1882 : #endif
1883 :
1884 0 : SelectStyle(pStyles->GetText());
1885 0 : return 0;
1886 : }
1887 :
1888 :
1889 0 : IMPL_LINK_NOARG(SmSymDefineDialog, CharHighlightHdl)
1890 : {
1891 0 : sal_UCS4 cChar = pCharsetDisplay->GetSelectCharacter();
1892 :
1893 : #if OSL_DEBUG_LEVEL > 1
1894 : OSL_ENSURE( pSubsetMap, "SubsetMap missing" );
1895 : #endif
1896 0 : if (pSubsetMap)
1897 : {
1898 0 : const Subset* pSubset = pSubsetMap->GetSubsetByUnicode( cChar );
1899 0 : if (pSubset)
1900 0 : pFontsSubsetLB->SelectEntry( pSubset->GetName() );
1901 : else
1902 0 : pFontsSubsetLB->SetNoSelection();
1903 : }
1904 :
1905 0 : pSymbolDisplay->SetSymbol( cChar, pCharsetDisplay->GetFont() );
1906 :
1907 0 : UpdateButtons();
1908 :
1909 : // display Unicode position as symbol name while iterating over characters
1910 0 : const OUString aHex(OUString::number(cChar, 16 ).toAsciiUpperCase());
1911 0 : const OUString aPattern( (aHex.getLength() > 4) ? OUString("Ux000000") : OUString("Ux0000") );
1912 0 : OUString aUnicodePos( aPattern.copy( 0, aPattern.getLength() - aHex.getLength() ) );
1913 0 : aUnicodePos += aHex;
1914 0 : pSymbols->SetText( aUnicodePos );
1915 0 : pSymbolName->SetText( aUnicodePos );
1916 :
1917 0 : return 0;
1918 : }
1919 :
1920 :
1921 0 : IMPL_LINK( SmSymDefineDialog, AddClickHdl, Button *, pButton )
1922 : {
1923 : (void) pButton;
1924 : #if OSL_DEBUG_LEVEL > 1
1925 : OSL_ENSURE(pButton == pAddBtn, "Sm : wrong argument");
1926 : OSL_ENSURE(pAddBtn->IsEnabled(), "Sm : requirements met ??");
1927 : #endif
1928 :
1929 : // add symbol
1930 0 : const SmSym aNewSymbol( pSymbols->GetText(), pCharsetDisplay->GetFont(),
1931 0 : pCharsetDisplay->GetSelectCharacter(), pSymbolSets->GetText() );
1932 : //OSL_ENSURE( aSymbolMgrCopy.GetSymbolByName(aTmpSymbolName) == NULL, "symbol already exists" );
1933 0 : aSymbolMgrCopy.AddOrReplaceSymbol( aNewSymbol );
1934 :
1935 : // update display of new symbol
1936 0 : pSymbolDisplay->SetSymbol( &aNewSymbol );
1937 0 : pSymbolName->SetText( aNewSymbol.GetName() );
1938 0 : pSymbolSetName->SetText( aNewSymbol.GetSymbolSetName() );
1939 :
1940 : // update list box entries
1941 0 : FillSymbolSets(*pOldSymbolSets, false);
1942 0 : FillSymbolSets(*pSymbolSets, false);
1943 0 : FillSymbols(*pOldSymbols ,false);
1944 0 : FillSymbols(*pSymbols ,false);
1945 :
1946 0 : UpdateButtons();
1947 :
1948 0 : return 0;
1949 : }
1950 :
1951 :
1952 0 : IMPL_LINK( SmSymDefineDialog, ChangeClickHdl, Button *, pButton )
1953 : {
1954 : (void) pButton;
1955 : #if OSL_DEBUG_LEVEL > 1
1956 : OSL_ENSURE(pButton == pChangeBtn, "Sm : wrong argument");
1957 : OSL_ENSURE(pChangeBtn->IsEnabled(), "Sm : requirements met ??");
1958 : #endif
1959 :
1960 : // get new Sybol to use
1961 : //! get font from symbol-disp lay since charset-display does not keep
1962 : //! the bold attribute.
1963 0 : const SmSym aNewSymbol( pSymbols->GetText(), pCharsetDisplay->GetFont(),
1964 0 : pCharsetDisplay->GetSelectCharacter(), pSymbolSets->GetText() );
1965 :
1966 : // remove old symbol if the name was changed then add new one
1967 0 : const bool bNameChanged = pOldSymbols->GetText() != pSymbols->GetText();
1968 0 : if (bNameChanged)
1969 0 : aSymbolMgrCopy.RemoveSymbol( pOldSymbols->GetText() );
1970 0 : aSymbolMgrCopy.AddOrReplaceSymbol( aNewSymbol, true );
1971 :
1972 : // clear display for original symbol if necessary
1973 0 : if (bNameChanged)
1974 0 : SetOrigSymbol(NULL, OUString());
1975 :
1976 : // update display of new symbol
1977 0 : pSymbolDisplay->SetSymbol( &aNewSymbol );
1978 0 : pSymbolName->SetText( aNewSymbol.GetName() );
1979 0 : pSymbolSetName->SetText( aNewSymbol.GetSymbolSetName() );
1980 :
1981 : // update list box entries
1982 0 : FillSymbolSets(*pOldSymbolSets, false);
1983 0 : FillSymbolSets(*pSymbolSets, false);
1984 0 : FillSymbols(*pOldSymbols ,false);
1985 0 : FillSymbols(*pSymbols ,false);
1986 :
1987 0 : UpdateButtons();
1988 :
1989 0 : return 0;
1990 : }
1991 :
1992 :
1993 0 : IMPL_LINK( SmSymDefineDialog, DeleteClickHdl, Button *, pButton )
1994 : {
1995 : (void) pButton;
1996 : #if OSL_DEBUG_LEVEL > 1
1997 : OSL_ENSURE(pButton == pDeleteBtn, "Sm : wrong argument");
1998 : OSL_ENSURE(pDeleteBtn->IsEnabled(), "Sm : requirements met ??");
1999 : #endif
2000 :
2001 0 : if (pOrigSymbol)
2002 : {
2003 0 : aSymbolMgrCopy.RemoveSymbol( pOrigSymbol->GetName() );
2004 :
2005 : // clear display for original symbol
2006 0 : SetOrigSymbol(NULL, OUString());
2007 :
2008 : // update list box entries
2009 0 : FillSymbolSets(*pOldSymbolSets, false);
2010 0 : FillSymbolSets(*pSymbolSets, false);
2011 0 : FillSymbols(*pOldSymbols ,false);
2012 0 : FillSymbols(*pSymbols ,false);
2013 : }
2014 :
2015 0 : UpdateButtons();
2016 :
2017 0 : return 0;
2018 : }
2019 :
2020 :
2021 0 : void SmSymDefineDialog::UpdateButtons()
2022 : {
2023 0 : bool bAdd = false,
2024 0 : bChange = false,
2025 0 : bDelete = false;
2026 0 : OUString aTmpSymbolName (pSymbols->GetText()),
2027 0 : aTmpSymbolSetName (pSymbolSets->GetText());
2028 :
2029 0 : if (aTmpSymbolName.getLength() > 0 && aTmpSymbolSetName.getLength() > 0)
2030 : {
2031 : // are all settings equal?
2032 : //! (Font-, Style- und SymbolSet name comparison is not case sensitive)
2033 : bool bEqual = pOrigSymbol
2034 0 : && aTmpSymbolSetName.equalsIgnoreAsciiCase(pOldSymbolSetName->GetText())
2035 0 : && aTmpSymbolName.equals(pOrigSymbol->GetName())
2036 0 : && pFonts->GetSelectEntry().equalsIgnoreAsciiCase(
2037 0 : pOrigSymbol->GetFace().GetName())
2038 0 : && pStyles->GetText().equalsIgnoreAsciiCase(
2039 0 : GetFontStyles().GetStyleName(pOrigSymbol->GetFace()))
2040 0 : && pCharsetDisplay->GetSelectCharacter() == pOrigSymbol->GetCharacter();
2041 :
2042 : // only add it if there isn't already a symbol with the same name
2043 0 : bAdd = aSymbolMgrCopy.GetSymbolByName(aTmpSymbolName) == NULL;
2044 :
2045 : // only delete it if all settings are equal
2046 0 : bDelete = bool(pOrigSymbol);
2047 :
2048 : // only change it if the old symbol exists and the new one is different
2049 0 : bChange = pOrigSymbol && !bEqual;
2050 : }
2051 :
2052 0 : pAddBtn ->Enable(bAdd);
2053 0 : pChangeBtn->Enable(bChange);
2054 0 : pDeleteBtn->Enable(bDelete);
2055 0 : }
2056 :
2057 0 : SmSymDefineDialog::SmSymDefineDialog(vcl::Window * pParent,
2058 : OutputDevice *pFntListDevice, SmSymbolManager &rMgr) :
2059 : ModalDialog (pParent, "EditSymbols", "modules/smath/ui/symdefinedialog.ui"),
2060 : rSymbolMgr (rMgr),
2061 : pOrigSymbol (),
2062 : pSubsetMap (),
2063 0 : pFontList (NULL)
2064 : {
2065 0 : get(pOldSymbols, "oldSymbols");
2066 0 : get(pOldSymbolSets, "oldSymbolSets");
2067 0 : get(pCharsetDisplay, "charsetDisplay");
2068 0 : get(pSymbols, "symbols");
2069 0 : get(pSymbolSets, "symbolSets");
2070 0 : get(pFonts, "fonts");
2071 0 : get(pFontsSubsetLB, "fontsSubsetLB");
2072 0 : get(pStyles, "styles");
2073 0 : get(pOldSymbolName, "oldSymbolName");
2074 0 : get(pOldSymbolDisplay, "oldSymbolDisplay");
2075 0 : get(pOldSymbolSetName, "oldSymbolSetName");
2076 0 : get(pSymbolName, "symbolName");
2077 0 : get(pSymbolDisplay, "symbolDisplay");
2078 0 : get(pSymbolSetName, "symbolSetName");
2079 0 : get(pAddBtn, "add");
2080 0 : get(pChangeBtn, "modify");
2081 0 : get(pDeleteBtn, "delete");
2082 :
2083 0 : pFontList = new FontList( pFntListDevice );
2084 :
2085 : // auto completion is troublesome since that symbols character also gets automatically selected in the
2086 : // display and if the user previously selected a character to define/redefine that one this is bad
2087 0 : pOldSymbols->EnableAutocomplete( false, true );
2088 0 : pSymbols->EnableAutocomplete( false, true );
2089 :
2090 0 : FillFonts();
2091 0 : if (pFonts->GetEntryCount() > 0)
2092 0 : SelectFont(pFonts->GetEntry(0));
2093 :
2094 0 : SetSymbolSetManager(rSymbolMgr);
2095 :
2096 0 : pOldSymbols ->SetSelectHdl(LINK(this, SmSymDefineDialog, OldSymbolChangeHdl));
2097 0 : pOldSymbolSets ->SetSelectHdl(LINK(this, SmSymDefineDialog, OldSymbolSetChangeHdl));
2098 0 : pSymbolSets ->SetModifyHdl(LINK(this, SmSymDefineDialog, ModifyHdl));
2099 0 : pOldSymbolSets ->SetModifyHdl(LINK(this, SmSymDefineDialog, ModifyHdl));
2100 0 : pSymbols ->SetModifyHdl(LINK(this, SmSymDefineDialog, ModifyHdl));
2101 0 : pOldSymbols ->SetModifyHdl(LINK(this, SmSymDefineDialog, ModifyHdl));
2102 0 : pStyles ->SetModifyHdl(LINK(this, SmSymDefineDialog, ModifyHdl));
2103 0 : pFonts ->SetSelectHdl(LINK(this, SmSymDefineDialog, FontChangeHdl));
2104 0 : pFontsSubsetLB ->SetSelectHdl(LINK(this, SmSymDefineDialog, SubsetChangeHdl));
2105 0 : pStyles ->SetSelectHdl(LINK(this, SmSymDefineDialog, StyleChangeHdl));
2106 0 : pAddBtn ->SetClickHdl (LINK(this, SmSymDefineDialog, AddClickHdl));
2107 0 : pChangeBtn ->SetClickHdl (LINK(this, SmSymDefineDialog, ChangeClickHdl));
2108 0 : pDeleteBtn ->SetClickHdl (LINK(this, SmSymDefineDialog, DeleteClickHdl));
2109 0 : pCharsetDisplay ->SetHighlightHdl( LINK( this, SmSymDefineDialog, CharHighlightHdl ) );
2110 :
2111 : // preview like controls should have a 2D look
2112 0 : pOldSymbolDisplay->SetBorderStyle( WindowBorderStyle::MONO );
2113 0 : pSymbolDisplay ->SetBorderStyle( WindowBorderStyle::MONO );
2114 0 : }
2115 :
2116 :
2117 0 : SmSymDefineDialog::~SmSymDefineDialog()
2118 : {
2119 0 : disposeOnce();
2120 0 : }
2121 :
2122 0 : void SmSymDefineDialog::dispose()
2123 : {
2124 0 : pSubsetMap.reset();
2125 0 : pOrigSymbol.reset();
2126 0 : pOldSymbols.clear();
2127 0 : pOldSymbolSets.clear();
2128 0 : pCharsetDisplay.clear();
2129 0 : pSymbols.clear();
2130 0 : pSymbolSets.clear();
2131 0 : pFonts.clear();
2132 0 : pFontsSubsetLB.clear();
2133 0 : pStyles.clear();
2134 0 : pOldSymbolName.clear();
2135 0 : pOldSymbolDisplay.clear();
2136 0 : pOldSymbolSetName.clear();
2137 0 : pSymbolName.clear();
2138 0 : pSymbolDisplay.clear();
2139 0 : pSymbolSetName.clear();
2140 0 : pAddBtn.clear();
2141 0 : pChangeBtn.clear();
2142 0 : pDeleteBtn.clear();
2143 0 : ModalDialog::dispose();
2144 0 : }
2145 :
2146 0 : void SmSymDefineDialog::DataChanged( const DataChangedEvent& rDCEvt )
2147 : {
2148 0 : if (rDCEvt.GetType() == DataChangedEventType::SETTINGS && (rDCEvt.GetFlags() & AllSettingsFlags::STYLE))
2149 : {
2150 0 : Invalidate();
2151 : }
2152 0 : ModalDialog::DataChanged( rDCEvt );
2153 0 : }
2154 :
2155 :
2156 0 : short SmSymDefineDialog::Execute()
2157 : {
2158 0 : short nResult = ModalDialog::Execute();
2159 :
2160 : // apply changes if dialog was closed by clicking OK
2161 0 : if (aSymbolMgrCopy.IsModified() && nResult == RET_OK)
2162 0 : rSymbolMgr = aSymbolMgrCopy;
2163 :
2164 0 : return nResult;
2165 : }
2166 :
2167 :
2168 0 : void SmSymDefineDialog::SetSymbolSetManager(const SmSymbolManager &rMgr)
2169 : {
2170 0 : aSymbolMgrCopy = rMgr;
2171 :
2172 : // Set the modified flag of the copy to false so that
2173 : // we can check later on if anything has been changed
2174 0 : aSymbolMgrCopy.SetModified(false);
2175 :
2176 0 : FillSymbolSets(*pOldSymbolSets);
2177 0 : if (pOldSymbolSets->GetEntryCount() > 0)
2178 0 : SelectSymbolSet(pOldSymbolSets->GetEntry(0));
2179 0 : FillSymbolSets(*pSymbolSets);
2180 0 : if (pSymbolSets->GetEntryCount() > 0)
2181 0 : SelectSymbolSet(pSymbolSets->GetEntry(0));
2182 0 : FillSymbols(*pOldSymbols);
2183 0 : if (pOldSymbols->GetEntryCount() > 0)
2184 0 : SelectSymbol(pOldSymbols->GetEntry(0));
2185 0 : FillSymbols(*pSymbols);
2186 0 : if (pSymbols->GetEntryCount() > 0)
2187 0 : SelectSymbol(pSymbols->GetEntry(0));
2188 :
2189 0 : UpdateButtons();
2190 0 : }
2191 :
2192 :
2193 0 : bool SmSymDefineDialog::SelectSymbolSet(ComboBox &rComboBox,
2194 : const OUString &rSymbolSetName, bool bDeleteText)
2195 : {
2196 : #if OSL_DEBUG_LEVEL > 1
2197 : OSL_ENSURE(&rComboBox == pOldSymbolSets || &rComboBox == pSymbolSets,
2198 : "Sm : wrong ComboBox");
2199 : #endif
2200 :
2201 : // trim SymbolName (no leading and trailing blanks)
2202 0 : OUString aNormName (rSymbolSetName);
2203 0 : aNormName = comphelper::string::stripStart(aNormName, ' ');
2204 0 : aNormName = comphelper::string::stripEnd(aNormName, ' ');
2205 : // and remove possible deviations within the input
2206 0 : rComboBox.SetText(aNormName);
2207 :
2208 0 : bool bRet = false;
2209 0 : sal_Int32 nPos = rComboBox.GetEntryPos(aNormName);
2210 :
2211 0 : if (nPos != COMBOBOX_ENTRY_NOTFOUND)
2212 : {
2213 0 : rComboBox.SetText(rComboBox.GetEntry(nPos));
2214 0 : bRet = true;
2215 : }
2216 0 : else if (bDeleteText)
2217 0 : rComboBox.SetText(OUString());
2218 :
2219 0 : bool bIsOld = &rComboBox == pOldSymbolSets;
2220 :
2221 : // setting the SymbolSet name at the associated display
2222 0 : FixedText &rFT = bIsOld ? *pOldSymbolSetName : *pSymbolSetName;
2223 0 : rFT.SetText(rComboBox.GetText());
2224 :
2225 : // set the symbol name which belongs to the SymbolSet at the associated combobox
2226 0 : ComboBox &rCB = bIsOld ? *pOldSymbols : *pSymbols;
2227 0 : FillSymbols(rCB, false);
2228 :
2229 : // display a valid respectively no symbol when changing the SymbolSets
2230 0 : if (bIsOld)
2231 : {
2232 0 : OUString aTmpOldSymbolName;
2233 0 : if (pOldSymbols->GetEntryCount() > 0)
2234 0 : aTmpOldSymbolName = pOldSymbols->GetEntry(0);
2235 0 : SelectSymbol(*pOldSymbols, aTmpOldSymbolName, true);
2236 : }
2237 :
2238 0 : UpdateButtons();
2239 :
2240 0 : return bRet;
2241 : }
2242 :
2243 :
2244 0 : void SmSymDefineDialog::SetOrigSymbol(const SmSym *pSymbol,
2245 : const OUString &rSymbolSetName)
2246 : {
2247 : // clear old symbol
2248 0 : pOrigSymbol.reset();
2249 :
2250 0 : OUString aSymName,
2251 0 : aSymSetName;
2252 0 : if (pSymbol)
2253 : {
2254 : // set new symbol
2255 0 : pOrigSymbol.reset(new SmSym( *pSymbol ));
2256 :
2257 0 : aSymName = pSymbol->GetName();
2258 0 : aSymSetName = rSymbolSetName;
2259 0 : pOldSymbolDisplay->SetSymbol( pSymbol );
2260 : }
2261 : else
2262 : { // delete displayed symbols
2263 0 : pOldSymbolDisplay->SetText(OUString());
2264 0 : pOldSymbolDisplay->Invalidate();
2265 : }
2266 0 : pOldSymbolName->SetText(aSymName);
2267 0 : pOldSymbolSetName->SetText(aSymSetName);
2268 0 : }
2269 :
2270 :
2271 0 : bool SmSymDefineDialog::SelectSymbol(ComboBox &rComboBox,
2272 : const OUString &rSymbolName, bool bDeleteText)
2273 : {
2274 : #if OSL_DEBUG_LEVEL > 1
2275 : OSL_ENSURE(&rComboBox == pOldSymbols || &rComboBox == pSymbols,
2276 : "Sm : wrong ComboBox");
2277 : #endif
2278 :
2279 : // trim SymbolName (no blanks)
2280 0 : OUString aNormName(comphelper::string::remove(rSymbolName, ' '));
2281 : // and remove possible deviations within the input
2282 0 : rComboBox.SetText(aNormName);
2283 :
2284 0 : bool bRet = false;
2285 0 : sal_Int32 nPos = rComboBox.GetEntryPos(aNormName);
2286 :
2287 0 : bool bIsOld = &rComboBox == pOldSymbols;
2288 :
2289 0 : if (nPos != COMBOBOX_ENTRY_NOTFOUND)
2290 : {
2291 0 : rComboBox.SetText(rComboBox.GetEntry(nPos));
2292 :
2293 0 : if (!bIsOld)
2294 : {
2295 0 : const SmSym *pSymbol = GetSymbol(*pSymbols);
2296 0 : if (pSymbol)
2297 : {
2298 : // choose font and style accordingly
2299 0 : const vcl::Font &rFont = pSymbol->GetFace();
2300 0 : SelectFont(rFont.GetName(), false);
2301 0 : SelectStyle(GetFontStyles().GetStyleName(rFont), false);
2302 :
2303 : // Since setting the Font via the Style name of the SymbolFonts doesn't
2304 : // work really well (e.g. it can be empty even though the font itself is
2305 : // bold or italic) we're manually setting the Font with respect to the Symbol
2306 0 : pCharsetDisplay->SetFont(rFont);
2307 0 : pSymbolDisplay->SetFont(rFont);
2308 :
2309 : // select associated character
2310 0 : SelectChar(pSymbol->GetCharacter());
2311 :
2312 : // since SelectChar will also set the unicode point as text in the
2313 : // symbols box, we have to set the symbol name again to get that one displayed
2314 0 : pSymbols->SetText( pSymbol->GetName() );
2315 : }
2316 : }
2317 :
2318 0 : bRet = true;
2319 : }
2320 0 : else if (bDeleteText)
2321 0 : rComboBox.SetText(OUString());
2322 :
2323 0 : if (bIsOld)
2324 : {
2325 : // if there's a change of the old symbol, show only the available ones, otherwise show none
2326 0 : const SmSym *pOldSymbol = NULL;
2327 0 : OUString aTmpOldSymbolSetName;
2328 0 : if (nPos != COMBOBOX_ENTRY_NOTFOUND)
2329 : {
2330 0 : pOldSymbol = aSymbolMgrCopy.GetSymbolByName(aNormName);
2331 0 : aTmpOldSymbolSetName = pOldSymbolSets->GetText();
2332 : }
2333 0 : SetOrigSymbol(pOldSymbol, aTmpOldSymbolSetName);
2334 : }
2335 : else
2336 0 : pSymbolName->SetText(rComboBox.GetText());
2337 :
2338 0 : UpdateButtons();
2339 :
2340 0 : return bRet;
2341 : }
2342 :
2343 :
2344 0 : void SmSymDefineDialog::SetFont(const OUString &rFontName, const OUString &rStyleName)
2345 : {
2346 : // get Font (FontInfo) matching name and style
2347 0 : vcl::FontInfo aFI;
2348 0 : if (pFontList)
2349 0 : aFI = pFontList->Get(rFontName, WEIGHT_NORMAL, ITALIC_NONE);
2350 0 : SetFontStyle(rStyleName, aFI);
2351 :
2352 0 : pCharsetDisplay->SetFont(aFI);
2353 0 : pSymbolDisplay->SetFont(aFI);
2354 :
2355 : // update subset listbox for new font's unicode subsets
2356 0 : FontCharMapPtr pFontCharMap;
2357 0 : pCharsetDisplay->GetFontCharMap( pFontCharMap );
2358 0 : pSubsetMap.reset(new SubsetMap( pFontCharMap ));
2359 :
2360 0 : pFontsSubsetLB->Clear();
2361 0 : bool bFirst = true;
2362 : const Subset* pSubset;
2363 0 : while( NULL != (pSubset = pSubsetMap->GetNextSubset( bFirst )) )
2364 : {
2365 0 : sal_uInt16 nPos = pFontsSubsetLB->InsertEntry( pSubset->GetName());
2366 0 : pFontsSubsetLB->SetEntryData( nPos, const_cast<Subset *>(pSubset) );
2367 : // subset must live at least as long as the selected font !!!
2368 0 : if( bFirst )
2369 0 : pFontsSubsetLB->SelectEntryPos( nPos );
2370 0 : bFirst = false;
2371 : }
2372 0 : if( bFirst )
2373 0 : pFontsSubsetLB->SetNoSelection();
2374 0 : pFontsSubsetLB->Enable( !bFirst );
2375 :
2376 0 : pFontCharMap = 0;
2377 0 : }
2378 :
2379 :
2380 0 : bool SmSymDefineDialog::SelectFont(const OUString &rFontName, bool bApplyFont)
2381 : {
2382 0 : bool bRet = false;
2383 0 : sal_Int32 nPos = pFonts->GetEntryPos(rFontName);
2384 :
2385 0 : if (nPos != LISTBOX_ENTRY_NOTFOUND)
2386 : {
2387 0 : pFonts->SelectEntryPos(nPos);
2388 0 : if (pStyles->GetEntryCount() > 0)
2389 0 : SelectStyle(pStyles->GetEntry(0));
2390 0 : if (bApplyFont)
2391 : {
2392 0 : SetFont(pFonts->GetSelectEntry(), pStyles->GetText());
2393 0 : bRet = true;
2394 0 : pSymbolDisplay->SetSymbol( pCharsetDisplay->GetSelectCharacter(), pCharsetDisplay->GetFont() );
2395 : }
2396 0 : bRet = true;
2397 : }
2398 : else
2399 0 : pFonts->SetNoSelection();
2400 0 : FillStyles();
2401 :
2402 0 : UpdateButtons();
2403 :
2404 0 : return bRet;
2405 : }
2406 :
2407 :
2408 0 : bool SmSymDefineDialog::SelectStyle(const OUString &rStyleName, bool bApplyFont)
2409 : {
2410 0 : bool bRet = false;
2411 0 : sal_Int32 nPos = pStyles->GetEntryPos(rStyleName);
2412 :
2413 : // if the style is not available take the first available one (if existent)
2414 0 : if (nPos == COMBOBOX_ENTRY_NOTFOUND && pStyles->GetEntryCount() > 0)
2415 0 : nPos = 0;
2416 :
2417 0 : if (nPos != COMBOBOX_ENTRY_NOTFOUND)
2418 : {
2419 0 : pStyles->SetText(pStyles->GetEntry(nPos));
2420 0 : if (bApplyFont)
2421 : {
2422 0 : SetFont(pFonts->GetSelectEntry(), pStyles->GetText());
2423 0 : bRet = true;
2424 0 : pSymbolDisplay->SetSymbol( pCharsetDisplay->GetSelectCharacter(), pCharsetDisplay->GetFont() );
2425 : }
2426 0 : bRet = true;
2427 : }
2428 : else
2429 0 : pStyles->SetText(OUString());
2430 :
2431 0 : UpdateButtons();
2432 :
2433 0 : return bRet;
2434 : }
2435 :
2436 :
2437 0 : void SmSymDefineDialog::SelectChar(sal_Unicode cChar)
2438 : {
2439 0 : pCharsetDisplay->SelectCharacter( cChar );
2440 0 : pSymbolDisplay->SetSymbol( cChar, pCharsetDisplay->GetFont() );
2441 :
2442 0 : UpdateButtons();
2443 42 : }
2444 :
2445 :
2446 : /**************************************************************************/
2447 :
2448 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
