starmath/source/dialog.cxx

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