    //=============================================================================
    //  MuseScore
    //  Music Composition & Notation
    //
    //  Copyright (C) 2010-2014 Werner Schweer and others
    //
    //  This program is free software; you can redistribute it and/or modify
    //  it under the terms of the GNU General Public License version 2
    //  as published by the Free Software Foundation and appearing in
    //  the file LICENCE.GPL
    //=============================================================================

    #include "editstafftype.h"
    #include "libmscore/part.h"
    #include "libmscore/mscore.h"
    #include "libmscore/score.h"
    #include "libmscore/staff.h"
    #include "libmscore/stringdata.h"
    #include "musescore.h"
    #include "navigator.h"
    #include "scoreview.h"

    namespace Ms {

    extern Score::FileError readScore(MasterScore* score, QString name, bool ignoreVersionError);

    const char* g_groupNames[STAFF_GROUP_MAX] = {
          QT_TRANSLATE_NOOP("staff group header name", "STANDARD STAFF"),
          QT_TRANSLATE_NOOP("staff group header name", "PERCUSSION STAFF"),
          QT_TRANSLATE_NOOP("staff group header name", "TABLATURE STAFF")
          };

    //---------------------------------------------------------
    //   noteHeadSchemes
    //---------------------------------------------------------

    NoteHeadScheme noteHeadSchemes[] = {
          NoteHeadScheme::HEAD_NORMAL,
          NoteHeadScheme::HEAD_PITCHNAME,
          NoteHeadScheme::HEAD_PITCHNAME_GERMAN,
          NoteHeadScheme::HEAD_SOLFEGE,
          NoteHeadScheme::HEAD_SOLFEGE_FIXED,
          NoteHeadScheme::HEAD_SHAPE_NOTE_4,
          NoteHeadScheme::HEAD_SHAPE_NOTE_7_AIKIN,
          NoteHeadScheme::HEAD_SHAPE_NOTE_7_FUNK,
          NoteHeadScheme::HEAD_SHAPE_NOTE_7_WALKER
          };

    //---------------------------------------------------------
    //   EditStaffType
    //---------------------------------------------------------

    EditStaffType::EditStaffType(QWidget* parent, Staff* st)
       : QDialog(parent)
          {
          setObjectName("EditStaffType");
          setWindowFlags(this->windowFlags() & ~Qt::WindowContextHelpButtonHint);
          setupUi(this);

          staff     = st;
          staffType = *staff->staffType(0);
          Instrument* instr = staff->part()->instrument();

          // template combo

          templateCombo->clear();
          // statdard group also as fall-back (but excluded by percussion)
          bool bStandard    = !(instr != nullptr && instr->drumset() != nullptr);
          bool bPerc        = (instr != nullptr && instr->drumset() != nullptr);
          bool bTab         = (instr != nullptr && instr->stringData() != nullptr && instr->stringData()->strings() > 0);
          int idx           = 0;
          for (const StaffType& t : StaffType::presets()) {
                if ( (t.group() == StaffGroup::STANDARD && bStandard)
                            || (t.group() == StaffGroup::PERCUSSION && bPerc)
                            || (t.group() == StaffGroup::TAB && bTab))
                      templateCombo->addItem(t.name(), idx);
                idx++;
                }
          templateCombo->setCurrentIndex(-1);

          // tab page configuration
          QList<QString> fontNames = StaffType::fontNames(false);
          foreach (const QString& name, fontNames)   // fill fret font name combo
                fretFontName->addItem(name);
          fretFontName->setCurrentIndex(0);
          fontNames = StaffType::fontNames(true);
          foreach(const QString& name, fontNames)   // fill duration font name combo
                durFontName->addItem(name);
          durFontName->setCurrentIndex(0);

          for (auto i : noteHeadSchemes)
                noteHeadScheme->addItem(StaffType::scheme2userName(i), StaffType::scheme2name(i));

          // load a sample standard score in preview
          MasterScore* sc = new MasterScore(MScore::defaultStyle());
          if (readScore(sc, QString(":/data/std_sample.mscx"), false) == Score::FileError::FILE_NO_ERROR)
                standardPreview->setScore(sc);
          else {
                Q_ASSERT_X(false, "EditStaffType::EditStaffType", "Error in opening sample standard file for preview");
                }

          // load a sample tabulature score in preview
          sc = new MasterScore(MScore::defaultStyle());
          if (readScore(sc, QString(":/data/tab_sample.mscx"), false) == Score::FileError::FILE_NO_ERROR)
                tabPreview->setScore(sc);
          else {
                Q_ASSERT_X(false, "EditStaffType::EditStaffType", "Error in opening sample tab file for preview");
                }

          setValues();

          connect(name,           SIGNAL(textEdited(const QString&)), SLOT(nameEdited(const QString&)));
          connect(lines,          SIGNAL(valueChanged(int)),          SLOT(updatePreview()));
          connect(lineDistance,   SIGNAL(valueChanged(double)),       SLOT(updatePreview()));
          connect(showBarlines,   SIGNAL(toggled(bool)),              SLOT(updatePreview()));
          connect(genClef,        SIGNAL(toggled(bool)),              SLOT(updatePreview()));
          connect(genTimesig,     SIGNAL(toggled(bool)),              SLOT(updatePreview()));
          connect(noteHeadScheme, SIGNAL(currentIndexChanged(int)),   SLOT(updatePreview()));

          connect(genKeysigPitched,           SIGNAL(toggled(bool)),  SLOT(updatePreview()));
          connect(showLedgerLinesPitched,     SIGNAL(toggled(bool)),  SLOT(updatePreview()));
          connect(stemlessPitched,            SIGNAL(toggled(bool)),  SLOT(updatePreview()));
          connect(genKeysigPercussion,        SIGNAL(toggled(bool)),  SLOT(updatePreview()));
          connect(showLedgerLinesPercussion,  SIGNAL(toggled(bool)),  SLOT(updatePreview()));
          connect(stemlessPercussion,         SIGNAL(toggled(bool)),  SLOT(updatePreview()));

          connect(noteValuesSymb,       SIGNAL(toggled(bool)),              SLOT(tabStemsToggled(bool)));
          connect(noteValuesStems,      SIGNAL(toggled(bool)),              SLOT(tabStemsToggled(bool)));
          connect(valuesRepeatNever,    SIGNAL(toggled(bool)),              SLOT(updatePreview()));
          connect(valuesRepeatSystem,   SIGNAL(toggled(bool)),              SLOT(updatePreview()));
          connect(valuesRepeatMeasure,  SIGNAL(toggled(bool)),              SLOT(updatePreview()));
          connect(valuesRepeatAlways,   SIGNAL(toggled(bool)),              SLOT(updatePreview()));
          connect(stemBesideRadio,      SIGNAL(toggled(bool)),              SLOT(updatePreview()));
          connect(stemThroughRadio,     SIGNAL(toggled(bool)),              SLOT(tabStemThroughToggled(bool)));
          connect(stemAboveRadio,       SIGNAL(toggled(bool)),              SLOT(updatePreview()));
          connect(stemBelowRadio,       SIGNAL(toggled(bool)),              SLOT(updatePreview()));
          connect(minimShortRadio,      SIGNAL(toggled(bool)),              SLOT(tabMinimShortToggled(bool)));
          connect(minimSlashedRadio,    SIGNAL(toggled(bool)),              SLOT(updatePreview()));
          connect(showRests,            SIGNAL(toggled(bool)),              SLOT(updatePreview()));
          connect(durFontName,          SIGNAL(currentIndexChanged(int)),   SLOT(durFontNameChanged(int)));
          connect(durFontSize,          SIGNAL(valueChanged(double)),       SLOT(updatePreview()));
          connect(durY,                 SIGNAL(valueChanged(double)),       SLOT(updatePreview()));
          connect(fretFontName,         SIGNAL(currentIndexChanged(int)),   SLOT(fretFontNameChanged(int)));
          connect(fretFontSize,         SIGNAL(valueChanged(double)),       SLOT(updatePreview()));
          connect(fretY,                SIGNAL(valueChanged(double)),       SLOT(updatePreview()));

          connect(linesThroughRadio,    SIGNAL(toggled(bool)),              SLOT(updatePreview()));
          connect(onLinesRadio,         SIGNAL(toggled(bool)),              SLOT(updatePreview()));
          connect(showTabFingering,     SIGNAL(toggled(bool)),              SLOT(updatePreview()));
          connect(upsideDown,           SIGNAL(toggled(bool)),              SLOT(updatePreview()));
          connect(numbersRadio,         SIGNAL(toggled(bool)),              SLOT(updatePreview()));
          connect(showBackTied,         SIGNAL(toggled(bool)),              SLOT(updatePreview()));

          connect(templateReset,        SIGNAL(clicked()),                  SLOT(resetToTemplateClicked()));
          connect(addToTemplates,       SIGNAL(clicked()),                  SLOT(addToTemplatesClicked()));
    //      connect(groupCombo,           SIGNAL(currentIndexChanged(int)),   SLOT(staffGroupChanged(int)));
          addToTemplates->setVisible(false);

          MuseScore::restoreGeometry(this);
          }

    //---------------------------------------------------------
    //   hideEvent
    //---------------------------------------------------------

    void EditStaffType::hideEvent(QHideEvent* ev)
          {
          MuseScore::saveGeometry(this);
          QWidget::hideEvent(ev);
          }

    //---------------------------------------------------------
    //   staffGroupChanged
    //---------------------------------------------------------
    /*
    void EditStaffType::staffGroupChanged(int n)
          {
          int groupIdx = groupCombo->itemData(groupCombo->currentIndex()).toInt();
          StaffGroup group = StaffGroup(groupIdx);
          staffType = *StaffType::getDefaultPreset(group); // overwrite with default
          setValues();
          }
    */
    //---------------------------------------------------------
    //   setValues
    //---------------------------------------------------------

    void EditStaffType::setValues()
          {
          blockSignals(true);

          StaffGroup group = staffType.group();
          int idx = int(group);
          stack->setCurrentIndex(idx);
          groupName->setText(qApp->translate("staff group header name", g_groupNames[idx]));
    //      groupCombo->setCurrentIndex(idx);

          name->setText(staffType.name());
          lines->setValue(staffType.lines());
          lineDistance->setValue(staffType.lineDistance().val());
          genClef->setChecked(staffType.genClef());
          showBarlines->setChecked(staffType.showBarlines());
          genTimesig->setChecked(staffType.genTimesig());

          switch (group) {
                case StaffGroup::STANDARD:
                      genKeysigPitched->setChecked(staffType.genKeysig());
                      showLedgerLinesPitched->setChecked(staffType.showLedgerLines());
                      stemlessPitched->setChecked(staffType.slashStyle());
                      noteHeadScheme->setCurrentIndex(int(staffType.noteHeadScheme()));
                      break;

                case StaffGroup::TAB:
                      {
                      upsideDown->setChecked(staffType.upsideDown());
                      showTabFingering->setChecked(staffType.showTabFingering());
                      int idx = fretFontName->findText(staffType.fretFontName(), Qt::MatchFixedString);
                      if (idx == -1)
                            idx = 0;          // if name not found, use first name
                      fretFontName->setCurrentIndex(idx);
                      fretFontSize->setValue(staffType.fretFontSize());
                      fretY->setValue(staffType.fretFontUserY());

                      numbersRadio->setChecked(staffType.useNumbers());
                      lettersRadio->setChecked(!staffType.useNumbers());
                      onLinesRadio->setChecked(staffType.onLines());
                      aboveLinesRadio->setChecked(!staffType.onLines());
                      linesThroughRadio->setChecked(staffType.linesThrough());
                      linesBrokenRadio->setChecked(!staffType.linesThrough());
                      showBackTied->setChecked(staffType.showBackTied());

                      idx = durFontName->findText(staffType.durationFontName(), Qt::MatchFixedString);
                      if (idx == -1)
                            idx = 0;          // if name not found, use first name
                      durFontName->setCurrentIndex(idx);
                      durFontSize->setValue(staffType.durationFontSize());
                      durY->setValue(staffType.durationFontUserY());
                      // convert combined values of genDurations and slashStyle into noteValuesx radio buttons
                      // Sbove/Below, Beside/Through and minim are only used if stems-and-beams
                      // but set them from stt values anyway, to ensure preset matching
                      stemAboveRadio->setChecked(!staffType.stemsDown());
                      stemBelowRadio->setChecked(staffType.stemsDown());
                      stemBesideRadio->setChecked(!staffType.stemThrough());
                      stemThroughRadio->setChecked(staffType.stemThrough());
                      TablatureMinimStyle minimStyle = staffType.minimStyle();
                      minimNoneRadio->setChecked(minimStyle == TablatureMinimStyle::NONE);
                      minimShortRadio->setChecked(minimStyle == TablatureMinimStyle::SHORTER);
                      minimSlashedRadio->setChecked(minimStyle == TablatureMinimStyle::SLASHED);
                      TablatureSymbolRepeat symRepeat = staffType.symRepeat();
                      valuesRepeatNever->setChecked(symRepeat == TablatureSymbolRepeat::NEVER);
                      valuesRepeatSystem->setChecked(symRepeat == TablatureSymbolRepeat::SYSTEM);
                      valuesRepeatMeasure->setChecked(symRepeat == TablatureSymbolRepeat::MEASURE);
                      valuesRepeatAlways->setChecked(symRepeat == TablatureSymbolRepeat::ALWAYS);
                      if (staffType.genDurations()) {
                            noteValuesNone->setChecked(false);
                            noteValuesSymb->setChecked(true);
                            noteValuesStems->setChecked(false);
                            }
                      else {
                            if (staffType.slashStyle()) {
                                  noteValuesNone->setChecked(true);
                                  noteValuesSymb->setChecked(false);
                                  noteValuesStems->setChecked(false);
                                  }
                            else {
                                  noteValuesNone->setChecked(false);
                                  noteValuesSymb->setChecked(false);
                                  noteValuesStems->setChecked(true);
                                  }
                            }
                      showRests->setChecked(staffType.showRests());
                      // adjust compatibility across different settings
                      tabStemThroughCompatibility(stemThroughRadio->isChecked());
                      tabMinimShortCompatibility(minimShortRadio->isChecked());
                      tabStemsCompatibility(noteValuesStems->isChecked());
                      }
                      break;

                case StaffGroup::PERCUSSION:
                      genKeysigPercussion->setChecked(staffType.genKeysig());
                      showLedgerLinesPercussion->setChecked(staffType.showLedgerLines());
                      stemlessPercussion->setChecked(staffType.slashStyle());
                      break;
                }
          updatePreview();
          blockSignals(false);
          }

    //---------------------------------------------------------
    //   nameEdited
    //---------------------------------------------------------

    void EditStaffType::nameEdited(const QString& /*s*/)
          {
    //      staffTypeList->currentItem()->setText(s);
          }

    //=========================================================
    //   PERCUSSION PAGE METHODS
    //=========================================================

    //=========================================================
    //   TABULATURE PAGE METHODS
    //=========================================================

    //---------------------------------------------------------
    //   Tabulature duration / fret font name changed
    //
    //    set depending parameters
    //---------------------------------------------------------

    void EditStaffType::durFontNameChanged(int idx)
          {
          qreal size, yOff;
          if (StaffType::fontData(true, idx, 0, 0, &size, &yOff)) {
                durFontSize->setValue(size);
                durY->setValue(yOff);
                }
          updatePreview();
          }

    void EditStaffType::fretFontNameChanged(int idx)
          {
          qreal size, yOff;
          if (StaffType::fontData(false, idx, 0, 0, &size, &yOff)) {
                fretFontSize->setValue(size);
                fretY->setValue(yOff);
                }
          updatePreview();
          }

    //---------------------------------------------------------
    //   Tabulature note stems toggled
    //
    //    enable / disable all controls related to stems
    //---------------------------------------------------------

    void EditStaffType::tabStemsToggled(bool checked)
          {
          tabStemsCompatibility(checked);
          updatePreview();
          }

    //---------------------------------------------------------
    //   Tabulature "minim short" toggled
    //
    //    contra-toggle "stems through"
    //---------------------------------------------------------

    void EditStaffType::tabMinimShortToggled(bool checked)
          {
          tabMinimShortCompatibility(checked);
          updatePreview();
          }

    //---------------------------------------------------------
    //   Tabulature "stems through" toggled
    //---------------------------------------------------------

    void EditStaffType::tabStemThroughToggled(bool checked)
          {
          tabStemThroughCompatibility(checked);
          updatePreview();
          }

    //---------------------------------------------------------
    //   setFromDlg
    //
    //    initializes a StaffType from dlg controls
    //---------------------------------------------------------

    void EditStaffType::setFromDlg()
          {
          staffType.setName(name->text());
          staffType.setLines(lines->value());
          staffType.setLineDistance(Spatium(lineDistance->value()));
          staffType.setGenClef(genClef->isChecked());
          staffType.setShowBarlines(showBarlines->isChecked());
          staffType.setGenTimesig(genTimesig->isChecked());
          if (staffType.group() == StaffGroup::STANDARD) {
                staffType.setGenKeysig(genKeysigPitched->isChecked());
                staffType.setShowLedgerLines(showLedgerLinesPitched->isChecked());
                staffType.setSlashStyle(stemlessPitched->isChecked());
                staffType.setNoteHeadScheme(StaffType::name2scheme(noteHeadScheme->currentData().toString()));
                }
          if (staffType.group() == StaffGroup::PERCUSSION) {
                staffType.setGenKeysig(genKeysigPercussion->isChecked());
                staffType.setShowLedgerLines(showLedgerLinesPercussion->isChecked());
                staffType.setSlashStyle(stemlessPercussion->isChecked());
                }
          staffType.setDurationFontName(durFontName->currentText());
          staffType.setDurationFontSize(durFontSize->value());
          staffType.setDurationFontUserY(durY->value());
          staffType.setFretFontName(fretFontName->currentText());
          staffType.setFretFontSize(fretFontSize->value());
          staffType.setFretFontUserY(fretY->value());
          staffType.setLinesThrough(linesThroughRadio->isChecked());
          staffType.setShowBackTied(showBackTied->isChecked());
          staffType.setMinimStyle(minimNoneRadio->isChecked() ? TablatureMinimStyle::NONE :
                (minimShortRadio->isChecked() ? TablatureMinimStyle::SHORTER : TablatureMinimStyle::SLASHED));
          staffType.setSymbolRepeat(valuesRepeatNever->isChecked() ? TablatureSymbolRepeat::NEVER :
                (valuesRepeatSystem->isChecked() ? TablatureSymbolRepeat::SYSTEM :
                      valuesRepeatMeasure->isChecked() ? TablatureSymbolRepeat::MEASURE : TablatureSymbolRepeat::ALWAYS));
          staffType.setOnLines(onLinesRadio->isChecked());
          staffType.setShowRests(showRests->isChecked());
          staffType.setUpsideDown(upsideDown->isChecked());
          staffType.setShowTabFingering(showTabFingering->isChecked());
          staffType.setUseNumbers(numbersRadio->isChecked());
          //note values
          staffType.setStemsDown(stemBelowRadio->isChecked());
          staffType.setStemsThrough(stemThroughRadio->isChecked());
          if (staffType.group() == StaffGroup::TAB) {
                staffType.setSlashStyle(true);                 // assume no note values
                staffType.setGenDurations(false);              //    "     "
                if (noteValuesSymb->isChecked())
                      staffType.setGenDurations(true);
                if (noteValuesStems->isChecked())
                      staffType.setSlashStyle(false);
                }
          }

    //---------------------------------------------------------
    //   Block preview signals
    //---------------------------------------------------------

    void EditStaffType::blockSignals(bool block)
          {
          stack->blockSignals(block);
    //      groupCombo->blockSignals(block);
          lines->blockSignals(block);
          lineDistance->blockSignals(block);
          showBarlines->blockSignals(block);
          genClef->blockSignals(block);
          genTimesig->blockSignals(block);
          noteValuesSymb->blockSignals(block);
          noteValuesStems->blockSignals(block);
          durFontName->blockSignals(block);
          durFontSize->blockSignals(block);
          durY->blockSignals(block);
          fretFontName->blockSignals(block);
          fretFontSize->blockSignals(block);
          fretY->blockSignals(block);

          numbersRadio->blockSignals(block);
          linesThroughRadio->blockSignals(block);
          onLinesRadio->blockSignals(block);
          showBackTied->blockSignals(block);

          upsideDown->blockSignals(block);
          showTabFingering->blockSignals(block);
          valuesRepeatNever->blockSignals(block);
          valuesRepeatSystem->blockSignals(block);
          valuesRepeatMeasure->blockSignals(block);
          valuesRepeatAlways->blockSignals(block);
          stemAboveRadio->blockSignals(block);
          stemBelowRadio->blockSignals(block);
          stemBesideRadio->blockSignals(block);
          stemThroughRadio->blockSignals(block);
          minimShortRadio->blockSignals(block);
          minimSlashedRadio->blockSignals(block);
          showRests->blockSignals(block);

          showLedgerLinesPercussion->blockSignals(block);
          genKeysigPercussion->blockSignals(block);
          stemlessPercussion->blockSignals(block);
          }

    //---------------------------------------------------------
    //   Tabulature note stems compatibility
    //
    //    Enable / disable all stem-related controls according to "Stems and beams" is checked/unchecked
    //---------------------------------------------------------

    void EditStaffType::tabStemsCompatibility(bool checked)
          {
          valuesRepeatNever->setEnabled(noteValuesSymb->isChecked());
          valuesRepeatSystem->setEnabled(noteValuesSymb->isChecked());
          valuesRepeatMeasure->setEnabled(noteValuesSymb->isChecked());
          valuesRepeatAlways->setEnabled(noteValuesSymb->isChecked());
          stemAboveRadio->setEnabled(checked && !stemThroughRadio->isChecked());
          stemBelowRadio->setEnabled(checked && !stemThroughRadio->isChecked());
          stemBesideRadio->setEnabled(checked);
          stemThroughRadio->setEnabled(checked && !minimShortRadio->isChecked());
          minimNoneRadio->setEnabled(checked);
          minimShortRadio->setEnabled(checked && !stemThroughRadio->isChecked());
          minimSlashedRadio->setEnabled(checked);
          }

    //---------------------------------------------------------
    //   Tabulature "minim short" compatibility
    //
    //    Setting "short minim" stems is incompatible with "stems through":
    //    if checked and "stems through" is checked, move check to "stems beside"
    //---------------------------------------------------------

    void EditStaffType::tabMinimShortCompatibility(bool checked)
          {
          if (checked) {
                if(stemThroughRadio->isChecked()) {
                      stemThroughRadio->setChecked(false);
                      stemBesideRadio->setChecked(true);
                      }
                }
          // disable / enable "stems through" according "minim short" is checked / unchecked
          stemThroughRadio->setEnabled(!checked && noteValuesStems->isChecked());
          }

    //---------------------------------------------------------
    //   Tabulature "stems through" compatibility
    //
    //    Setting "stems through" is incompatible with "minim short":
    //    if checking and "minim short" is checked, move check to "minim slashed"
    //    It also make "Stems above" and "Stems below" meaningless: disable them
    //---------------------------------------------------------

    void EditStaffType::tabStemThroughCompatibility(bool checked)
          {
          if (checked) {
                if(minimShortRadio->isChecked()) {
                      minimShortRadio->setChecked(false);
                      minimSlashedRadio->setChecked(true);
                      }
                }
          // disable / enable "minim short" and "stems above/below" according "stems through" is checked / unchecked
          bool enab = !checked && noteValuesStems->isChecked();
          minimShortRadio->setEnabled(enab);
          stemAboveRadio->setEnabled(enab);
          stemBelowRadio->setEnabled(enab);
          }

    //---------------------------------------------------------
    //    updatePreview
    ///   update staff type in preview score
    //---------------------------------------------------------

    void EditStaffType::updatePreview()
          {
          setFromDlg();
          ExampleView* preview = nullptr;
          if (staffType.group() == StaffGroup::TAB)
                 preview = tabPreview;
          else if (staffType.group() == StaffGroup::STANDARD)
                 preview = standardPreview;
          if (preview) {
                preview->score()->staff(0)->setStaffType(0, &staffType);
                preview->score()->doLayout();
                preview->updateAll();
                preview->update();
                }
          }

    //---------------------------------------------------------
    //   createUniqueStaffTypeName
    ///  create unique new name for StaffType
    //---------------------------------------------------------

    QString EditStaffType::createUniqueStaffTypeName(StaffGroup group)
          {
          QString name;
          for (int idx = 1; ; ++idx) {
                switch (group) {
                      case StaffGroup::STANDARD:
                            name = QString("Standard-%1 [*]").arg(idx);
                            break;
                      case StaffGroup::PERCUSSION:
                            name = QString("Perc-%1 [*]").arg(idx);
                            break;
                      case StaffGroup::TAB:
                            name = QString("Tab-%1 [*]").arg(idx);
                            break;
                      }
                bool found = false;
                for (const StaffType& st : StaffType::presets()) {
                      if (st.name() == name) {
                            found = true;
                            break;
                            }
                      }
                if (!found)
                      break;
                }
          return name;
          }

    //---------------------------------------------------------
    //   savePresets
    //---------------------------------------------------------

    void EditStaffType::savePresets()
          {
          qDebug("savePresets");
          }

    //---------------------------------------------------------
    //   loadPresets
    //---------------------------------------------------------

    void EditStaffType::loadPresets()
          {
          qDebug("loadPresets");
          }

    //---------------------------------------------------------
    //   loadFromTemplate
    //---------------------------------------------------------
    /*
    void EditStaffType::loadFromTemplateClicked()
          {
          StaffTypeTemplates stt(staffType);
          if (stt.exec()) {
                StaffType* st = stt.staffType();
                staffType = *st;
                setValues();
                updatePreview();
                }
          }
    */
    void EditStaffType::resetToTemplateClicked()
          {
          int idx = templateCombo->itemData(templateCombo->currentIndex()).toInt();
          if (idx >= 0) {
                staffType = *(StaffType::preset(StaffTypes(idx)));
                setValues();
                }
          }

    //---------------------------------------------------------
    //   addToTemplates
    //---------------------------------------------------------

    void EditStaffType::addToTemplatesClicked()
          {
          qDebug("not implemented: add to templates");
          }

    //---------------------------------------------------------
    //   StaffTypeTemplates
    //---------------------------------------------------------
    /*
    StaffTypeTemplates::StaffTypeTemplates(const StaffType& st, QWidget* parent)
       : QDialog(parent)
          {
          setupUi(this);

          QList<const StaffType*> stl;
          for (const StaffType& t : StaffType::presets()) {
                if (t.group() == st.group())
                      stl.append(&t);
                }
          for (const StaffType* t : stl) {
                QListWidgetItem* item = new QListWidgetItem(t->name());
                item->setData(Qt::UserRole,
                   QVariant::fromValue<void*>((void*)t)
                   );
                staffTypeList->addItem(item);
                }
          staffTypeList->setCurrentRow(0);
          }
    */
    //---------------------------------------------------------
    //   staffType
    //---------------------------------------------------------
    /*
    StaffType* StaffTypeTemplates::staffType() const
          {
          return (StaffType*)staffTypeList->currentItem()->data(Qt::UserRole).value<void*>();
          }
    */
    }

↑ V688 The 'name' local variable possesses the same name as one of the class members, which can result in a confusion.

↑ V688 The 'name' local variable possesses the same name as one of the class members, which can result in a confusion.