diff options
Diffstat (limited to 'src/gui/configuration/NotationConfigurationPage.cpp')
| -rw-r--r-- | src/gui/configuration/NotationConfigurationPage.cpp | 741 |
1 files changed, 741 insertions, 0 deletions
diff --git a/src/gui/configuration/NotationConfigurationPage.cpp b/src/gui/configuration/NotationConfigurationPage.cpp new file mode 100644 index 0000000..a828fe7 --- /dev/null +++ b/src/gui/configuration/NotationConfigurationPage.cpp @@ -0,0 +1,741 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "NotationConfigurationPage.h" +#include <qlayout.h> + +#include "misc/Strings.h" +#include "document/ConfigGroups.h" +#include "base/Exception.h" +#include "base/NotationTypes.h" +#include "commands/edit/PasteEventsCommand.h" +#include "ConfigurationPage.h" +#include "document/RosegardenGUIDoc.h" +#include "gui/editors/notation/HeadersGroup.h" +#include "gui/editors/notation/NotationHLayout.h" +#include "gui/editors/notation/NoteFontFactory.h" +#include "gui/editors/notation/NoteFont.h" +#include "gui/editors/notation/NoteFontMap.h" +#include "gui/editors/notation/NoteFontViewer.h" +#include "gui/editors/notation/NotePixmapFactory.h" +#include "gui/editors/notation/NoteStyleFactory.h" +#include "gui/widgets/QuantizeParameters.h" +#include "TabbedConfigurationPage.h" +#include <kcombobox.h> +#include <kconfig.h> +#include <kfontrequester.h> +#include <kmessagebox.h> +#include <qcheckbox.h> +#include <qcombobox.h> +#include <qfont.h> +#include <qframe.h> +#include <qgroupbox.h> +#include <qhbox.h> +#include <qlabel.h> +#include <qobject.h> +#include <qpushbutton.h> +#include <qstring.h> +#include <qstringlist.h> +#include <qtabwidget.h> +#include <qwidget.h> +#include <qtooltip.h> +#include <algorithm> + +namespace Rosegarden +{ + +NotationConfigurationPage::NotationConfigurationPage(KConfig *cfg, + QWidget *parent, + const char *name) : + TabbedConfigurationPage(cfg, parent, name) +{ + m_cfg->setGroup(NotationViewConfigGroup); + + QFrame *frame; + QGridLayout *layout; + + frame = new QFrame(m_tabWidget); + layout = new QGridLayout(frame, 9, 3, 10, 5); + + int row = 0; + + layout->setRowSpacing(row, 15); + ++row; + + layout->addWidget(new QLabel(i18n("Default layout mode"), frame), row, 0); + + m_layoutMode = new KComboBox(frame); + m_layoutMode->setEditable(false); + m_layoutMode->insertItem(i18n("Linear layout")); + m_layoutMode->insertItem(i18n("Continuous page layout")); + m_layoutMode->insertItem(i18n("Multiple page layout")); + int defaultLayoutMode = m_cfg->readNumEntry("layoutmode", 0); + if (defaultLayoutMode >= 0 && defaultLayoutMode <= 2) { + m_layoutMode->setCurrentItem(defaultLayoutMode); + } + layout->addMultiCellWidget(m_layoutMode, row, row, 1, 2); + ++row; + + layout->addWidget(new QLabel(i18n("Default spacing"), frame), row, 0); + + m_spacing = new KComboBox(frame); + m_spacing->setEditable(false); + + std::vector<int> s = NotationHLayout::getAvailableSpacings(); + int defaultSpacing = m_cfg->readNumEntry("spacing", 100); + + for (std::vector<int>::iterator i = s.begin(); i != s.end(); ++i) { + + QString text("%1 %"); + if (*i == 100) + text = "%1 % (normal)"; + m_spacing->insertItem(text.arg(*i)); + + if (*i == defaultSpacing) { + m_spacing->setCurrentItem(m_spacing->count() - 1); + } + } + + layout->addMultiCellWidget(m_spacing, row, row, 1, 2); + + ++row; + + layout->addWidget(new QLabel(i18n("Default duration factor"), frame), row, 0); + + m_proportion = new KComboBox(frame); + m_proportion->setEditable(false); + + s = NotationHLayout::getAvailableProportions(); + int defaultProportion = m_cfg->readNumEntry("proportion", 60); + + for (std::vector<int>::iterator i = s.begin(); i != s.end(); ++i) { + + QString text = QString("%1 %").arg(*i); + if (*i == 40) + text = "40 % (normal)"; + else if (*i == 0) + text = i18n("None"); + else if (*i == 100) + text = i18n("Full"); + m_proportion->insertItem(text); + + if (*i == defaultProportion) { + m_proportion->setCurrentItem(m_proportion->count() - 1); + } + } + + layout->addMultiCellWidget(m_proportion, row, row, 1, 2); + ++row; + + layout->addWidget(new QLabel(i18n("Show track headers (linear layout only)"), + frame), row, 0); + + m_showTrackHeaders = new KComboBox(frame); + m_showTrackHeaders->setEditable(false); + m_showTrackHeaders->insertItem(i18n("Never"), HeadersGroup::ShowNever); + m_showTrackHeaders->insertItem(i18n("When needed"), HeadersGroup::ShowWhenNeeded); + m_showTrackHeaders->insertItem(i18n("Always"), HeadersGroup::ShowAlways); + int defaultShowTrackHeaders = m_cfg->readNumEntry("shownotationheader", + HeadersGroup::DefaultShowMode); + if (HeadersGroup::isValidShowMode(defaultShowTrackHeaders)) { + m_showTrackHeaders->setCurrentItem(defaultShowTrackHeaders); + } + QToolTip::add(m_showTrackHeaders, QString(i18n( + "\"Always\" and \"Never\" mean what they usually mean\n" + "\"When needed\" means \"when staves are too many to all fit" + " in the current window\""))); + + layout->addMultiCellWidget(m_showTrackHeaders, row, row, 1, 2); + ++row; + + layout->setRowSpacing(row, 20); + ++row; + + layout->addMultiCellWidget + (new QLabel + (i18n("Show non-notation events as question marks"), frame), + row, row, 0, 1); + m_showUnknowns = new QCheckBox(frame); + bool defaultShowUnknowns = m_cfg->readBoolEntry("showunknowns", false); + m_showUnknowns->setChecked(defaultShowUnknowns); + layout->addWidget(m_showUnknowns, row, 2); + ++row; + + layout->addMultiCellWidget + (new QLabel + (i18n("Show notation-quantized notes in a different color"), frame), + row, row, 0, 1); + m_colourQuantize = new QCheckBox(frame); + bool defaultColourQuantize = m_cfg->readBoolEntry("colourquantize", false); + m_colourQuantize->setChecked(defaultColourQuantize); + layout->addWidget(m_colourQuantize, row, 2); + ++row; + + layout->addMultiCellWidget + (new QLabel + (i18n("Show \"invisible\" events in grey"), frame), + row, row, 0, 1); + m_showInvisibles = new QCheckBox(frame); + bool defaultShowInvisibles = m_cfg->readBoolEntry("showinvisibles", true); + m_showInvisibles->setChecked(defaultShowInvisibles); + layout->addWidget(m_showInvisibles, row, 2); + ++row; + + layout->addMultiCellWidget + (new QLabel + (i18n("Show notes outside suggested playable range in red"), frame), + row, row, 0, 1); + m_showRanges = new QCheckBox(frame); + bool defaultShowRanges = m_cfg->readBoolEntry("showranges", true); + m_showRanges->setChecked(defaultShowRanges); + layout->addWidget(m_showRanges, row, 2); + ++row; + + layout->addMultiCellWidget + (new QLabel + (i18n("Highlight superimposed notes with a halo effect"), frame), + row, row, 0, 1); + m_showCollisions = new QCheckBox(frame); + bool defaultShowCollisions = m_cfg->readBoolEntry("showcollisions", true); + m_showCollisions->setChecked(defaultShowCollisions); + layout->addWidget(m_showCollisions, row, 2); + ++row; + + layout->setRowSpacing(row, 20); + ++row; + + layout->addMultiCellWidget + (new QLabel + (i18n("When recording MIDI, split-and-tie long notes at barlines"), frame), + row, row, 0, 1); + m_splitAndTie = new QCheckBox(frame); + bool defaultSplitAndTie = m_cfg->readBoolEntry("quantizemakeviable", false); + m_splitAndTie->setChecked(defaultSplitAndTie); + layout->addWidget(m_splitAndTie, row, 2); + ++row; + + layout->setRowStretch(row, 10); + + + addTab(frame, i18n("Layout")); + + + + frame = new QFrame(m_tabWidget); + layout = new QGridLayout(frame, 6, 3, 10, 5); + + row = 0; + + layout->setRowSpacing(row, 15); + ++row; + + layout->addMultiCellWidget + (new QLabel(i18n("Default note style for new notes"), frame), + row, row, 0, 1); + + layout->setColStretch(2, 10); + + m_noteStyle = new KComboBox(frame); + m_noteStyle->setEditable(false); + m_untranslatedNoteStyle.clear(); + + QString defaultStyle = + m_cfg->readEntry("style", strtoqstr(NoteStyleFactory::DefaultStyle)); + std::vector<NoteStyleName> styles + (NoteStyleFactory::getAvailableStyleNames()); + + for (std::vector<NoteStyleName>::iterator i = styles.begin(); + i != styles.end(); ++i) { + + QString styleQName(strtoqstr(*i)); + m_untranslatedNoteStyle.append(styleQName); + m_noteStyle->insertItem(i18n(styleQName.utf8())); + if (styleQName == defaultStyle) { + m_noteStyle->setCurrentItem(m_noteStyle->count() - 1); + } + } + + layout->addWidget(m_noteStyle, row, 2); + ++row; + + layout->setRowSpacing(row, 20); + ++row; + + layout->addWidget + (new QLabel(i18n("When inserting notes..."), frame), row, 0); + + int defaultInsertType = m_cfg->readNumEntry("inserttype", 0); + + m_insertType = new KComboBox(frame); + m_insertType->setEditable(false); + m_insertType->insertItem + (i18n("Split notes into ties to make durations match")); + m_insertType->insertItem(i18n("Ignore existing durations")); + m_insertType->setCurrentItem(defaultInsertType); + + layout->addMultiCellWidget(m_insertType, row, row, 1, 2); + ++row; + + bool autoBeam = m_cfg->readBoolEntry("autobeam", true); + + layout->addMultiCellWidget + (new QLabel + (i18n("Auto-beam on insert when appropriate"), frame), + row, row, 0, 1); + m_autoBeam = new QCheckBox(frame); + m_autoBeam->setChecked(autoBeam); + layout->addMultiCellWidget(m_autoBeam, row, row, 2, 2); + + ++row; + + bool collapse = m_cfg->readBoolEntry("collapse", false); + + layout->addMultiCellWidget + (new QLabel + (i18n("Collapse rests after erase"), frame), + row, row, 0, 1); + m_collapseRests = new QCheckBox(frame); + m_collapseRests->setChecked(collapse); + layout->addMultiCellWidget(m_collapseRests, row, row, 2, 2); + ++row; + + layout->setRowSpacing(row, 20); + ++row; + + layout->addWidget + (new QLabel(i18n("Default paste type"), frame), row, 0); + + m_pasteType = new KComboBox(frame); + m_pasteType->setEditable(false); + + unsigned int defaultPasteType = m_cfg->readUnsignedNumEntry + ("pastetype", PasteEventsCommand::Restricted); + + PasteEventsCommand::PasteTypeMap pasteTypes = + PasteEventsCommand::getPasteTypes(); + + for (PasteEventsCommand::PasteTypeMap::iterator i = pasteTypes.begin(); + i != pasteTypes.end(); ++i) { + m_pasteType->insertItem(i->second); + } + + m_pasteType->setCurrentItem(defaultPasteType); + layout->addMultiCellWidget(m_pasteType, row, row, 1, 2); + ++row; + + layout->setRowStretch(row, 10); + + addTab(frame, i18n("Editing")); + + + + frame = new QFrame(m_tabWidget); + layout = new QGridLayout(frame, 4, 2, 10, 5); + + row = 0; + + layout->setRowSpacing(row, 15); + ++row; + + layout->addWidget(new QLabel(i18n("Accidentals in one octave..."), frame), row, 0); + m_accOctavePolicy = new KComboBox(frame); + m_accOctavePolicy->insertItem(i18n("Affect only that octave")); + m_accOctavePolicy->insertItem(i18n("Require cautionaries in other octaves")); + m_accOctavePolicy->insertItem(i18n("Affect all subsequent octaves")); + int accOctaveMode = m_cfg->readNumEntry("accidentaloctavemode", 1); + if (accOctaveMode >= 0 && accOctaveMode < 3) { + m_accOctavePolicy->setCurrentItem(accOctaveMode); + } + layout->addWidget(m_accOctavePolicy, row, 1); + ++row; + + layout->addWidget(new QLabel(i18n("Accidentals in one bar..."), frame), row, 0); + m_accBarPolicy = new KComboBox(frame); + m_accBarPolicy->insertItem(i18n("Affect only that bar")); + m_accBarPolicy->insertItem(i18n("Require cautionary resets in following bar")); + m_accBarPolicy->insertItem(i18n("Require explicit resets in following bar")); + int accBarMode = m_cfg->readNumEntry("accidentalbarmode", 0); + if (accBarMode >= 0 && accBarMode < 3) { + m_accBarPolicy->setCurrentItem(accBarMode); + } + layout->addWidget(m_accBarPolicy, row, 1); + ++row; + + layout->addWidget(new QLabel(i18n("Key signature cancellation style"), frame), row, 0); + m_keySigCancelMode = new KComboBox(frame); + m_keySigCancelMode->insertItem(i18n("Cancel only when entering C major or A minor")); + m_keySigCancelMode->insertItem(i18n("Cancel whenever removing sharps or flats")); + m_keySigCancelMode->insertItem(i18n("Cancel always")); + int cancelMode = m_cfg->readNumEntry("keysigcancelmode", 1); + if (cancelMode >= 0 && cancelMode < 3) { + m_keySigCancelMode->setCurrentItem(cancelMode); + } + layout->addWidget(m_keySigCancelMode, row, 1); + ++row; + + layout->setRowStretch(row, 10); + + addTab(frame, i18n("Accidentals")); + +/* + QString preamble = + (i18n("Rosegarden can apply automatic quantization to recorded " + "or imported MIDI data for notation purposes only. " + "This does not affect playback, and does not affect " + "editing in any of the views except notation.")); + + // force to default of 2 if not used before + int quantizeType = m_cfg->readNumEntry("quantizetype", 2); + m_cfg->writeEntry("quantizetype", quantizeType); + m_cfg->writeEntry("quantizenotationonly", true); + + m_quantizeFrame = new QuantizeParameters + (m_tabWidget, QuantizeParameters::Notation, + false, false, "Notation Options", preamble); + + addTab(m_quantizeFrame, i18n("Quantize")); +*/ + row = 0; + +// QFrame *mainFrame = new QFrame(m_tabWidget); +// QGridLayout *mainLayout = new QGridLayout(mainFrame, 2, 4, 10, 5); + +// QGroupBox *noteFontBox = new QGroupBox(1, Horizontal, i18n("Notation font"), mainFrame); +// QGroupBox *otherFontBox = new QGroupBox(1, Horizontal, i18n("Other fonts"), mainFrame); +// QGroupBox *descriptionBox = new QGroupBox(1, Horizontal, i18n("Description"), mainFrame); + +// mainLayout->addWidget(noteFontBox, 0, 0); +// mainLayout->addWidget(otherFontBox, 1, 0); + +// QFrame *mainFrame = new QFrame(m_tabWidget); + frame = new QFrame(m_tabWidget); + layout = new QGridLayout(frame, 2, 4, 10, 5); + +// frame = new QFrame(noteFontBox); +// layout = new QGridLayout(frame, 5, 2, 10, 5); + + m_viewButton = 0; + + layout->addWidget(new QLabel(i18n("Notation font"), frame), 0, 0); + + m_font = new KComboBox(frame); + +#ifdef HAVE_XFT + m_viewButton = new QPushButton(i18n("View"), frame); + layout->addMultiCellWidget(m_font, row, row, 1, 2); + layout->addWidget(m_viewButton, row, 3); + QObject::connect(m_viewButton, SIGNAL(clicked()), + this, SLOT(slotViewButtonPressed())); +#else + layout->addMultiCellWidget(m_font, row, row, 1, 3); +#endif + m_font->setEditable(false); + QObject::connect(m_font, SIGNAL(activated(int)), + this, SLOT(slotFontComboChanged(int))); + ++row; + + QFrame *subFrame = new QFrame(frame); + QGridLayout *subLayout = new QGridLayout(subFrame, + 4, 2, // nbrow, nbcol + 12, 2); + + QFont font = m_font->font(); + font.setPointSize((font.pointSize() * 9) / 10); + + QLabel *originLabel = new QLabel(i18n("Origin:"), subFrame); + originLabel->setFont(font); + subLayout->addWidget(originLabel, 0, 0); + + QLabel *copyrightLabel = new QLabel(i18n("Copyright:"), subFrame); + copyrightLabel->setFont(font); + subLayout->addWidget(copyrightLabel, 1, 0); + + QLabel *mappedLabel = new QLabel(i18n("Mapped by:"), subFrame); + mappedLabel->setFont(font); + subLayout->addWidget(mappedLabel, 2, 0); + + QLabel *typeLabel = new QLabel(i18n("Type:"), subFrame); + typeLabel->setFont(font); + subLayout->addWidget(typeLabel, 3, 0); + + m_fontOriginLabel = new QLabel(subFrame); + m_fontOriginLabel->setAlignment(Qt::WordBreak); + m_fontOriginLabel->setFont(font); +// m_fontOriginLabel->setFixedWidth(250); + m_fontCopyrightLabel = new QLabel(subFrame); + m_fontCopyrightLabel->setAlignment(Qt::WordBreak); + m_fontCopyrightLabel->setFont(font); +// m_fontCopyrightLabel->setFixedWidth(250); + m_fontMappedByLabel = new QLabel(subFrame); + m_fontMappedByLabel->setFont(font); + m_fontTypeLabel = new QLabel(subFrame); + m_fontTypeLabel->setFont(font); + subLayout->addWidget(m_fontOriginLabel, 0, 1); + subLayout->addWidget(m_fontCopyrightLabel, 1, 1); + subLayout->addWidget(m_fontMappedByLabel, 2, 1); + subLayout->addWidget(m_fontTypeLabel, 3, 1); + + subLayout->setColStretch(1, 10); + + layout->addMultiCellWidget(subFrame, + row, row, + 0, 3); + ++row; + + layout->addMultiCellWidget + (new QLabel(i18n("Font size for single-staff views"), frame), + row, row, 0, 1); + m_singleStaffSize = new KComboBox(frame); + m_singleStaffSize->setEditable(false); + layout->addMultiCellWidget(m_singleStaffSize, row, row, 2, 2); + ++row; + + layout->addMultiCellWidget + (new QLabel(i18n("Font size for multi-staff views"), frame), + row, row, 0, 1); + m_multiStaffSize = new KComboBox(frame); + m_multiStaffSize->setEditable(false); + layout->addMultiCellWidget(m_multiStaffSize, row, row, 2, 2); + ++row; + + layout->addMultiCellWidget + (new QLabel(i18n("Font size for printing (pt)"), frame), + row, row, 0, 1); + m_printingSize = new KComboBox(frame); + m_printingSize->setEditable(false); + layout->addMultiCellWidget(m_printingSize, row, row, 2, 2); + ++row; + + slotPopulateFontCombo(false); + + layout->setRowSpacing(row, 15); + ++row; + + QFont defaultTextFont(NotePixmapFactory::defaultSerifFontFamily), + defaultSansFont(NotePixmapFactory::defaultSansSerifFontFamily), + defaultTimeSigFont(NotePixmapFactory::defaultTimeSigFontFamily); + + layout->addWidget + (new QLabel(i18n("Text font"), frame), row, 0); + m_textFont = new KFontRequester(frame); + QFont textFont = m_cfg->readFontEntry("textfont", &defaultTextFont); + m_textFont->setFont(textFont); + layout->addMultiCellWidget(m_textFont, row, row, 1, 3); + ++row; + + layout->addWidget + (new QLabel(i18n("Sans-serif font"), frame), row, 0); + m_sansFont = new KFontRequester(frame); + QFont sansFont = m_cfg->readFontEntry("sansfont", &defaultSansFont); + m_sansFont->setFont(sansFont); + layout->addMultiCellWidget(m_sansFont, row, row, 1, 3); + ++row; + +/*!!! No -- not much point in having the time sig font here: it's only + * used if the time sig characters are not found in the notation font, + * and our default notation font has all the characters we need + + layout->addWidget + (new QLabel(i18n("Time Signature font"), frame), row, 0); + m_timeSigFont = new KFontRequester(frame); + QFont timeSigFont = m_cfg->readFontEntry("timesigfont", &defaultTimeSigFont); + m_timeSigFont->setFont(timeSigFont); + layout->addMultiCellWidget(m_timeSigFont, row, row, 1, 3); + ++row; +*/ + +// addTab(mainFrame, i18n("Font")); + addTab(frame, i18n("Font")); + + +} + +void +NotationConfigurationPage::slotViewButtonPressed() +{ +#ifdef HAVE_XFT + std::string fontName = qstrtostr(m_untranslatedFont[m_font->currentItem()]); + + try { + NoteFont *noteFont = NoteFontFactory::getFont + (fontName, NoteFontFactory::getDefaultSize(fontName)); + const NoteFontMap &map(noteFont->getNoteFontMap()); + QStringList systemFontNames(map.getSystemFontNames()); + if (systemFontNames.count() == 0) { + m_viewButton->setEnabled(false); // oops + } else { + NoteFontViewer *viewer = + new NoteFontViewer(0, m_untranslatedFont[m_font->currentItem()], + systemFontNames, 24); + (void)viewer->exec(); // no return value + } + } catch (Exception f) { + KMessageBox::error(0, i18n(strtoqstr(f.getMessage()))); + } +#endif +} + +void +NotationConfigurationPage::slotPopulateFontCombo(bool rescan) +{ + QString defaultFont = m_cfg->readEntry + ("notefont", strtoqstr(NoteFontFactory::getDefaultFontName())); + + try { + (void)NoteFontFactory::getFont + (qstrtostr(defaultFont), + NoteFontFactory::getDefaultSize(qstrtostr(defaultFont))); + } catch (Exception e) { + defaultFont = strtoqstr(NoteFontFactory::getDefaultFontName()); + } + + std::set + <std::string> fs(NoteFontFactory::getFontNames(rescan)); + std::vector<std::string> f(fs.begin(), fs.end()); + std::sort(f.begin(), f.end()); + + m_untranslatedFont.clear(); + m_font->clear(); + + for (std::vector<std::string>::iterator i = f.begin(); i != f.end(); ++i) { + QString s(strtoqstr(*i)); + m_untranslatedFont.append(s); + m_font->insertItem(i18n(s.utf8())); + if (s == defaultFont) + m_font->setCurrentItem(m_font->count() - 1); + } + + slotFontComboChanged(m_font->currentItem()); +} + +void +NotationConfigurationPage::slotFontComboChanged(int index) +{ + std::string fontStr = qstrtostr(m_untranslatedFont[index]); + + populateSizeCombo(m_singleStaffSize, fontStr, + m_cfg->readUnsignedNumEntry + ("singlestaffnotesize", + NoteFontFactory::getDefaultSize(fontStr))); + populateSizeCombo(m_multiStaffSize, fontStr, + m_cfg->readUnsignedNumEntry + ("multistaffnotesize", + NoteFontFactory::getDefaultSize(fontStr))); + + int printpt = m_cfg->readUnsignedNumEntry("printingnotesize", 5); + for (int i = 2; i < 16; ++i) { + m_printingSize->insertItem(QString("%1").arg(i)); + if (i == printpt) { + m_printingSize->setCurrentItem(m_printingSize->count() - 1); + } + } + + try { + NoteFont *noteFont = NoteFontFactory::getFont + (fontStr, NoteFontFactory::getDefaultSize(fontStr)); + const NoteFontMap &map(noteFont->getNoteFontMap()); + m_fontOriginLabel->setText(i18n(strtoqstr(map.getOrigin()))); + m_fontCopyrightLabel->setText(i18n(strtoqstr(map.getCopyright()))); + m_fontMappedByLabel->setText(i18n(strtoqstr(map.getMappedBy()))); + if (map.isSmooth()) { + m_fontTypeLabel->setText( + i18n("%1 (smooth)").arg(i18n(strtoqstr(map.getType())))); + } else { + m_fontTypeLabel->setText( + i18n("%1 (jaggy)").arg(i18n(strtoqstr(map.getType())))); + } + if (m_viewButton) { + m_viewButton->setEnabled(map.getSystemFontNames().count() > 0); + } + } catch (Exception f) { + KMessageBox::error(0, i18n(strtoqstr(f.getMessage()))); + } +} + +void +NotationConfigurationPage::populateSizeCombo(QComboBox *combo, + std::string font, + int defaultSize) +{ + std::vector<int> sizes = NoteFontFactory::getScreenSizes(font); + combo->clear(); + + for (std::vector<int>::iterator i = sizes.begin(); i != sizes.end(); ++i) { + combo->insertItem(QString("%1").arg(*i)); + if (*i == defaultSize) + combo->setCurrentItem(combo->count() - 1); + } +} + +void +NotationConfigurationPage::apply() +{ + m_cfg->setGroup(NotationViewConfigGroup); + + m_cfg->writeEntry("notefont", m_untranslatedFont[m_font->currentItem()]); + m_cfg->writeEntry("singlestaffnotesize", + m_singleStaffSize->currentText().toUInt()); + m_cfg->writeEntry("multistaffnotesize", + m_multiStaffSize->currentText().toUInt()); + m_cfg->writeEntry("printingnotesize", + m_printingSize->currentText().toUInt()); + m_cfg->writeEntry("textfont", + m_textFont->font()); + m_cfg->writeEntry("sansfont", + m_sansFont->font()); +/*!!! + m_cfg->writeEntry("timesigfont", + m_timeSigFont->font()); +*/ + std::vector<int> s = NotationHLayout::getAvailableSpacings(); + m_cfg->writeEntry("spacing", s[m_spacing->currentItem()]); + + s = NotationHLayout::getAvailableProportions(); + m_cfg->writeEntry("proportion", s[m_proportion->currentItem()]); + + m_cfg->writeEntry("layoutmode", m_layoutMode->currentItem()); + m_cfg->writeEntry("colourquantize", m_colourQuantize->isChecked()); + m_cfg->writeEntry("showunknowns", m_showUnknowns->isChecked()); + m_cfg->writeEntry("showinvisibles", m_showInvisibles->isChecked()); + m_cfg->writeEntry("showranges", m_showRanges->isChecked()); + m_cfg->writeEntry("showcollisions", m_showCollisions->isChecked()); + m_cfg->writeEntry("shownotationheader", + m_showTrackHeaders->currentItem()); + m_cfg->writeEntry("style", m_untranslatedNoteStyle[m_noteStyle->currentItem()]); + m_cfg->writeEntry("inserttype", m_insertType->currentItem()); + m_cfg->writeEntry("autobeam", m_autoBeam->isChecked()); + m_cfg->writeEntry("collapse", m_collapseRests->isChecked()); + m_cfg->writeEntry("pastetype", m_pasteType->currentItem()); + m_cfg->writeEntry("accidentaloctavemode", m_accOctavePolicy->currentItem()); + m_cfg->writeEntry("accidentalbarmode", m_accBarPolicy->currentItem()); + m_cfg->writeEntry("keysigcancelmode", m_keySigCancelMode->currentItem()); + + m_cfg->writeEntry("quantizemakeviable", m_splitAndTie->isChecked()); + +// (void)m_quantizeFrame->getQuantizer(); // this also writes to the config +} + +} +#include "NotationConfigurationPage.moc" |