//=============================================================================
//  MuseScore
//  Linux Music Score Editor
//
//  Copyright (C) 2002-2016 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.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//=============================================================================

// For menus in the menu bar, like File, Edit, and View, see mscore/musescore.cpp

#include "menus.h"
#include <tuple>
#include "libmscore/score.h"
#include "palette.h"
#include "libmscore/note.h"
#include "libmscore/chordrest.h"
#include "libmscore/dynamic.h"
#include "libmscore/slur.h"
#include "libmscore/sym.h"
#include "libmscore/hairpin.h"
#include "scoreview.h"
#include "musescore.h"
#include "libmscore/select.h"
#include "libmscore/tempo.h"
#include "libmscore/segment.h"
#include "libmscore/undo.h"
#include "icons.h"
#include "libmscore/bracket.h"
#include "libmscore/ottava.h"
#include "libmscore/textline.h"
#include "libmscore/trill.h"
#include "libmscore/pedal.h"
#include "libmscore/clef.h"
#include "libmscore/timesig.h"
#include "libmscore/barline.h"
#include "libmscore/layoutbreak.h"
#include "symboldialog.h"
#include "libmscore/volta.h"
#include "libmscore/keysig.h"
#include "libmscore/breath.h"
#include "libmscore/arpeggio.h"
#include "libmscore/tremolo.h"
#include "libmscore/repeat.h"
#include "libmscore/tempotext.h"
#include "libmscore/glissando.h"
#include "libmscore/articulation.h"
#include "libmscore/chord.h"
#include "libmscore/drumset.h"
#include "libmscore/spacer.h"
#include "libmscore/measure.h"
#include "libmscore/fret.h"
#include "libmscore/staffstate.h"
#include "libmscore/fingering.h"
#include "libmscore/bend.h"
#include "libmscore/tremolobar.h"
#include "libmscore/chordline.h"
#include "libmscore/stafftext.h"
#include "libmscore/systemtext.h"
#include "libmscore/instrchange.h"
#include "workspace.h"
#include "libmscore/icon.h"
#include "libmscore/accidental.h"
#include "libmscore/harmony.h"
#include "libmscore/rehearsalmark.h"
#include "shortcut.h"
#include "libmscore/marker.h"
#include "libmscore/jump.h"
#include "libmscore/bagpembell.h"
#include "libmscore/ambitus.h"
#include "libmscore/stafftypechange.h"
#include "libmscore/letring.h"
#include "libmscore/vibrato.h"
#include "libmscore/palmmute.h"
#include "libmscore/fermata.h"

#include "palette/palettetree.h"
#include "palette/palettewidget.h"
#include "palette/paletteworkspace.h"
#include "qml/msqmlengine.h"

namespace Ms {

extern bool useFactorySettings;

static Palette* toPalette(PalettePanel* pp)
      {
      return new Palette(std::unique_ptr<PalettePanel>(pp));
      }

//---------------------------------------------------------
//   populateIconPalette
//---------------------------------------------------------

void populateIconPalette(Palette* p, const IconAction* a)
      {
      while (a->subtype != IconType::NONE) {
            Icon* ik = new Icon(gscore);
            ik->setIconType(a->subtype);
            const Shortcut* s = Shortcut::getShortcut(a->action);
            QAction* action = s->action();
            QIcon icon(action->icon());
            ik->setAction(a->action, icon);
            p->append(ik, s->help());
            ++a;
            }
      }

//---------------------------------------------------------
//   newBeamPalette
//---------------------------------------------------------

Palette* MuseScore::newBeamPalette()
      {
      return toPalette(newBeamPalettePanel());
      }

//---------------------------------------------------------
//   newFramePalette
//---------------------------------------------------------

Palette* MuseScore::newFramePalette()
      {
      return toPalette(newFramePalettePanel());
      }

//---------------------------------------------------------
//   newDynamicsPalette
//---------------------------------------------------------

Palette* MuseScore::newDynamicsPalette(bool defaultPalette)
      {
      return toPalette(newDynamicsPalettePanel(defaultPalette));
      }

//---------------------------------------------------------
//   newKeySigPalette
//---------------------------------------------------------

Palette* MuseScore::newKeySigPalette()
      {
      return toPalette(newKeySigPalettePanel());
      }

//---------------------------------------------------------
//   newAccidentalsPalette
//---------------------------------------------------------

Palette* MuseScore::newAccidentalsPalette(bool defaultPalette)
      {
      return toPalette(newAccidentalsPalettePanel(defaultPalette));
      }

//---------------------------------------------------------
//   newBarLinePalette
//---------------------------------------------------------

Palette* MuseScore::newBarLinePalette()
      {
      return toPalette(newBarLinePalettePanel());
      }

//---------------------------------------------------------
//   newRepeatsPalette
//---------------------------------------------------------

Palette* MuseScore::newRepeatsPalette()
      {
      return toPalette(newRepeatsPalettePanel());
      }

//---------------------------------------------------------
//   newBreaksPalette
//---------------------------------------------------------

Palette* MuseScore::newBreaksPalette()
      {
      return toPalette(newBreaksPalettePanel());
      }

//---------------------------------------------------------
//   newFingeringPalette
//---------------------------------------------------------

Palette* MuseScore::newFingeringPalette()
      {
      return toPalette(newFingeringPalettePanel());
      }

//---------------------------------------------------------
//   newTremoloPalette
//---------------------------------------------------------

Palette* MuseScore::newTremoloPalette()
      {
      return toPalette(newTremoloPalettePanel());
      }

//---------------------------------------------------------
//   newNoteHeadsPalette
//---------------------------------------------------------

Palette* MuseScore::newNoteHeadsPalette()
      {
      return toPalette(newNoteHeadsPalettePanel());
      }

//---------------------------------------------------------
//   newArticulationsPalette
//---------------------------------------------------------

Palette* MuseScore::newArticulationsPalette()
      {
      return toPalette(newArticulationsPalettePanel());
      }

//---------------------------------------------------------
//   newOrnamentsPalette
//---------------------------------------------------------

Palette* MuseScore::newOrnamentsPalette()
      {
      return toPalette(newOrnamentsPalettePanel());
      }

//---------------------------------------------------------
//   newAccordionPalette
//---------------------------------------------------------

Palette* MuseScore::newAccordionPalette()
      {
      return toPalette(newAccordionPalettePanel());
      }

//---------------------------------------------------------
//   newBracketsPalette
//---------------------------------------------------------

Palette* MuseScore::newBracketsPalette()
      {
      return toPalette(newBracketsPalettePanel());
      }

//---------------------------------------------------------
//   newBreathPalette
//---------------------------------------------------------

Palette* MuseScore::newBreathPalette()
      {
      return toPalette(newBreathPalettePanel());
      }

//---------------------------------------------------------
//   newArpeggioPalette
//---------------------------------------------------------

Palette* MuseScore::newArpeggioPalette()
      {
      return toPalette(newArpeggioPalettePanel());
      }

//---------------------------------------------------------
//   newClefsPalette
//---------------------------------------------------------

Palette* MuseScore::newClefsPalette(bool defaultPalette)
      {
      return toPalette(newClefsPalettePanel(defaultPalette));
      }

//---------------------------------------------------------
//   newGraceNotePalette
//---------------------------------------------------------

Palette* MuseScore::newGraceNotePalette()
      {
      return toPalette(newGraceNotePalettePanel());
      }

//---------------------------------------------------------
//   newBagpipeEmbellishmentPalette
//---------------------------------------------------------

Palette* MuseScore::newBagpipeEmbellishmentPalette()
      {
      return toPalette(newBagpipeEmbellishmentPalettePanel());
      }

//---------------------------------------------------------
//   newLinesPalette
//---------------------------------------------------------

Palette* MuseScore::newLinesPalette()
      {
      return toPalette(newLinesPalettePanel());
      }

//---------------------------------------------------------
//   showPalette
//---------------------------------------------------------

void MuseScore::showPalette(bool visible)
      {
      QAction* a = getAction("toggle-palette");
      if (!paletteWidget) {
            Workspace::currentWorkspace->read();
            preferencesChanged();
            updateIcons();

            paletteWidget = new PaletteWidget(getPaletteWorkspace(), getQmlUiEngine(), this);
            a = getAction("toggle-palette");
            connect(paletteWidget, &PaletteWidget::visibilityChanged, a, &QAction::setChecked);
            addDockWidget(Qt::LeftDockWidgetArea, paletteWidget);
            }
      reDisplayDockWidget(paletteWidget, visible);
      a->setChecked(visible);
      }

//---------------------------------------------------------
//   TempoPattern
//---------------------------------------------------------

struct TempoPattern {
      QString pattern;
      double f;
      bool relative;
      bool italian;
      bool followText;
      bool basic;
      bool masterOnly;

      TempoPattern(const QString& s, double v, bool r, bool i, bool f, bool b, bool m) : pattern(s), f(v), relative(r), italian(i), followText(f), basic(b), masterOnly(m) {}
      };

//---------------------------------------------------------
//   newTempoPalette
//---------------------------------------------------------

Palette* MuseScore::newTempoPalette(bool defaultPalette)
      {
      return toPalette(newTempoPalettePanel(defaultPalette));
      }

//---------------------------------------------------------
//   newTextPalette
//---------------------------------------------------------

Palette* MuseScore::newTextPalette(bool defaultPalette)
      {
      return toPalette(newTextPalettePanel(defaultPalette));
      }

//---------------------------------------------------------
//   newTimePalette
//    create default time signature palette
//---------------------------------------------------------

Palette* MuseScore::newTimePalette()
      {
      return toPalette(newTimePalettePanel());
      }

//---------------------------------------------------------
//    newFretboardDiagramPalette
//---------------------------------------------------------

Palette* MuseScore::newFretboardDiagramPalette()
      {
      return toPalette(newFretboardDiagramPalettePanel());
      }

//---------------------------------------------------------
//   newMasterPaletteTree
//---------------------------------------------------------

PaletteTree* MuseScore::newMasterPaletteTree()
      {
      PaletteTree* tree = new PaletteTree();

      tree->append(MuseScore::newClefsPalettePanel());
      tree->append(MuseScore::newKeySigPalettePanel());
      tree->append(MuseScore::newTimePalettePanel());

      tree->append(MuseScore::newBracketsPalettePanel());
      tree->append(MuseScore::newAccidentalsPalettePanel());
      tree->append(MuseScore::newArticulationsPalettePanel());
      tree->append(MuseScore::newOrnamentsPalettePanel());
      tree->append(MuseScore::newBreathPalettePanel());
      tree->append(MuseScore::newGraceNotePalettePanel());
      tree->append(MuseScore::newNoteHeadsPalettePanel());
      tree->append(MuseScore::newLinesPalettePanel());
      tree->append(MuseScore::newBarLinePalettePanel());
      tree->append(MuseScore::newArpeggioPalettePanel());
      tree->append(MuseScore::newTremoloPalettePanel());
      tree->append(MuseScore::newTextPalettePanel());
      tree->append(MuseScore::newTempoPalettePanel());
      tree->append(MuseScore::newDynamicsPalettePanel());
      tree->append(MuseScore::newFingeringPalettePanel());
      tree->append(MuseScore::newRepeatsPalettePanel());
      tree->append(MuseScore::newFretboardDiagramPalettePanel());
      tree->append(MuseScore::newAccordionPalettePanel());
      tree->append(MuseScore::newBagpipeEmbellishmentPalettePanel());
      tree->append(MuseScore::newBreaksPalettePanel());
      tree->append(MuseScore::newFramePalettePanel());
      tree->append(MuseScore::newBeamPalettePanel());

      return tree;
      }

//---------------------------------------------------------
//   populateIconPalettePanel
//---------------------------------------------------------

static void populateIconPalettePanel(PalettePanel* p, const IconAction* a)
      {
      while (a->subtype != IconType::NONE) {
            Icon* ik = new Icon(gscore);
            ik->setIconType(a->subtype);
            const Shortcut* s = Shortcut::getShortcut(a->action);
            QAction* action = s->action();
            QIcon icon(action->icon());
            ik->setAction(a->action, icon);
            p->append(ik, s->help());
            ++a;
            }
      }

//---------------------------------------------------------
//   newBeamPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newBeamPalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Beam);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Beam Properties"));
      sp->setGrid(27, 40);
      sp->setDrawGrid(true);

      const IconAction bpa[] = {
            { IconType::SBEAM,    "beam-start" },
            { IconType::MBEAM,    "beam-mid" },
            { IconType::NBEAM,    "no-beam" },
            { IconType::BEAM32,   "beam32" },
            { IconType::BEAM64,   "beam64" },
            { IconType::AUTOBEAM, "auto-beam" },
            { IconType::FBEAM1,   "fbeam1" },
            { IconType::FBEAM2,   "fbeam2" },
            { IconType::NONE,     ""}
            };

      populateIconPalettePanel(sp, bpa);
      return sp;
      }

//---------------------------------------------------------
//   newFramePalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newFramePalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Frame);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Frames & Measures"));
      sp->setGrid(27, 40);
      sp->setDrawGrid(true);

      if (enableExperimental) {
            static const IconAction bpa[] = {
                  { IconType::VFRAME,   "insert-vbox" },
                  { IconType::HFRAME,   "insert-hbox" },
                  { IconType::TFRAME,   "insert-textframe" },
                  { IconType::FFRAME,   "insert-fretframe" },    // experimental
                  { IconType::MEASURE,  "insert-measure" },
                  { IconType::NONE,     ""}
                  };
            populateIconPalettePanel(sp, bpa);
            }
      else {
            static const IconAction bpa[] = {
                  { IconType::VFRAME,   "insert-vbox" },
                  { IconType::HFRAME,   "insert-hbox" },
                  { IconType::TFRAME,   "insert-textframe" },
                  { IconType::MEASURE,  "insert-measure" },
                  { IconType::NONE,     ""}
                };
            populateIconPalettePanel(sp, bpa);
            }

      return sp;
      }

//---------------------------------------------------------
//   newDynamicsPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newDynamicsPalettePanel(bool defaultPalettePanel)
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Dynamic);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Dynamics"));
      sp->setMag(.8);
      sp->setDrawGrid(true);

      static const std::vector<const char*> array1 = {
            "pppppp", "ppppp", "pppp",
            "ppp", "pp", "p", "mp", "mf", "f", "ff", "fff",
            "ffff", "fffff", "ffffff",
            "fp", "sf", "sfz", "sff", "sffz", "sfp", "sfpp",
            "rfz", "rf", "fz", "m", "r", "s", "z", "n"
            };
      static const std::vector<const char*> arrayDefault = {
            "ppp", "pp", "p", "mp", "mf", "f", "ff", "fff",
            "fp", "sf", "sfz", "sff", "sffz", "sfp", "sfpp",
            "rfz", "rf", "fz", "m", "r", "s", "z", "n"
            };

      const std::vector<const char*>* array = nullptr;
      if (defaultPalettePanel) {
            array = &arrayDefault;
            sp->setGrid(42, 28);
            sp->setMoreElements(true);
            }
      else {
            array = &array1;
            sp->setGrid(60, 28);
            }

      for (const char* c :  *array) {
            Dynamic* dynamic = new Dynamic(gscore);
            dynamic->setDynamicType(c);
            sp->append(dynamic, dynamic->dynamicTypeName());
            }
      return sp;
      }

//---------------------------------------------------------
//   newKeySigPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newKeySigPalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::KeySig);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Key Signatures"));
      sp->setMag(1.0);
      sp->setGrid(56, 55);
      sp->setYOffset(1.0);

      for (int i = 0; i < 7; ++i) {
            KeySig* k = new KeySig(gscore);
            k->setKey(Key(i + 1));
            sp->append(k, keyNames[i*2]);
            }
      for (int i = -7; i < 0; ++i) {
            KeySig* k = new KeySig(gscore);
            k->setKey(Key(i));
            sp->append(k, keyNames[(7 + i) * 2 + 1]);
            }
      KeySig* k = new KeySig(gscore);
      k->setKey(Key::C);
      sp->append(k, keyNames[14]);

      // atonal key signature
      KeySigEvent nke;
      nke.setKey(Key::C);
      nke.setCustom(true);
      nke.setMode(KeyMode::NONE);
      KeySig* nk = new KeySig(gscore);
      nk->setKeySigEvent(nke);
      sp->append(nk, keyNames[15]);

      return sp;
      }

//---------------------------------------------------------
//   newAccidentalsPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newAccidentalsPalettePanel(bool defaultPalettePanel)
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Accidental);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Accidentals"));
      sp->setGrid(33, 36);
      sp->setDrawGrid(true);

      int end = 0;
      if (defaultPalettePanel)
            end = int(AccidentalType::SHARP_SHARP);
      else
            end = int(AccidentalType::END);

      Accidental* a = new Accidental(gscore);
      a->setAccidentalType(AccidentalType::NONE);
      sp->append(a, a->subtypeUserName());
      for (int i = int(AccidentalType::FLAT); i < end; ++i) {
            Accidental* ac = new Accidental(gscore);
            ac->setAccidentalType(AccidentalType(i));
            if (ac->symbol() != SymId::noSym)
                  sp->append(ac, ac->subtypeUserName());
            else
                  delete ac;
            }

      if (defaultPalettePanel) {
            sp->setMoreElements(true);
            }

      Icon* ik = new Icon(gscore);
      ik->setIconType(IconType::BRACKETS);
      const Shortcut* s = Shortcut::getShortcut("add-brackets");
      QAction* action = s->action();
      ik->setAction(QByteArray("add-brackets"), action->icon());
      sp->append(ik, s->help());

      ik = new Icon(gscore);
      ik->setIconType(IconType::PARENTHESES);
      s = Shortcut::getShortcut("add-parentheses");
      action = s->action();
      ik->setAction(QByteArray("add-parentheses"), action->icon());
      sp->append(ik, s->help());

      return sp;
      }

//---------------------------------------------------------
//   newBarLinePalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newBarLinePalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::BarLine);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Barlines"));
      sp->setMag(0.8);
      sp->setGrid(42, 38);

      // bar line styles
      for (unsigned i = 0;; ++i) {
            const BarLineTableItem* bti = BarLine::barLineTableItem(i);
            if (!bti)
                  break;
            BarLine* b = new BarLine(gscore);
            b->setBarLineType(bti->type);
            sp->append(b, BarLine::userTypeName(bti->type));
            }

      // bar line spans
      struct {
            int         from, to;
            const char* userName;
            } spans[] = {
            { BARLINE_SPAN_TICK1_FROM, BARLINE_SPAN_TICK1_TO, QT_TRANSLATE_NOOP("Palette", "Tick 1 span") },
            { BARLINE_SPAN_TICK2_FROM, BARLINE_SPAN_TICK2_TO, QT_TRANSLATE_NOOP("Palette", "Tick 2 span") },
            { BARLINE_SPAN_SHORT1_FROM,BARLINE_SPAN_SHORT1_TO,QT_TRANSLATE_NOOP("Palette", "Short 1 span") },
            { BARLINE_SPAN_SHORT2_FROM,BARLINE_SPAN_SHORT2_TO,QT_TRANSLATE_NOOP("Palette", "Short 2 span") },
            };
      for (auto span : spans) {
            BarLine* b = new BarLine(gscore);
            b->setBarLineType(BarLineType::NORMAL);
            b->setSpanFrom(span.from);
            b->setSpanTo(span.to);
            sp->append(b, span.userName);
            }
      return sp;
      }

//---------------------------------------------------------
//   newRepeatsPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newRepeatsPalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Repeat);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Repeats & Jumps"));
      sp->setMag(0.65);
      sp->setGrid(75, 28);
      sp->setDrawGrid(true);

      RepeatMeasure* rm = new RepeatMeasure(gscore);
      sp->append(rm, QT_TRANSLATE_NOOP("Palette", "Repeat measure sign"));

      for (int i = 0; i < markerTypeTableSize(); i++) {
            if (markerTypeTable[i].type == Marker::Type::CODETTA) //not in smufl
                  continue;

            Marker* mk = new Marker(gscore);
            mk->setMarkerType(markerTypeTable[i].type);
            mk->styleChanged();
            sp->append(mk, markerTypeTable[i].name);
            }

      for (int i = 0; i < jumpTypeTableSize(); i++) {
            Jump* jp = new Jump(gscore);
            jp->setJumpType(jumpTypeTable[i].type);
            sp->append(jp, jumpTypeTable[i].userText);
            }

      for (unsigned i = 0;; ++i) {
            const BarLineTableItem* bti = BarLine::barLineTableItem(i);
            if (!bti)
                  break;
            switch (bti->type) {
                  case BarLineType::START_REPEAT:
                  case BarLineType::END_REPEAT:
                  case BarLineType::END_START_REPEAT:
                        break;
                  default:
                        continue;
                  }

            BarLine* b = new BarLine(gscore);
            b->setBarLineType(bti->type);
            PaletteCell* cell= sp->append(b, BarLine::userTypeName(bti->type));
            cell->drawStaff = false;
            }

      return sp;
      }

//---------------------------------------------------------
//   newBreaksPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newBreaksPalettePanel()
      {
      qreal _spatium = gscore->spatium();
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Break);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Breaks & Spacers"));
      sp->setMag(1.0);
      sp->setGrid(42, 36);
      sp->setDrawGrid(true);

      struct BreakItem {
            LayoutBreak b;
            };
      LayoutBreak* lb = new LayoutBreak(gscore);
      lb->setLayoutBreakType(LayoutBreak::Type::LINE);
      PaletteCell* cell = sp->append(lb, QT_TRANSLATE_NOOP("Palette", "System break"));
      cell->mag = 1.2;

      lb = new LayoutBreak(gscore);
      lb->setLayoutBreakType(LayoutBreak::Type::PAGE);
      cell = sp->append(lb, QT_TRANSLATE_NOOP("Palette", "Page break"));
      cell->mag = 1.2;

      lb = new LayoutBreak(gscore);
      lb->setLayoutBreakType(LayoutBreak::Type::SECTION);
      cell = sp->append(lb, QT_TRANSLATE_NOOP("Palette", "Section break"));
      cell->mag = 1.2;

#if 0
      lb = new LayoutBreak(gscore);
      lb->setLayoutBreakType(LayoutBreak::Type::NOBREAK);
      cell = sp->append(lb, QT_TRANSLATE_NOOP("Palette", "Don't break"));
      cell->mag = 1.2;
#endif

      Spacer* spacer = new Spacer(gscore);
      spacer->setSpacerType(SpacerType::DOWN);
      spacer->setGap(3 * _spatium);
      cell = sp->append(spacer, QT_TRANSLATE_NOOP("Palette", "Staff spacer down"));
      cell->mag = .7;

      spacer = new Spacer(gscore);
      spacer->setSpacerType(SpacerType::UP);
      spacer->setGap(3 * _spatium);
      cell = sp->append(spacer, QT_TRANSLATE_NOOP("Palette", "Staff spacer up"));
      cell->mag = .7;

      spacer = new Spacer(gscore);
      spacer->setSpacerType(SpacerType::FIXED);
      spacer->setGap(3 * _spatium);
      cell = sp->append(spacer, QT_TRANSLATE_NOOP("Palette", "Staff spacer fixed down"));
      cell->mag = .7;

      return sp;
      }

//---------------------------------------------------------
//   newFingeringPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newFingeringPalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Fingering);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Fingering"));
      sp->setMag(1.5);
      sp->setGrid(28, 30);
      sp->setDrawGrid(true);

      const char* finger = "012345";
      for (unsigned i = 0; i < strlen(finger); ++i) {
            Fingering* f = new Fingering(gscore);
            f->setXmlText(QString(finger[i]));
            sp->append(f, QT_TRANSLATE_NOOP("Palette", "Fingering %1"));
            }
      finger = "pimac";
      for (unsigned i = 0; i < strlen(finger); ++i) {
            Fingering* f = new Fingering(gscore, Tid::RH_GUITAR_FINGERING);
            f->setXmlText(QString(finger[i]));
            sp->append(f, QT_TRANSLATE_NOOP("Palette", "RH Guitar Fingering %1"));
            }
      finger = "012345T";
      for (unsigned i = 0; i < strlen(finger); ++i) {
            Fingering* f = new Fingering(gscore, Tid::LH_GUITAR_FINGERING);
            f->setXmlText(QString(finger[i]));
            sp->append(f, QT_TRANSLATE_NOOP("Palette", "LH Guitar Fingering %1"));
            }
      finger = "0123456";
      for (unsigned i = 0; i < strlen(finger); ++i) {
            Fingering* f = new Fingering(gscore, Tid::STRING_NUMBER);
            f->setXmlText(QString(finger[i]));
            sp->append(f, QT_TRANSLATE_NOOP("Palette", "String number %1"));
            }

      static const std::vector<SymId> lute {
            SymId::stringsThumbPosition,
            SymId::luteFingeringRHThumb, SymId::luteFingeringRHFirst,
            SymId::luteFingeringRHSecond, SymId::luteFingeringRHThird
            };
      // include additional symbol-based fingerings (temporarily?) implemented as articulations
      for (auto i : lute) {
            Articulation* s = new Articulation(i, gscore);
            sp->append(s, s->userName());
            }
      return sp;
      }

//---------------------------------------------------------
//   newTremoloPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newTremoloPalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Tremolo);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Tremolos"));
      sp->setGrid(27, 40);
      sp->setDrawGrid(true);

      for (int i = int(TremoloType::R8); i <= int(TremoloType::C64); ++i) {
            Tremolo* tremolo = new Tremolo(gscore);
            tremolo->setTremoloType(TremoloType(i));
            sp->append(tremolo, tremolo->subtypeName());
            }
      return sp;
      }

//---------------------------------------------------------
//   newNoteHeadsPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newNoteHeadsPalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::NoteHead);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Noteheads"));
      sp->setMag(1.3);
      sp->setGrid(33, 36);
      sp->setDrawGrid(true);

      for (int i = 0; i < int(NoteHead::Group::HEAD_DO_WALKER); ++i) {
            SymId sym = Note::noteHead(0, NoteHead::Group(i), NoteHead::Type::HEAD_HALF);
            // HEAD_BREVIS_ALT shows up only for brevis value
            if (i == int(NoteHead::Group::HEAD_BREVIS_ALT))
                  sym = Note::noteHead(0, NoteHead::Group(i), NoteHead::Type::HEAD_BREVIS);
            NoteHead* nh = new NoteHead(gscore);
            nh->setSym(sym);
            sp->append(nh, NoteHead::group2userName(NoteHead::Group(i)));
            }
      Icon* ik = new Icon(gscore);
      ik->setIconType(IconType::PARENTHESES);
      const Shortcut* s = Shortcut::getShortcut("add-parentheses");
      QAction* action = s->action();
      QIcon icon(action->icon());
      ik->setAction("add-parentheses", icon);
      sp->append(ik, s->help());
      return sp;
      }

//---------------------------------------------------------
//   newArticulationsPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newArticulationsPalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Articulation);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Articulations"));
      sp->setGrid(42, 25);
      sp->setDrawGrid(true);

      // do not include additional symbol-based fingerings (temporarily?) implemented as articulations
      static const std::vector<SymId> fermatas {
            SymId::fermataAbove,
            SymId::fermataShortAbove,
            SymId::fermataLongAbove,
            SymId::fermataLongHenzeAbove,
            SymId::fermataShortHenzeAbove,
            SymId::fermataVeryLongAbove,
            SymId::fermataVeryShortAbove,
            };
      for (auto i : fermatas) {
            Fermata* f = new Fermata(i, gscore);
            sp->append(f, f->userName());
            }
      static const std::vector<SymId> art {
            SymId::articAccentAbove,
            SymId::articStaccatoAbove,
            SymId::articStaccatissimoAbove,
            SymId::articTenutoAbove,
            SymId::articTenutoStaccatoAbove,
            SymId::articMarcatoAbove,
            SymId::articAccentStaccatoAbove,
            SymId::articLaissezVibrerAbove,
            SymId::articMarcatoStaccatoAbove,
            SymId::articMarcatoTenutoAbove,
            SymId::articStaccatissimoStrokeAbove,
            SymId::articStaccatissimoWedgeAbove,
            SymId::articStressAbove,
            SymId::articTenutoAccentAbove,
            SymId::articUnstressAbove,

            SymId::articSoftAccentAbove,                    // supplemental articulations
            SymId::articSoftAccentStaccatoAbove,
            SymId::articSoftAccentTenutoAbove,
            SymId::articSoftAccentTenutoStaccatoAbove,

            SymId::guitarFadeIn,
            SymId::guitarFadeOut,
            SymId::guitarVolumeSwell,
            SymId::wiggleSawtooth,
            SymId::wiggleSawtoothWide,
            SymId::wiggleVibratoLargeFaster,
            SymId::wiggleVibratoLargeSlowest,
            SymId::brassMuteOpen,
            SymId::brassMuteClosed,
            SymId::stringsHarmonic,
            SymId::stringsUpBow,
            SymId::stringsDownBow,
            SymId::pluckedSnapPizzicatoAbove,
            // SymId::stringsThumbPosition,
            // SymId::luteFingeringRHThumb,
            // SymId::luteFingeringRHFirst,
            // SymId::luteFingeringRHSecond,
            // SymId::luteFingeringRHThird,
            };
      for (auto i : art) {
            Articulation* s = new Articulation(i, gscore);
            sp->append(s, s->userName());
            }
      Bend* bend = new Bend(gscore);
      bend->points().append(PitchValue(0,    0, false));
      bend->points().append(PitchValue(15, 100, false));
      bend->points().append(PitchValue(60, 100, false));
      sp->append(bend, QT_TRANSLATE_NOOP("Palette", "Bend"));

      TremoloBar* tb = new TremoloBar(gscore);
      tb->points().append(PitchValue(0,     0, false));     // "Dip"
      tb->points().append(PitchValue(30, -100, false));
      tb->points().append(PitchValue(60,    0, false));
      sp->append(tb, QT_TRANSLATE_NOOP("Palette", "Tremolo bar"));

      return sp;
      }

//---------------------------------------------------------
//   newOrnamentsPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newOrnamentsPalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Ornament);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Ornaments"));
      sp->setGrid(42, 25);
      sp->setDrawGrid(true);

      // do not include additional symbol-based fingerings (temporarily?) implemented as articulations
      static const std::vector<SymId> art {
            SymId::ornamentTurnInverted,
            SymId::ornamentTurn,
            SymId::ornamentTrill,
            SymId::ornamentMordent,
            SymId::ornamentMordentInverted,
            SymId::ornamentTremblement,
            SymId::ornamentPrallMordent,
            SymId::ornamentUpPrall,
            SymId::ornamentPrecompMordentUpperPrefix,       // SymId::ornamentDownPrall,
            SymId::ornamentUpMordent,
            SymId::ornamentDownMordent,
            SymId::ornamentPrallDown,
            SymId::ornamentPrallUp,
            SymId::ornamentLinePrall,
            SymId::ornamentPrecompSlide,
            };
      for (auto i : art) {
            Articulation* s = new Articulation(i, gscore);
            sp->append(s, s->userName());
            }
      return sp;
      }

//---------------------------------------------------------
//   newAccordionPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newAccordionPalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Accordion);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Accordion"));
      sp->setGrid(42, 25);
      sp->setDrawGrid(true);

      // do not include additional symbol-based fingerings (temporarily?) implemented as articulations
      static std::vector<SymId> art {
            SymId::accdnCombDot,
            SymId::accdnCombLH2RanksEmpty,
            SymId::accdnCombLH3RanksEmptySquare,
            SymId::accdnCombRH3RanksEmpty,
            SymId::accdnCombRH4RanksEmpty,
            SymId::accdnDiatonicClef,
            SymId::accdnLH2Ranks16Round,
            SymId::accdnLH2Ranks8Plus16Round,
            SymId::accdnLH2Ranks8Round,
            SymId::accdnLH2RanksFullMasterRound,

            SymId::accdnLH2RanksMasterPlus16Round,
            SymId::accdnLH2RanksMasterRound,
            SymId::accdnLH3Ranks2Plus8Square,
            SymId::accdnLH3Ranks2Square,
            SymId::accdnLH3Ranks8Square,
            SymId::accdnLH3RanksDouble8Square,
            SymId::accdnLH3RanksTuttiSquare,
            SymId::accdnPull,
            SymId::accdnPush,
            SymId::accdnRH3RanksAccordion,

            SymId::accdnRH3RanksAuthenticMusette,
            SymId::accdnRH3RanksBandoneon,
            SymId::accdnRH3RanksBassoon,
            SymId::accdnRH3RanksClarinet,
            SymId::accdnRH3RanksDoubleTremoloLower8ve,
            SymId::accdnRH3RanksDoubleTremoloUpper8ve,
            SymId::accdnRH3RanksFullFactory,
            SymId::accdnRH3RanksHarmonium,
            SymId::accdnRH3RanksImitationMusette,
            SymId::accdnRH3RanksLowerTremolo8,

            SymId::accdnRH3RanksMaster,
            SymId::accdnRH3RanksOboe,
            SymId::accdnRH3RanksOrgan,
            SymId::accdnRH3RanksPiccolo,
            SymId::accdnRH3RanksTremoloLower8ve,
            SymId::accdnRH3RanksTremoloUpper8ve,
            SymId::accdnRH3RanksTwoChoirs,
            SymId::accdnRH3RanksUpperTremolo8,
            SymId::accdnRH3RanksViolin,
            SymId::accdnRH4RanksAlto,

            SymId::accdnRH4RanksBassAlto,
            SymId::accdnRH4RanksMaster,
            SymId::accdnRH4RanksSoftBass,
            SymId::accdnRH4RanksSoftTenor,
            SymId::accdnRH4RanksSoprano,
            SymId::accdnRH4RanksTenor,
            SymId::accdnRicochet2,
            SymId::accdnRicochet3,
            SymId::accdnRicochet4,
            SymId::accdnRicochet5,

            SymId::accdnRicochet6,
            SymId::accdnRicochetStem2,
            SymId::accdnRicochetStem3,
            SymId::accdnRicochetStem4,
            SymId::accdnRicochetStem5,
            SymId::accdnRicochetStem6
            };
      for (auto i : art) {
            Symbol* s = new Symbol(gscore);
            s->setSym(i);
            sp->append(s, Sym::id2userName(i));
            }
      return sp;
      }

//---------------------------------------------------------
//   newBracketsPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newBracketsPalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Bracket);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Brackets"));
      sp->setMag(0.7);
      sp->setGrid(40, 60);
      sp->setDrawGrid(true);

      for (auto t : std::array<std::pair<BracketType,const char*>, 4> {
         {{ BracketType::NORMAL, QT_TRANSLATE_NOOP("Palette", "Bracket") },
          { BracketType::BRACE,  QT_TRANSLATE_NOOP("Palette", "Brace")   },
          { BracketType::SQUARE, QT_TRANSLATE_NOOP("Palette", "Square")  },
          { BracketType::LINE,   QT_TRANSLATE_NOOP("Palette", "Line")    }}
         } ) {
            Bracket* b1      = new Bracket(gscore);
            BracketItem* bi1 = new BracketItem(gscore);
            bi1->setBracketType(t.first);
            b1->setBracketItem(bi1);
            sp->append(b1, t.second);      // Bracket, Brace, Square, Line
            }
      return sp;
      }

//---------------------------------------------------------
//   newBreathPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newBreathPalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Breath);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Breaths & Pauses"));
      sp->setGrid(42, 40);
      sp->setDrawGrid(true);
      sp->setDrawGrid(true);

      for (BreathType bt : Breath::breathList) {
            Breath* a = new Breath(gscore);
            a->setSymId(bt.id);
            a->setPause(bt.pause);
            sp->append(a, Sym::id2userName(bt.id));
            }
      return sp;
      }

//---------------------------------------------------------
//   newArpeggioPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newArpeggioPalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Arpeggio);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Arpeggios & Glissandi"));
      sp->setGrid(27, 50);
      sp->setDrawGrid(true);

      for (int i = 0; i < 6; ++i) {
            Arpeggio* a = new Arpeggio(gscore);
            a->setArpeggioType(ArpeggioType(i));
            sp->append(a, QT_TRANSLATE_NOOP("Palette", "Arpeggio"));
            }
      for (int i = 0; i < 2; ++i) {
            Glissando* a = new Glissando(gscore);
            a->setGlissandoType(GlissandoType(i));
            sp->append(a, QT_TRANSLATE_NOOP("Palette", "Glissando"));
            }

      //fall and doits

      ChordLine* cl = new ChordLine(gscore);
      cl->setChordLineType(ChordLineType::FALL);
      sp->append(cl, scorelineNames[0]);

      cl = new ChordLine(gscore);
      cl->setChordLineType(ChordLineType::DOIT);
      sp->append(cl, scorelineNames[1]);

      cl = new ChordLine(gscore);
      cl->setChordLineType(ChordLineType::PLOP);
      sp->append(cl, scorelineNames[2]);

      cl = new ChordLine(gscore);
      cl->setChordLineType(ChordLineType::SCOOP);
      sp->append(cl, scorelineNames[3]);

      cl = new ChordLine(gscore);
      cl->setChordLineType(ChordLineType::FALL);
      cl->setStraight(true);
      sp->append(cl, QT_TRANSLATE_NOOP("Ms", "Slide out down"));

      cl = new ChordLine(gscore);
      cl->setChordLineType(ChordLineType::DOIT);
      cl->setStraight(true);
      sp->append(cl, QT_TRANSLATE_NOOP("Ms", "Slide out up"));

      cl = new ChordLine(gscore);
      cl->setChordLineType(ChordLineType::PLOP);
      cl->setStraight(true);
      sp->append(cl, QT_TRANSLATE_NOOP("Ms", "Slide in above"));

      cl = new ChordLine(gscore);
      cl->setChordLineType(ChordLineType::SCOOP);
      cl->setStraight(true);
      sp->append(cl, QT_TRANSLATE_NOOP("Ms", "Slide in below"));

      return sp;
      }

//---------------------------------------------------------
//   newClefsPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newClefsPalettePanel(bool defaultPalettePanel)
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Clef);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Clefs"));
      sp->setMag(0.8);
      sp->setGrid(35, 50);
      sp->setYOffset(1.0);

      static std::vector<ClefType> clefsDefault  {
            ClefType::G,     ClefType::G8_VA,  ClefType::G15_MA,  ClefType::G8_VB, ClefType::G15_MB, ClefType::G8_VB_O,
            ClefType::G8_VB_P,    ClefType::G_1,  ClefType::C1,  ClefType::C2,    ClefType::C3,
            ClefType::C4,    ClefType::C5, ClefType::F,   ClefType::F_8VA, ClefType::F_15MA,
            ClefType::F8_VB,    ClefType::F15_MB, ClefType::F_B, ClefType::F_C, ClefType::PERC,
            ClefType::PERC2, ClefType::TAB, ClefType::TAB4
            };
      static std::vector<ClefType> clefsMaster  {
            ClefType::G,     ClefType::G8_VA,  ClefType::G15_MA,  ClefType::G8_VB, ClefType::G15_MB, ClefType::G8_VB_O,
            ClefType::G8_VB_P,    ClefType::G_1,  ClefType::C1,  ClefType::C2,    ClefType::C3,
            ClefType::C4,    ClefType::C5,  ClefType::C_19C, ClefType::C3_F18C, ClefType::C4_F18C, ClefType::C3_F20C, ClefType::C4_F20C,
             ClefType::F,   ClefType::F_8VA, ClefType::F_15MA,
            ClefType::F8_VB,    ClefType::F15_MB, ClefType::F_B, ClefType::F_C, ClefType::F_F18C, ClefType::F_19C,  ClefType::PERC,
            ClefType::PERC2, ClefType::TAB, ClefType::TAB4, ClefType::TAB_SERIF, ClefType::TAB4_SERIF
            };

      std::vector<ClefType>* items = nullptr;
      if (defaultPalettePanel) {
            items = &clefsDefault;
            sp->setMoreElements(true);
            }
      else {
            items = &clefsMaster;
            sp->setMoreElements(false);
            }

      for (ClefType j : *items) {
            Clef* k = new Ms::Clef(gscore);
            k->setClefType(ClefTypeList(j, j));
            sp->append(k, ClefInfo::name(j));
            }
      return sp;
      }

//---------------------------------------------------------
//   newGraceNotePalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newGraceNotePalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::GraceNote);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Grace Notes"));
      sp->setGrid(32, 40);
      sp->setDrawGrid(true);
      static const IconAction gna[] = {
            { IconType::ACCIACCATURA,  "acciaccatura" },
            { IconType::APPOGGIATURA,  "appoggiatura" },
            { IconType::GRACE4,        "grace4" },
            { IconType::GRACE16,       "grace16" },
            { IconType::GRACE32,       "grace32" },
            { IconType::GRACE8_AFTER,  "grace8after" },
            { IconType::GRACE16_AFTER, "grace16after" },
            { IconType::GRACE32_AFTER, "grace32after" },
            { IconType::NONE,          "" }
            };
      populateIconPalettePanel(sp, gna);
      return sp;
      }

//---------------------------------------------------------
//   newBagpipeEmbellishmentPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newBagpipeEmbellishmentPalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::BagpipeEmbellishment);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Bagpipe Embellishments"));
      sp->setMag(0.8);
      sp->setYOffset(2.0);
      sp->setGrid(55, 55);
      for (int i = 0; i < BagpipeEmbellishment::nEmbellishments(); ++i) {
            BagpipeEmbellishment* b  = new BagpipeEmbellishment(gscore);
            b->setEmbelType(i);
            sp->append(b, BagpipeEmbellishment::BagpipeEmbellishmentList[i].name);
            }

      return sp;
      }

//---------------------------------------------------------
//   newLinesPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newLinesPalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Line);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Lines"));
      sp->setMag(.8);
      sp->setGrid(75, 28);
      sp->setDrawGrid(true);

      qreal w = gscore->spatium() * 8;

      Slur* slur = new Slur(gscore);
      sp->append(slur, QT_TRANSLATE_NOOP("Palette", "Slur"));

      Hairpin* gabel0 = new Hairpin(gscore);
      gabel0->setHairpinType(HairpinType::CRESC_HAIRPIN);
      gabel0->setLen(w);
      sp->append(gabel0, QT_TRANSLATE_NOOP("Palette", "Crescendo hairpin"));

      Hairpin* gabel1 = new Hairpin(gscore);
      gabel1->setHairpinType(HairpinType::DECRESC_HAIRPIN);
      gabel1->setLen(w);
      sp->append(gabel1, QT_TRANSLATE_NOOP("Palette", "Diminuendo hairpin"));

      Hairpin* gabel2 = new Hairpin(gscore);
      gabel2->setHairpinType(HairpinType::CRESC_LINE);
      gabel2->setLen(w);
      sp->append(gabel2, QT_TRANSLATE_NOOP("Palette", "Crescendo line"));

      Hairpin* gabel3 = new Hairpin(gscore);
      gabel3->setHairpinType(HairpinType::DECRESC_LINE);
      gabel3->setLen(w);
      sp->append(gabel3, QT_TRANSLATE_NOOP("Palette", "Diminuendo line"));

      Hairpin* gabel4 = new Hairpin(gscore);
      gabel4->setHairpinType(HairpinType::CRESC_HAIRPIN);
      gabel4->setBeginText("<sym>dynamicMezzo</sym><sym>dynamicForte</sym>");
      gabel4->setPropertyFlags(Pid::BEGIN_TEXT, PropertyFlags::UNSTYLED);
      gabel4->setBeginTextAlign(Align::VCENTER);
      gabel4->setPropertyFlags(Pid::BEGIN_TEXT_ALIGN, PropertyFlags::UNSTYLED);
      gabel4->setLen(w);
      sp->append(gabel4, QT_TRANSLATE_NOOP("Palette", "Dynamic + hairpin"));

      Volta* volta = new Volta(gscore);
      volta->setVoltaType(Volta::Type::CLOSED);
      volta->setLen(w);
      volta->setText("1.");
      QList<int> il;
      il.append(1);
      volta->setEndings(il);
      sp->append(volta, QT_TRANSLATE_NOOP("Palette", "Prima volta"));

      volta = new Volta(gscore);
      volta->setVoltaType(Volta::Type::CLOSED);
      volta->setLen(w);
      volta->setText("2.");
      il.clear();
      il.append(2);
      volta->setEndings(il);
      sp->append(volta, QT_TRANSLATE_NOOP("Palette", "Seconda volta"));

      volta = new Volta(gscore);
      volta->setVoltaType(Volta::Type::CLOSED);
      volta->setLen(w);
      volta->setText("3.");
      il.clear();
      il.append(3);
      volta->setEndings(il);
      sp->append(volta, QT_TRANSLATE_NOOP("Palette", "Terza volta"));

      volta = new Volta(gscore);
      volta->setVoltaType(Volta::Type::OPEN);
      volta->setLen(w);
      volta->setText("2.");
      il.clear();
      il.append(2);
      volta->setEndings(il);
      sp->append(volta, QT_TRANSLATE_NOOP("Palette", "Seconda volta, open"));

      Ottava* ottava = new Ottava(gscore);
      ottava->setOttavaType(OttavaType::OTTAVA_8VA);
      ottava->setLen(w);
      ottava->styleChanged();
      sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "8va alta"));

      ottava = new Ottava(gscore);
      ottava->setOttavaType(OttavaType::OTTAVA_8VB);
      ottava->setLen(w);
      ottava->setPlacement(Placement::BELOW);
      ottava->styleChanged();
      sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "8va bassa"));

      ottava = new Ottava(gscore);
      ottava->setOttavaType(OttavaType::OTTAVA_15MA);
      ottava->setLen(w);
      ottava->styleChanged();
      sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "15ma alta"));

      ottava = new Ottava(gscore);
      ottava->setOttavaType(OttavaType::OTTAVA_15MB);
      ottava->setLen(w);
      ottava->setPlacement(Placement::BELOW);
      ottava->styleChanged();
      sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "15ma bassa"));

      ottava = new Ottava(gscore);
      ottava->setOttavaType(OttavaType::OTTAVA_22MA);
      ottava->setLen(w);
      ottava->styleChanged();
      sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "22ma alta"));

      ottava = new Ottava(gscore);
      ottava->setOttavaType(OttavaType::OTTAVA_22MB);
      ottava->setLen(w);
      ottava->styleChanged();
      sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "22ma bassa"));

      Pedal* pedal;
      pedal = new Pedal(gscore);
      pedal->setLen(w);
      pedal->setBeginText("<sym>keyboardPedalPed</sym>");
      pedal->setContinueText("(<sym>keyboardPedalPed</sym>)");
      pedal->setEndHookType(HookType::HOOK_90);
      sp->append(pedal, QT_TRANSLATE_NOOP("Palette", "Pedal"));

      pedal = new Pedal(gscore);
      pedal->setLen(w);
      pedal->setBeginText("<sym>keyboardPedalPed</sym>");
      pedal->setContinueText("(<sym>keyboardPedalPed</sym>)");
      pedal->setEndText("<sym>keyboardPedalUp</sym>");
      pedal->setLineVisible(false);
      sp->append(pedal, QT_TRANSLATE_NOOP("Palette", "Pedal"));

      pedal = new Pedal(gscore);
      pedal->setLen(w);
      pedal->setBeginHookType(HookType::HOOK_90);
      pedal->setEndHookType(HookType::HOOK_90);
      sp->append(pedal, QT_TRANSLATE_NOOP("Palette", "Pedal"));

      pedal = new Pedal(gscore);
      pedal->setLen(w);
      pedal->setBeginHookType(HookType::HOOK_90);
      pedal->setEndHookType(HookType::HOOK_45);
      sp->append(pedal, QT_TRANSLATE_NOOP("Palette", "Pedal"));

      pedal = new Pedal(gscore);
      pedal->setLen(w);
      pedal->setBeginHookType(HookType::HOOK_45);
      pedal->setEndHookType(HookType::HOOK_45);
      sp->append(pedal, QT_TRANSLATE_NOOP("Palette", "Pedal"));

      pedal = new Pedal(gscore);
      pedal->setLen(w);
      pedal->setBeginHookType(HookType::HOOK_45);
      pedal->setEndHookType(HookType::HOOK_90);
      sp->append(pedal, QT_TRANSLATE_NOOP("Palette", "Pedal"));

      for (int i = 0; i < trillTableSize(); i++) {
            Trill* trill = new Trill(gscore);
            trill->setTrillType(trillTable[i].type);
            trill->setLen(w);
            sp->append(trill, trillTable[i].userName);
            }

      TextLine* textLine = new TextLine(gscore);
      textLine->setLen(w);
      textLine->setBeginText("VII");
      textLine->setEndHookType(HookType::HOOK_90);
      sp->append(textLine, QT_TRANSLATE_NOOP("Palette", "Text line"));

      TextLine* line = new TextLine(gscore);
      line->setLen(w);
      line->setDiagonal(true);
      sp->append(line, QT_TRANSLATE_NOOP("Palette", "Line"));

      Ambitus* a = new Ambitus(gscore);
      sp->append(a, QT_TRANSLATE_NOOP("Palette", "Ambitus"));

      LetRing* letRing = new LetRing(gscore);
      letRing->setLen(w);
      sp->append(letRing, QT_TRANSLATE_NOOP("Palette", "Let Ring"));

      for (int i = 0; i < vibratoTableSize(); i++) {
            Vibrato* vibrato = new Vibrato(gscore);
            vibrato->setVibratoType(vibratoTable[i].type);
            vibrato->setLen(w);
            sp->append(vibrato, vibratoTable[i].userName);
            }

      PalmMute* pm = new PalmMute(gscore);
      pm->setLen(w);
      sp->append(pm, QT_TRANSLATE_NOOP("Palette", "Palm Mute"));

      return sp;
      }

//---------------------------------------------------------
//   newTempoPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newTempoPalettePanel(bool defaultPalettePanel)
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Tempo);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Tempo"));
      sp->setMag(0.65);
      if (defaultPalettePanel)
            sp->setGrid(66, 28);
      else
            sp->setGrid(116, 28);
      sp->setDrawGrid(true);

      static const TempoPattern tps[] = {
            TempoPattern("<sym>metNoteHalfUp</sym> = 80",    80.0/ 30.0, false, false, true, true, false),                // 1/2
            TempoPattern("<sym>metNoteQuarterUp</sym> = 80", 80.0/ 60.0, false, false, true, true, false),                // 1/4
            TempoPattern("<sym>metNote8thUp</sym> = 80",     80.0/120.0, false, false, true, true, false),                // 1/8
            TempoPattern("<sym>metNoteHalfUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = 80",    120/ 30.0, false, false, true, false, false),   // dotted 1/2
            TempoPattern("<sym>metNoteQuarterUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = 80", 120/ 60.0, false, false, true, true, false),   // dotted 1/4
            TempoPattern("<sym>metNote8thUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = 80",     120/120.0, false, false, true, false, false),   // dotted 1/8

            TempoPattern("Grave",             35.0/60.0, false, true, false, false, false),
            TempoPattern("Largo",             50.0/60.0, false, true, false, false, false),
            TempoPattern("Lento",             52.5/60.0, false, true, false, false, false),
            TempoPattern("Larghetto",         63.0/60.0, false, true, false, false, true),
            TempoPattern("Adagio",            71.0/60.0, false, true, false, false, false),
            TempoPattern("Andante",           92.0/60.0, false, true, false, false, false),
            TempoPattern("Andantino",         94.0/60.0, false, true, false, false, true),
            TempoPattern("Moderato",         114.0/60.0, false, true, false, false, false),
            TempoPattern("Allegretto",       116.0/60.0, false, true, false, false, false),
            TempoPattern("Allegro moderato", 118.0/60.0, false, true, false, false, true),
            TempoPattern("Allegro",          144.0/60.0, false, true, false, false, false),
            TempoPattern("Vivace",           172.0/60.0, false, true, false, false, false),
            TempoPattern("Presto",           187.0/60.0, false, true, false, false, false),
            TempoPattern("Prestissimo",      200.0/60.0, false, true, false, false, true),

            TempoPattern("<sym>metNoteQuarterUp</sym> = <sym>metNoteQuarterUp</sym><sym>space</sym><sym>metAugmentationDot</sym>", 3.0/2.0, true, false, true, false, false),
            TempoPattern("<sym>metNoteQuarterUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = <sym>metNoteQuarterUp</sym>", 2.0/3.0, true, false, true, false, false),
            TempoPattern("<sym>metNoteHalfUp</sym> = <sym>metNoteQuarterUp</sym>",    1.0/2.0, true, false, true, false, false),
            TempoPattern("<sym>metNoteQuarterUp</sym> = <sym>metNoteHalfUp</sym>",    2.0/1.0, true, false, true, false, false),
            TempoPattern("<sym>metNote8thUp</sym> = <sym>metNote8thUp</sym>",         1.0/1.0, true, false, true, false, false),
            TempoPattern("<sym>metNoteQuarterUp</sym> = <sym>metNoteQuarterUp</sym>", 1.0/1.0, true, false, true, false, false),
            };
      for (TempoPattern tp : tps) {
            TempoText* tt = new TempoText(gscore);
            tt->setFollowText(tp.followText);
            tt->setXmlText(tp.pattern);
            if (tp.relative) {
                  tt->setRelative(tp.f);
                  sp->append(tt, QT_TRANSLATE_NOOP("Palette", "Metric modulation"), QString(), 1.5);
                  }
            else if (tp.italian) {
                  tt->setTempo(tp.f);
                  sp->append(tt, QT_TRANSLATE_NOOP("Palette", "Tempo text"), QString(), 1.3);
                  }
            else {
                  tt->setTempo(tp.f);
                  sp->append(tt, QT_TRANSLATE_NOOP("Palette", "Tempo text"), QString(), 1.5);
                  }
            }
      sp->setMoreElements(false);

      return sp;
      }

//---------------------------------------------------------
//   newTextPalettePanel
//---------------------------------------------------------

PalettePanel* MuseScore::newTextPalettePanel(bool defaultPalettePanel)
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::Text);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Text"));
      sp->setMag(0.85);
      sp->setGrid(84, 28);
      sp->setDrawGrid(true);

      StaffText* st = new StaffText(gscore);
      st->setXmlText(QT_TRANSLATE_NOOP("Palette", "Staff Text"));
      sp->append(st, QT_TRANSLATE_NOOP("Palette", "Staff text"))->setElementTranslated(true);

      st = new StaffText(gscore, Tid::EXPRESSION);
      st->setXmlText(QT_TRANSLATE_NOOP("Palette", "Expression"));
      st->setPlacement(Placement::BELOW);
      st->setPropertyFlags(Pid::PLACEMENT, PropertyFlags::UNSTYLED);
      sp->append(st, QT_TRANSLATE_NOOP("Palette", "Expression text"))->setElementTranslated(true);

      InstrumentChange* is = new InstrumentChange(gscore);
      is->setXmlText(QT_TRANSLATE_NOOP("Palette", "Change Instr."));
      sp->append(is, QT_TRANSLATE_NOOP("Palette", "Instrument change"))->setElementTranslated(true);

      StaffTypeChange* stc = new StaffTypeChange(gscore);
      sp->append(stc, QT_TRANSLATE_NOOP("Palette", "Staff type change"));

      RehearsalMark* rhm = new RehearsalMark(gscore);
      rhm->setXmlText("B1");
      sp->append(rhm, QT_TRANSLATE_NOOP("Palette", "Rehearsal mark"));

      SystemText* stxt = new SystemText(gscore, Tid::TEMPO);
      stxt->setXmlText(QT_TRANSLATE_NOOP("Palette", "Swing"));
      stxt->setSwing(true);
      sp->append(stxt, QT_TRANSLATE_NOOP("Palette", "Swing"))->setElementTranslated(true);

      stxt = new SystemText(gscore);
      stxt->setXmlText(QT_TRANSLATE_NOOP("Palette", "System Text"));
      sp->append(stxt, QT_TRANSLATE_NOOP("Palette", "System text"))->setElementTranslated(true);

      if (!defaultPalettePanel) {
            StaffText* pz = new StaffText(gscore);
            pz->setXmlText(QT_TRANSLATE_NOOP("Palette", "pizz."));
            pz->setChannelName(0, "pizzicato");
            sp->append(pz, QT_TRANSLATE_NOOP("Palette", "Pizzicato"))->setElementTranslated(true);

            StaffText* ar = new StaffText(gscore);
            ar->setXmlText(QT_TRANSLATE_NOOP("Palette", "arco"));
            ar->setChannelName(0, "arco");
            sp->append(ar, QT_TRANSLATE_NOOP("Palette", "Arco"))->setElementTranslated(true);

            StaffText* tm = new StaffText(gscore, Tid::EXPRESSION);
            tm->setXmlText(QT_TRANSLATE_NOOP("Palette", "tremolo"));
            tm->setChannelName(0, "tremolo");
            sp->append(tm, QT_TRANSLATE_NOOP("Palette", "Tremolo"))->setElementTranslated(true);

            StaffText* mu = new StaffText(gscore);
            /*: For brass instruments: staff text that prescribes to use mute while playing, see https://en.wikipedia.org/wiki/Mute_(music) */
            mu->setXmlText(QT_TRANSLATE_NOOP("Palette", "mute"));
            mu->setChannelName(0, "mute");
            /*: For brass instruments: staff text that prescribes to use mute while playing, see https://en.wikipedia.org/wiki/Mute_(music) */
            sp->append(mu, QT_TRANSLATE_NOOP("Palette", "Mute"))->setElementTranslated(true);

            StaffText* no = new StaffText(gscore);
            /*: For brass instruments: staff text that prescribes to play without mute, see https://en.wikipedia.org/wiki/Mute_(music) */
            no->setXmlText(QT_TRANSLATE_NOOP("Palette", "open"));
            no->setChannelName(0, "open");
            /*: For brass instruments: staff text that prescribes to play without mute, see https://en.wikipedia.org/wiki/Mute_(music) */
            sp->append(no, QT_TRANSLATE_NOOP("Palette", "Open"))->setElementTranslated(true);
            }

      return sp;
      }

//---------------------------------------------------------
//   newTimePalettePanel
//    create default time signature palette
//---------------------------------------------------------

PalettePanel* MuseScore::newTimePalettePanel()
      {
      struct TS {
            int numerator;
            int denominator;
            TimeSigType type;
            QString name;
            };

      TS tsList[] = {
            { 2,  4, TimeSigType::NORMAL, "2/4" },
            { 3,  4, TimeSigType::NORMAL, "3/4" },
            { 4,  4, TimeSigType::NORMAL, "4/4" },
            { 5,  4, TimeSigType::NORMAL, "5/4" },
            { 6,  4, TimeSigType::NORMAL, "6/4" },
            { 3,  8, TimeSigType::NORMAL, "3/8" },
            { 6,  8, TimeSigType::NORMAL, "6/8" },
            { 7,  8, TimeSigType::NORMAL, "7/8" },
            { 9,  8, TimeSigType::NORMAL, "9/8" },
            { 12, 8, TimeSigType::NORMAL, "12/8" },
            { 4,  4, TimeSigType::FOUR_FOUR,  QT_TRANSLATE_NOOP("Palette", "4/4 common time") },
            { 2,  2, TimeSigType::ALLA_BREVE, QT_TRANSLATE_NOOP("Palette", "2/2 alla breve") }
            };

      PalettePanel* sp = new PalettePanel(PalettePanel::Type::TimeSig);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Time Signatures"));
      sp->setMag(.8);
      sp->setGrid(42, 38);

      for (unsigned i = 0; i < sizeof(tsList)/sizeof(*tsList); ++i) {
            TimeSig* ts;
            ts = new TimeSig(gscore);
            ts->setSig(Fraction(tsList[i].numerator, tsList[i].denominator), tsList[i].type);
            sp->append(ts, tsList[i].name);
            }
      return sp;
      }

//-----------------------------------
//    newFretboardDiagramPalettePanel
//-----------------------------------

PalettePanel* MuseScore::newFretboardDiagramPalettePanel()
      {
      PalettePanel* sp = new PalettePanel(PalettePanel::Type::FretboardDiagram);
      sp->setName(QT_TRANSLATE_NOOP("Palette", "Fretboard Diagrams"));
      sp->setGrid(42, 45);
      sp->setDrawGrid(true);

      FretDiagram* fret = FretDiagram::fromString(gscore, "X32O1O");
      fret->setHarmony("C");
      sp->append(fret, "C");
      fret = FretDiagram::fromString(gscore, "X-554-");
      fret->setHarmony("Cm");
      sp->append(fret, "Cm");
      fret = FretDiagram::fromString(gscore, "X3231O");
      fret->setHarmony("C7");
      sp->append(fret, "C7");

      fret = FretDiagram::fromString(gscore, "XXO232");
      fret->setHarmony("D");
      sp->append(fret, "D");
      fret = FretDiagram::fromString(gscore, "XXO231");
      fret->setHarmony("Dm");
      sp->append(fret, "Dm");
      fret = FretDiagram::fromString(gscore, "XXO212");
      fret->setHarmony("D7");
      sp->append(fret, "D7");

      fret = FretDiagram::fromString(gscore, "O221OO");
      fret->setHarmony("E");
      sp->append(fret, "E");
      fret = FretDiagram::fromString(gscore, "O22OOO");
      fret->setHarmony("Em");
      sp->append(fret, "Em");
      fret = FretDiagram::fromString(gscore, "O2O1OO");
      fret->setHarmony("E7");
      sp->append(fret, "E7");

      fret = FretDiagram::fromString(gscore, "-332--");
      fret->setHarmony("F");
      sp->append(fret, "F");
      fret = FretDiagram::fromString(gscore, "-33---");
      fret->setHarmony("Fm");
      sp->append(fret, "Fm");
      fret = FretDiagram::fromString(gscore, "-3-2--");
      fret->setHarmony("F7");
      sp->append(fret, "F7");

      fret = FretDiagram::fromString(gscore, "32OOO3");
      fret->setHarmony("G");
      sp->append(fret, "G");
      fret = FretDiagram::fromString(gscore, "-55---");
      fret->setHarmony("Gm");
      sp->append(fret, "Gm");
      fret = FretDiagram::fromString(gscore, "32OOO1");
      fret->setHarmony("G7");
      sp->append(fret, "G7");

      fret = FretDiagram::fromString(gscore, "XO222O");
      fret->setHarmony("A");
      sp->append(fret, "A");
      fret = FretDiagram::fromString(gscore, "XO221O");
      fret->setHarmony("Am");
      sp->append(fret, "Am");
      fret = FretDiagram::fromString(gscore, "XO2O2O");
      fret->setHarmony("A7");
      sp->append(fret, "A7");

      fret = FretDiagram::fromString(gscore, "X-444-");
      fret->setHarmony("B");
      sp->append(fret, "B");
      fret = FretDiagram::fromString(gscore, "X-443-");
      fret->setHarmony("Bm");
      sp->append(fret, "Bm");
      fret = FretDiagram::fromString(gscore, "X212O2");
      fret->setHarmony("B7");
      sp->append(fret, "B7");

      return sp;
      }
//########END DEBUG: new palettes #########################

//---------------------------------------------------------
//   setDefaultPalette
//---------------------------------------------------------

void MuseScore::setDefaultPalette()
      {
      std::unique_ptr<PaletteTree> defaultPalette(new PaletteTree);

      defaultPalette->append(newClefsPalettePanel(true));
      defaultPalette->append(newKeySigPalettePanel());
      defaultPalette->append(newTimePalettePanel());
      defaultPalette->append(newBracketsPalettePanel());
      defaultPalette->append(newAccidentalsPalettePanel(true));
      defaultPalette->append(newArticulationsPalettePanel());
      defaultPalette->append(newOrnamentsPalettePanel());
      defaultPalette->append(newBreathPalettePanel());
      defaultPalette->append(newGraceNotePalettePanel());
      defaultPalette->append(newNoteHeadsPalettePanel());
      defaultPalette->append(newLinesPalettePanel());
      defaultPalette->append(newBarLinePalettePanel());
      defaultPalette->append(newArpeggioPalettePanel());
      defaultPalette->append(newTremoloPalettePanel());
      defaultPalette->append(newTextPalettePanel(true));
      defaultPalette->append(newTempoPalettePanel(true));
      defaultPalette->append(newDynamicsPalettePanel(true));
      defaultPalette->append(newFingeringPalettePanel());
      defaultPalette->append(newRepeatsPalettePanel());
      defaultPalette->append(newFretboardDiagramPalettePanel());
      defaultPalette->append(newAccordionPalettePanel());
      defaultPalette->append(newBagpipeEmbellishmentPalettePanel());
      defaultPalette->append(newBreaksPalettePanel());
      defaultPalette->append(newFramePalettePanel());
      defaultPalette->append(newBeamPalettePanel());

      mscore->getPaletteWorkspace()->setUserPaletteTree(std::move(defaultPalette));
      }

//---------------------------------------------------------
//   addTempo
//---------------------------------------------------------

void MuseScore::addTempo()
      {
      ChordRest* cr = cs->getSelectedChordRest();
      if (!cr)
            return;
//      double bps = 2.0;

      SigEvent event = cs->sigmap()->timesig(cr->tick());
      Fraction f = event.nominal();
      QString text("<sym>metNoteQuarterUp</sym> = 80");
      switch (f.denominator()) {
            case 1:
                  text = "<sym>metNoteWhole</sym> = 80";
                  break;
            case 2:
                  text = "<sym>metNoteHalfUp</sym> = 80";
                  break;
            case 4:
                  text = "<sym>metNoteQuarterUp</sym> = 80";
                  break;
            case 8:
                  if(f.numerator() % 3 == 0)
                        text = "<sym>metNoteQuarterUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = 80";
                  else
                        text = "<sym>metNote8thUp</sym> = 80";
                  break;
            case 16:
                  if(f.numerator() % 3 == 0)
                        text = "<sym>metNote8thUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = 80";
                  else
                        text = "<sym>metNote16thUp</sym> = 80";
                  break;
            case 32:
                  if(f.numerator() % 3 == 0)
                        text = "<sym>metNote16thUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = 80";
                  else
                        text = "<sym>metNote32ndUp</sym> = 80";
                  break;
            case 64:
                  if(f.numerator() % 3 == 0)
                        text = "<sym>metNote32ndUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = 80";
                  else
                        text = "<sym>metNote64thUp</sym> = 80";
                  break;
            default:
                  break;
            }

      TempoText* tt = new TempoText(cs);
      cs->startCmd();
      tt->setParent(cr->segment());
      tt->setTrack(0);
      tt->setXmlText(text);
      tt->setFollowText(true);
      //tt->setTempo(bps);
      cs->undoAddElement(tt);
      cs->select(tt, SelectType::SINGLE, 0);
      cs->endCmd();
      Measure* m = tt->findMeasure();
      if (m && m->hasMMRest() && tt->links()) {
            Measure* mmRest = m->mmRest();
            for (ScoreElement* se : *tt->links()) {
                  TempoText* tt1 = toTempoText(se);
                  if (tt != tt1 && tt1->findMeasure() == mmRest) {
                        tt = tt1;
                        break;
                        }
                  }
            }
      cv->startEditMode(tt);
      }

//---------------------------------------------------------
//   smuflRanges
//    read smufl ranges.json file
//---------------------------------------------------------

QMap<QString, QStringList>* smuflRanges()
      {
      static QMap<QString, QStringList> ranges;
      QStringList allSymbols;

      if (ranges.empty()) {
            QFile fi(":fonts/smufl/ranges.json");
            if (!fi.open(QIODevice::ReadOnly))
                  qDebug("ScoreFont: open ranges file <%s> failed", qPrintable(fi.fileName()));
            QJsonParseError error;
            QJsonObject o = QJsonDocument::fromJson(fi.readAll(), &error).object();
            if (error.error != QJsonParseError::NoError)
                  qDebug("Json parse error in <%s>(offset: %d): %s", qPrintable(fi.fileName()),
                     error.offset, qPrintable(error.errorString()));

            for (auto s : o.keys()) {
                  QJsonObject range = o.value(s).toObject();
                  QString desc      = range.value("description").toString();
                  QJsonArray glyphs = range.value("glyphs").toArray();
                  if (glyphs.size() > 0) {
                        QStringList glyphNames;
                        for (QJsonValue g : glyphs)
                              glyphNames.append(g.toString());
                        ranges.insert(desc, glyphNames);
                        allSymbols << glyphNames;
                        }
                  }
            ranges.insert(SMUFL_ALL_SYMBOLS, allSymbols); // TODO: make translatable as well as ranges.json
            }
      return &ranges;
      }
}