1 //=============================================================================
2 // MuseScore
3 // Linux Music Score Editor
4 //
5 // Copyright (C) 2002-2016 Werner Schweer and others
6 //
7 // This program is free software; you can redistribute it and/or modify
8 // it under the terms of the GNU General Public License version 2.
9 //
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with this program; if not, write to the Free Software
17 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 //=============================================================================
19
20 // For menus in the menu bar, like File, Edit, and View, see mscore/musescore.cpp
21
22 #include "menus.h"
23 #include <tuple>
24 #include "libmscore/score.h"
25 #include "palette.h"
26 #include "libmscore/note.h"
27 #include "libmscore/chordrest.h"
28 #include "libmscore/dynamic.h"
29 #include "libmscore/slur.h"
30 #include "libmscore/sym.h"
31 #include "libmscore/hairpin.h"
32 #include "scoreview.h"
33 #include "musescore.h"
34 #include "libmscore/select.h"
35 #include "libmscore/tempo.h"
36 #include "libmscore/segment.h"
37 #include "libmscore/undo.h"
38 #include "icons.h"
39 #include "libmscore/bracket.h"
40 #include "libmscore/ottava.h"
41 #include "libmscore/textline.h"
42 #include "libmscore/trill.h"
43 #include "libmscore/pedal.h"
44 #include "libmscore/clef.h"
45 #include "libmscore/timesig.h"
46 #include "libmscore/barline.h"
47 #include "libmscore/layoutbreak.h"
48 #include "symboldialog.h"
49 #include "libmscore/volta.h"
50 #include "libmscore/keysig.h"
51 #include "libmscore/breath.h"
52 #include "libmscore/arpeggio.h"
53 #include "libmscore/tremolo.h"
54 #include "libmscore/repeat.h"
55 #include "libmscore/tempotext.h"
56 #include "libmscore/glissando.h"
57 #include "libmscore/articulation.h"
58 #include "libmscore/chord.h"
59 #include "libmscore/drumset.h"
60 #include "libmscore/spacer.h"
61 #include "libmscore/measure.h"
62 #include "libmscore/fret.h"
63 #include "libmscore/staffstate.h"
64 #include "libmscore/fingering.h"
65 #include "libmscore/bend.h"
66 #include "libmscore/tremolobar.h"
67 #include "libmscore/chordline.h"
68 #include "libmscore/stafftext.h"
69 #include "libmscore/systemtext.h"
70 #include "libmscore/instrchange.h"
71 #include "workspace.h"
72 #include "libmscore/icon.h"
73 #include "libmscore/accidental.h"
74 #include "libmscore/harmony.h"
75 #include "libmscore/rehearsalmark.h"
76 #include "shortcut.h"
77 #include "libmscore/marker.h"
78 #include "libmscore/jump.h"
79 #include "libmscore/bagpembell.h"
80 #include "libmscore/ambitus.h"
81 #include "libmscore/stafftypechange.h"
82 #include "libmscore/letring.h"
83 #include "libmscore/vibrato.h"
84 #include "libmscore/palmmute.h"
85 #include "libmscore/fermata.h"
86 #include "libmscore/measurenumber.h"
87
88 #include "palette/palettetree.h"
89 #include "palette/palettewidget.h"
90 #include "palette/paletteworkspace.h"
91 #include "qml/msqmlengine.h"
92
93 namespace Ms {
94
95 extern bool useFactorySettings;
96
toPalette(PalettePanel * pp)97 static Palette* toPalette(PalettePanel* pp)
98 {
99 return new Palette(std::unique_ptr<PalettePanel>(pp));
100 }
101
102 //---------------------------------------------------------
103 // populateIconPalette
104 //---------------------------------------------------------
105
populateIconPalette(Palette * p,const IconAction * a)106 void populateIconPalette(Palette* p, const IconAction* a)
107 {
108 while (a->subtype != IconType::NONE) {
109 Icon* ik = new Icon(gscore);
110 ik->setIconType(a->subtype);
111 const Shortcut* s = Shortcut::getShortcut(a->action);
112 QAction* action = s->action();
113 QIcon icon(action->icon());
114 ik->setAction(a->action, icon);
115 p->append(ik, s->help());
116 ++a;
117 }
118 }
119
120 //---------------------------------------------------------
121 // newBeamPalette
122 //---------------------------------------------------------
123
newBeamPalette()124 Palette* MuseScore::newBeamPalette()
125 {
126 return toPalette(newBeamPalettePanel());
127 }
128
129 //---------------------------------------------------------
130 // newFramePalette
131 //---------------------------------------------------------
132
newFramePalette()133 Palette* MuseScore::newFramePalette()
134 {
135 return toPalette(newFramePalettePanel());
136 }
137
138 //---------------------------------------------------------
139 // newDynamicsPalette
140 //---------------------------------------------------------
141
newDynamicsPalette(bool defaultPalette)142 Palette* MuseScore::newDynamicsPalette(bool defaultPalette)
143 {
144 return toPalette(newDynamicsPalettePanel(defaultPalette));
145 }
146
147 //---------------------------------------------------------
148 // newKeySigPalette
149 //---------------------------------------------------------
150
newKeySigPalette()151 Palette* MuseScore::newKeySigPalette()
152 {
153 return toPalette(newKeySigPalettePanel());
154 }
155
156 //---------------------------------------------------------
157 // newAccidentalsPalette
158 //---------------------------------------------------------
159
newAccidentalsPalette(bool defaultPalette)160 Palette* MuseScore::newAccidentalsPalette(bool defaultPalette)
161 {
162 return toPalette(newAccidentalsPalettePanel(defaultPalette));
163 }
164
165 //---------------------------------------------------------
166 // newBarLinePalette
167 //---------------------------------------------------------
168
newBarLinePalette()169 Palette* MuseScore::newBarLinePalette()
170 {
171 return toPalette(newBarLinePalettePanel());
172 }
173
174 //---------------------------------------------------------
175 // newRepeatsPalette
176 //---------------------------------------------------------
177
newRepeatsPalette()178 Palette* MuseScore::newRepeatsPalette()
179 {
180 return toPalette(newRepeatsPalettePanel());
181 }
182
183 //---------------------------------------------------------
184 // newBreaksPalette
185 //---------------------------------------------------------
186
newBreaksPalette()187 Palette* MuseScore::newBreaksPalette()
188 {
189 return toPalette(newBreaksPalettePanel());
190 }
191
192 //---------------------------------------------------------
193 // newFingeringPalette
194 //---------------------------------------------------------
195
newFingeringPalette()196 Palette* MuseScore::newFingeringPalette()
197 {
198 return toPalette(newFingeringPalettePanel());
199 }
200
201 //---------------------------------------------------------
202 // newTremoloPalette
203 //---------------------------------------------------------
204
newTremoloPalette()205 Palette* MuseScore::newTremoloPalette()
206 {
207 return toPalette(newTremoloPalettePanel());
208 }
209
210 //---------------------------------------------------------
211 // newNoteHeadsPalette
212 //---------------------------------------------------------
213
newNoteHeadsPalette()214 Palette* MuseScore::newNoteHeadsPalette()
215 {
216 return toPalette(newNoteHeadsPalettePanel());
217 }
218
219 //---------------------------------------------------------
220 // newArticulationsPalette
221 //---------------------------------------------------------
222
newArticulationsPalette()223 Palette* MuseScore::newArticulationsPalette()
224 {
225 return toPalette(newArticulationsPalettePanel());
226 }
227
228 //---------------------------------------------------------
229 // newOrnamentsPalette
230 //---------------------------------------------------------
231
newOrnamentsPalette()232 Palette* MuseScore::newOrnamentsPalette()
233 {
234 return toPalette(newOrnamentsPalettePanel());
235 }
236
237 //---------------------------------------------------------
238 // newAccordionPalette
239 //---------------------------------------------------------
240
newAccordionPalette()241 Palette* MuseScore::newAccordionPalette()
242 {
243 return toPalette(newAccordionPalettePanel());
244 }
245
246 //---------------------------------------------------------
247 // newBracketsPalette
248 //---------------------------------------------------------
249
newBracketsPalette()250 Palette* MuseScore::newBracketsPalette()
251 {
252 return toPalette(newBracketsPalettePanel());
253 }
254
255 //---------------------------------------------------------
256 // newBreathPalette
257 //---------------------------------------------------------
258
newBreathPalette()259 Palette* MuseScore::newBreathPalette()
260 {
261 return toPalette(newBreathPalettePanel());
262 }
263
264 //---------------------------------------------------------
265 // newArpeggioPalette
266 //---------------------------------------------------------
267
newArpeggioPalette()268 Palette* MuseScore::newArpeggioPalette()
269 {
270 return toPalette(newArpeggioPalettePanel());
271 }
272
273 //---------------------------------------------------------
274 // newClefsPalette
275 //---------------------------------------------------------
276
newClefsPalette(bool defaultPalette)277 Palette* MuseScore::newClefsPalette(bool defaultPalette)
278 {
279 return toPalette(newClefsPalettePanel(defaultPalette));
280 }
281
282 //---------------------------------------------------------
283 // newGraceNotePalette
284 //---------------------------------------------------------
285
newGraceNotePalette()286 Palette* MuseScore::newGraceNotePalette()
287 {
288 return toPalette(newGraceNotePalettePanel());
289 }
290
291 //---------------------------------------------------------
292 // newBagpipeEmbellishmentPalette
293 //---------------------------------------------------------
294
newBagpipeEmbellishmentPalette()295 Palette* MuseScore::newBagpipeEmbellishmentPalette()
296 {
297 return toPalette(newBagpipeEmbellishmentPalettePanel());
298 }
299
300 //---------------------------------------------------------
301 // newLinesPalette
302 //---------------------------------------------------------
303
newLinesPalette()304 Palette* MuseScore::newLinesPalette()
305 {
306 return toPalette(newLinesPalettePanel());
307 }
308
309 //---------------------------------------------------------
310 // showPalette
311 //---------------------------------------------------------
312
showPalette(bool visible)313 void MuseScore::showPalette(bool visible)
314 {
315 QAction* a = getAction("toggle-palette");
316 if (!paletteWidget) {
317 WorkspacesManager::currentWorkspace()->read();
318 preferencesChanged();
319 updateIcons();
320
321 paletteWidget = new PaletteWidget(getPaletteWorkspace(), getQmlUiEngine(), this);
322 a = getAction("toggle-palette");
323 connect(paletteWidget, &PaletteWidget::visibilityChanged, a, &QAction::setChecked);
324 addDockWidget(Qt::LeftDockWidgetArea, paletteWidget);
325 }
326 reDisplayDockWidget(paletteWidget, visible);
327 a->setChecked(visible);
328 }
329
330 //---------------------------------------------------------
331 // TempoPattern
332 //---------------------------------------------------------
333
334 struct TempoPattern {
335 QString pattern;
336 const char* name;
337 double f;
338 bool relative;
339 bool italian;
340 bool followText;
341 bool basic;
342 bool masterOnly;
343
TempoPatternMs::TempoPattern344 TempoPattern(const QString& s, const char* n, double v, bool r, bool i, bool f, bool b, bool m) : pattern(s), name(n), f(v), relative(r), italian(i), followText(f), basic(b), masterOnly(m) {}
345 };
346
347 //---------------------------------------------------------
348 // newTempoPalette
349 //---------------------------------------------------------
350
newTempoPalette(bool defaultPalette)351 Palette* MuseScore::newTempoPalette(bool defaultPalette)
352 {
353 return toPalette(newTempoPalettePanel(defaultPalette));
354 }
355
356 //---------------------------------------------------------
357 // newTextPalette
358 //---------------------------------------------------------
359
newTextPalette(bool defaultPalette)360 Palette* MuseScore::newTextPalette(bool defaultPalette)
361 {
362 return toPalette(newTextPalettePanel(defaultPalette));
363 }
364
365 //---------------------------------------------------------
366 // newTimePalette
367 // create default time signature palette
368 //---------------------------------------------------------
369
newTimePalette()370 Palette* MuseScore::newTimePalette()
371 {
372 return toPalette(newTimePalettePanel());
373 }
374
375 //---------------------------------------------------------
376 // newFretboardDiagramPalette
377 //---------------------------------------------------------
378
newFretboardDiagramPalette()379 Palette* MuseScore::newFretboardDiagramPalette()
380 {
381 return toPalette(newFretboardDiagramPalettePanel());
382 }
383
384 //---------------------------------------------------------
385 // newMasterPaletteTree
386 //---------------------------------------------------------
387
newMasterPaletteTree()388 PaletteTree* MuseScore::newMasterPaletteTree()
389 {
390 PaletteTree* tree = new PaletteTree();
391
392 tree->append(MuseScore::newClefsPalettePanel());
393 tree->append(MuseScore::newKeySigPalettePanel());
394 tree->append(MuseScore::newTimePalettePanel());
395
396 tree->append(MuseScore::newBracketsPalettePanel());
397 tree->append(MuseScore::newAccidentalsPalettePanel());
398 tree->append(MuseScore::newArticulationsPalettePanel());
399 tree->append(MuseScore::newOrnamentsPalettePanel());
400 tree->append(MuseScore::newBreathPalettePanel());
401 tree->append(MuseScore::newGraceNotePalettePanel());
402 tree->append(MuseScore::newNoteHeadsPalettePanel());
403 tree->append(MuseScore::newLinesPalettePanel());
404 tree->append(MuseScore::newBarLinePalettePanel());
405 tree->append(MuseScore::newArpeggioPalettePanel());
406 tree->append(MuseScore::newTremoloPalettePanel());
407 tree->append(MuseScore::newTextPalettePanel());
408 tree->append(MuseScore::newTempoPalettePanel());
409 tree->append(MuseScore::newDynamicsPalettePanel());
410 tree->append(MuseScore::newFingeringPalettePanel());
411 tree->append(MuseScore::newRepeatsPalettePanel());
412 tree->append(MuseScore::newFretboardDiagramPalettePanel());
413 tree->append(MuseScore::newAccordionPalettePanel());
414 tree->append(MuseScore::newBagpipeEmbellishmentPalettePanel());
415 tree->append(MuseScore::newBreaksPalettePanel());
416 tree->append(MuseScore::newFramePalettePanel());
417 tree->append(MuseScore::newBeamPalettePanel());
418
419 return tree;
420 }
421
422 //---------------------------------------------------------
423 // populateIconPalettePanel
424 //---------------------------------------------------------
425
populateIconPalettePanel(PalettePanel * p,const IconAction * a)426 static void populateIconPalettePanel(PalettePanel* p, const IconAction* a)
427 {
428 while (a->subtype != IconType::NONE) {
429 Icon* ik = new Icon(gscore);
430 ik->setIconType(a->subtype);
431 const Shortcut* s = Shortcut::getShortcut(a->action);
432 QAction* action = s->action();
433 QIcon icon(action->icon());
434 ik->setAction(a->action, icon);
435 p->append(ik, s->help());
436 ++a;
437 }
438 }
439
440 //---------------------------------------------------------
441 // newBeamPalettePanel
442 //---------------------------------------------------------
443
newBeamPalettePanel()444 PalettePanel* MuseScore::newBeamPalettePanel()
445 {
446 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Beam);
447 sp->setName(QT_TRANSLATE_NOOP("Palette", "Beam Properties"));
448 sp->setGrid(27, 40);
449 sp->setDrawGrid(true);
450
451 const IconAction bpa[] = {
452 { IconType::SBEAM, "beam-start" },
453 { IconType::MBEAM, "beam-mid" },
454 { IconType::NBEAM, "no-beam" },
455 { IconType::BEAM32, "beam32" },
456 { IconType::BEAM64, "beam64" },
457 { IconType::AUTOBEAM, "auto-beam" },
458 { IconType::FBEAM1, "fbeam1" },
459 { IconType::FBEAM2, "fbeam2" },
460 { IconType::NONE, ""}
461 };
462
463 populateIconPalettePanel(sp, bpa);
464 return sp;
465 }
466
467 //---------------------------------------------------------
468 // newFramePalettePanel
469 //---------------------------------------------------------
470
newFramePalettePanel()471 PalettePanel* MuseScore::newFramePalettePanel()
472 {
473 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Frame);
474 sp->setName(QT_TRANSLATE_NOOP("Palette", "Frames & Measures"));
475 sp->setGrid(27, 40);
476 sp->setDrawGrid(true);
477
478 if (enableExperimental) {
479 static const IconAction bpa[] = {
480 { IconType::VFRAME, "insert-vbox" },
481 { IconType::HFRAME, "insert-hbox" },
482 { IconType::TFRAME, "insert-textframe" },
483 { IconType::FFRAME, "insert-fretframe" }, // experimental
484 { IconType::MEASURE, "insert-measure" },
485 { IconType::NONE, ""}
486 };
487 populateIconPalettePanel(sp, bpa);
488 }
489 else {
490 static const IconAction bpa[] = {
491 { IconType::VFRAME, "insert-vbox" },
492 { IconType::HFRAME, "insert-hbox" },
493 { IconType::TFRAME, "insert-textframe" },
494 { IconType::MEASURE, "insert-measure" },
495 { IconType::NONE, ""}
496 };
497 populateIconPalettePanel(sp, bpa);
498 }
499
500 return sp;
501 }
502
503 //---------------------------------------------------------
504 // newDynamicsPalettePanel
505 //---------------------------------------------------------
506
newDynamicsPalettePanel(bool defaultPalettePanel)507 PalettePanel* MuseScore::newDynamicsPalettePanel(bool defaultPalettePanel)
508 {
509 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Dynamic);
510 sp->setName(QT_TRANSLATE_NOOP("Palette", "Dynamics"));
511 sp->setMag(.8);
512 sp->setDrawGrid(true);
513
514 static const std::vector<const char*> array1 = {
515 "pppppp", "ppppp", "pppp",
516 "ppp", "pp", "p", "mp", "mf", "f", "ff", "fff",
517 "ffff", "fffff", "ffffff",
518 "fp", "pf", "sf", "sfz", "sff", "sffz", "sfp", "sfpp",
519 "rfz", "rf", "fz", "m", "r", "s", "z", "n"
520 };
521 static const std::vector<const char*> arrayDefault = {
522 "ppp", "pp", "p", "mp", "mf", "f", "ff", "fff",
523 "fp", "pf", "sf", "sfz", "sff", "sffz", "sfp", "sfpp",
524 "rfz", "rf", "fz", "m", "r", "s", "z", "n"
525 };
526
527 const std::vector<const char*>* array = nullptr;
528 if (defaultPalettePanel) {
529 array = &arrayDefault;
530 sp->setGrid(42, 28);
531 sp->setMoreElements(true);
532 }
533 else {
534 array = &array1;
535 sp->setGrid(60, 28);
536 }
537
538 for (const char* c : *array) {
539 Dynamic* dynamic = new Dynamic(gscore);
540 dynamic->setDynamicType(c);
541 sp->append(dynamic, dynamic->dynamicTypeName());
542 }
543 return sp;
544 }
545
546 //---------------------------------------------------------
547 // newKeySigPalettePanel
548 //---------------------------------------------------------
549
newKeySigPalettePanel()550 PalettePanel* MuseScore::newKeySigPalettePanel()
551 {
552 PalettePanel* sp = new PalettePanel(PalettePanel::Type::KeySig);
553 sp->setName(QT_TRANSLATE_NOOP("Palette", "Key Signatures"));
554 sp->setMag(1.0);
555 sp->setGrid(56, 55);
556 sp->setYOffset(1.0);
557
558 for (int i = 0; i < 7; ++i) {
559 KeySig* k = new KeySig(gscore);
560 k->setKey(Key(i + 1));
561 sp->append(k, keyNames[i*2]);
562 }
563 for (int i = -7; i < 0; ++i) {
564 KeySig* k = new KeySig(gscore);
565 k->setKey(Key(i));
566 sp->append(k, keyNames[(7 + i) * 2 + 1]);
567 }
568 KeySig* k = new KeySig(gscore);
569 k->setKey(Key::C);
570 sp->append(k, keyNames[14]);
571
572 // atonal key signature
573 KeySigEvent nke;
574 nke.setKey(Key::C);
575 nke.setCustom(true);
576 nke.setMode(KeyMode::NONE);
577 KeySig* nk = new KeySig(gscore);
578 nk->setKeySigEvent(nke);
579 sp->append(nk, keyNames[15]);
580
581 return sp;
582 }
583
584 //---------------------------------------------------------
585 // newAccidentalsPalettePanel
586 //---------------------------------------------------------
587
newAccidentalsPalettePanel(bool defaultPalettePanel)588 PalettePanel* MuseScore::newAccidentalsPalettePanel(bool defaultPalettePanel)
589 {
590 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Accidental);
591 sp->setName(QT_TRANSLATE_NOOP("Palette", "Accidentals"));
592 sp->setGrid(33, 36);
593 sp->setDrawGrid(true);
594
595 int end = 0;
596 if (defaultPalettePanel)
597 end = int(AccidentalType::SHARP_SHARP);
598 else
599 end = int(AccidentalType::END);
600
601 Accidental* a = new Accidental(gscore);
602 a->setAccidentalType(AccidentalType::NONE);
603 sp->append(a, a->subtypeUserName());
604 for (int i = int(AccidentalType::FLAT); i < end; ++i) {
605 Accidental* ac = new Accidental(gscore);
606 ac->setAccidentalType(AccidentalType(i));
607 if (ac->symbol() != SymId::noSym)
608 sp->append(ac, ac->subtypeUserName());
609 else
610 delete ac;
611 }
612
613 if (defaultPalettePanel) {
614 sp->setMoreElements(true);
615 }
616
617 Icon* ik = new Icon(gscore);
618 ik->setIconType(IconType::BRACKETS);
619 const Shortcut* s = Shortcut::getShortcut("add-brackets");
620 QAction* action = s->action();
621 ik->setAction(QByteArray("add-brackets"), action->icon());
622 sp->append(ik, s->help());
623
624 ik = new Icon(gscore);
625 ik->setIconType(IconType::PARENTHESES);
626 s = Shortcut::getShortcut("add-parentheses");
627 action = s->action();
628 ik->setAction(QByteArray("add-parentheses"), action->icon());
629 sp->append(ik, s->help());
630
631 ik = new Icon(gscore);
632 ik->setIconType(IconType::BRACES);
633 s = Shortcut::getShortcut("add-braces");
634 action = s->action();
635 ik->setAction(QByteArray("add-braces"), action->icon());
636 sp->append(ik, s->help());
637 return sp;
638 }
639
640 //---------------------------------------------------------
641 // newBarLinePalettePanel
642 //---------------------------------------------------------
643
newBarLinePalettePanel()644 PalettePanel* MuseScore::newBarLinePalettePanel()
645 {
646 PalettePanel* sp = new PalettePanel(PalettePanel::Type::BarLine);
647 sp->setName(QT_TRANSLATE_NOOP("Palette", "Barlines"));
648 sp->setMag(0.8);
649 sp->setGrid(42, 38);
650
651 // bar line styles
652 for (unsigned i = 0;; ++i) {
653 const BarLineTableItem* bti = BarLine::barLineTableItem(i);
654 if (!bti)
655 break;
656 BarLine* b = new BarLine(gscore);
657 b->setBarLineType(bti->type);
658 sp->append(b, BarLine::userTypeName(bti->type));
659 }
660
661 // bar line spans
662 struct {
663 int from, to;
664 const char* userName;
665 } spans[] = {
666 { BARLINE_SPAN_TICK1_FROM, BARLINE_SPAN_TICK1_TO, Sym::symUserNames[int(SymId::barlineDashed)] },
667 { BARLINE_SPAN_TICK2_FROM, BARLINE_SPAN_TICK2_TO, QT_TRANSLATE_NOOP("symUserNames", "Tick barline 2") }, // Not in SMuFL
668 { BARLINE_SPAN_SHORT1_FROM, BARLINE_SPAN_SHORT1_TO, Sym::symUserNames[int(SymId::barlineShort)] },
669 { BARLINE_SPAN_SHORT2_FROM, BARLINE_SPAN_SHORT2_TO, QT_TRANSLATE_NOOP("symUserNames", "Short barline 2") }, // Not in SMuFL
670 };
671 for (auto span : spans) {
672 BarLine* b = new BarLine(gscore);
673 b->setBarLineType(BarLineType::NORMAL);
674 b->setSpanFrom(span.from);
675 b->setSpanTo(span.to);
676 sp->append(b, span.userName);
677 }
678 return sp;
679 }
680
681 //---------------------------------------------------------
682 // newRepeatsPalettePanel
683 //---------------------------------------------------------
684
newRepeatsPalettePanel()685 PalettePanel* MuseScore::newRepeatsPalettePanel()
686 {
687 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Repeat);
688 sp->setName(QT_TRANSLATE_NOOP("Palette", "Repeats & Jumps"));
689 sp->setMag(0.65);
690 sp->setGrid(75, 28);
691 sp->setDrawGrid(true);
692
693 RepeatMeasure* rm = new RepeatMeasure(gscore);
694 sp->append(rm, qApp->translate("symUserNames", Sym::symUserNames[int(SymId::repeat1Bar)]));
695
696 for (int i = 0; i < markerTypeTableSize(); i++) {
697 if (markerTypeTable[i].type == Marker::Type::CODETTA) // not in SMuFL
698 continue;
699
700 Marker* mk = new Marker(gscore);
701 mk->setMarkerType(markerTypeTable[i].type);
702 mk->styleChanged();
703 sp->append(mk, markerTypeTable[i].name);
704 }
705
706 for (int i = 0; i < jumpTypeTableSize(); i++) {
707 Jump* jp = new Jump(gscore);
708 jp->setJumpType(jumpTypeTable[i].type);
709 sp->append(jp, jumpTypeTable[i].userText);
710 }
711
712 for (unsigned i = 0;; ++i) {
713 const BarLineTableItem* bti = BarLine::barLineTableItem(i);
714 if (!bti)
715 break;
716 switch (bti->type) {
717 case BarLineType::START_REPEAT:
718 case BarLineType::END_REPEAT:
719 case BarLineType::END_START_REPEAT:
720 break;
721 default:
722 continue;
723 }
724
725 BarLine* b = new BarLine(gscore);
726 b->setBarLineType(bti->type);
727 PaletteCell* cell = sp->append(b, BarLine::userTypeName(bti->type));
728 cell->drawStaff = false;
729 }
730
731 return sp;
732 }
733
734 //---------------------------------------------------------
735 // newBreaksPalettePanel
736 //---------------------------------------------------------
737
newBreaksPalettePanel()738 PalettePanel* MuseScore::newBreaksPalettePanel()
739 {
740 qreal _spatium = gscore->spatium();
741 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Break);
742 sp->setName(QT_TRANSLATE_NOOP("Palette", "Breaks & Spacers"));
743 sp->setMag(1.0);
744 sp->setGrid(42, 36);
745 sp->setDrawGrid(true);
746
747 struct BreakItem {
748 LayoutBreak b;
749 };
750 LayoutBreak* lb = new LayoutBreak(gscore);
751 lb->setLayoutBreakType(LayoutBreak::Type::LINE);
752 PaletteCell* cell = sp->append(lb, QT_TRANSLATE_NOOP("Palette", "System break"));
753 cell->mag = 1.2;
754
755 lb = new LayoutBreak(gscore);
756 lb->setLayoutBreakType(LayoutBreak::Type::PAGE);
757 cell = sp->append(lb, QT_TRANSLATE_NOOP("Palette", "Page break"));
758 cell->mag = 1.2;
759
760 lb = new LayoutBreak(gscore);
761 lb->setLayoutBreakType(LayoutBreak::Type::SECTION);
762 cell = sp->append(lb, QT_TRANSLATE_NOOP("Palette", "Section break"));
763 cell->mag = 1.2;
764
765 #if 0
766 lb = new LayoutBreak(gscore);
767 lb->setLayoutBreakType(LayoutBreak::Type::NOBREAK);
768 cell = sp->append(lb, QT_TRANSLATE_NOOP("Palette", "Don't break"));
769 cell->mag = 1.2;
770 #endif
771
772 Spacer* spacer = new Spacer(gscore);
773 spacer->setSpacerType(SpacerType::DOWN);
774 spacer->setGap(3 * _spatium);
775 cell = sp->append(spacer, QT_TRANSLATE_NOOP("Palette", "Staff spacer down"));
776 cell->mag = .7;
777
778 spacer = new Spacer(gscore);
779 spacer->setSpacerType(SpacerType::UP);
780 spacer->setGap(3 * _spatium);
781 cell = sp->append(spacer, QT_TRANSLATE_NOOP("Palette", "Staff spacer up"));
782 cell->mag = .7;
783
784 spacer = new Spacer(gscore);
785 spacer->setSpacerType(SpacerType::FIXED);
786 spacer->setGap(3 * _spatium);
787 cell = sp->append(spacer, QT_TRANSLATE_NOOP("Palette", "Staff spacer fixed down"));
788 cell->mag = .7;
789
790 return sp;
791 }
792
793 //---------------------------------------------------------
794 // newFingeringPalettePanel
795 //---------------------------------------------------------
796
newFingeringPalettePanel()797 PalettePanel* MuseScore::newFingeringPalettePanel()
798 {
799 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Fingering);
800 sp->setName(QT_TRANSLATE_NOOP("Palette", "Fingering"));
801 sp->setMag(1.5);
802 sp->setGrid(28, 30);
803 sp->setDrawGrid(true);
804
805 const char* finger = "012345";
806 for (unsigned i = 0; i < strlen(finger); ++i) {
807 Fingering* f = new Fingering(gscore);
808 f->setXmlText(QString(finger[i]));
809 sp->append(f, QT_TRANSLATE_NOOP("Palette", "Fingering %1"));
810 }
811 finger = "pimac";
812 for (unsigned i = 0; i < strlen(finger); ++i) {
813 Fingering* f = new Fingering(gscore, Tid::RH_GUITAR_FINGERING);
814 f->setXmlText(QString(finger[i]));
815 sp->append(f, QT_TRANSLATE_NOOP("Palette", "RH Guitar Fingering %1"));
816 }
817 finger = "012345T";
818 for (unsigned i = 0; i < strlen(finger); ++i) {
819 Fingering* f = new Fingering(gscore, Tid::LH_GUITAR_FINGERING);
820 f->setXmlText(QString(finger[i]));
821 sp->append(f, QT_TRANSLATE_NOOP("Palette", "LH Guitar Fingering %1"));
822 }
823 finger = "0123456";
824 for (unsigned i = 0; i < strlen(finger); ++i) {
825 Fingering* f = new Fingering(gscore, Tid::STRING_NUMBER);
826 f->setXmlText(QString(finger[i]));
827 sp->append(f, QT_TRANSLATE_NOOP("Palette", "String number %1"));
828 }
829
830 static const std::vector<SymId> lute {
831 SymId::stringsThumbPosition,
832 SymId::luteFingeringRHThumb, SymId::luteFingeringRHFirst,
833 SymId::luteFingeringRHSecond, SymId::luteFingeringRHThird
834 };
835 // include additional symbol-based fingerings (temporarily?) implemented as articulations
836 for (auto i : lute) {
837 Articulation* s = new Articulation(i, gscore);
838 sp->append(s, s->userName());
839 }
840 return sp;
841 }
842
843 //---------------------------------------------------------
844 // newTremoloPalettePanel
845 //---------------------------------------------------------
846
newTremoloPalettePanel()847 PalettePanel* MuseScore::newTremoloPalettePanel()
848 {
849 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Tremolo);
850 sp->setName(QT_TRANSLATE_NOOP("Palette", "Tremolos"));
851 sp->setGrid(27, 40);
852 sp->setDrawGrid(true);
853
854 for (int i = int(TremoloType::R8); i <= int(TremoloType::C64); ++i) {
855 Tremolo* tremolo = new Tremolo(gscore);
856 tremolo->setTremoloType(TremoloType(i));
857 sp->append(tremolo, tremolo->subtypeName());
858 }
859 return sp;
860 }
861
862 //---------------------------------------------------------
863 // newNoteHeadsPalettePanel
864 //---------------------------------------------------------
865
newNoteHeadsPalettePanel()866 PalettePanel* MuseScore::newNoteHeadsPalettePanel()
867 {
868 PalettePanel* sp = new PalettePanel(PalettePanel::Type::NoteHead);
869 sp->setName(QT_TRANSLATE_NOOP("Palette", "Noteheads"));
870 sp->setMag(1.3);
871 sp->setGrid(33, 36);
872 sp->setDrawGrid(true);
873
874 for (int i = 0; i < int(NoteHead::Group::HEAD_DO_WALKER); ++i) {
875 SymId sym = Note::noteHead(0, NoteHead::Group(i), NoteHead::Type::HEAD_HALF);
876 // HEAD_BREVIS_ALT shows up only for brevis value
877 if (i == int(NoteHead::Group::HEAD_BREVIS_ALT))
878 sym = Note::noteHead(0, NoteHead::Group(i), NoteHead::Type::HEAD_BREVIS);
879 NoteHead* nh = new NoteHead(gscore);
880 nh->setSym(sym);
881 sp->append(nh, NoteHead::group2userName(NoteHead::Group(i)));
882 }
883 Icon* ik = new Icon(gscore);
884 ik->setIconType(IconType::PARENTHESES);
885 const Shortcut* s = Shortcut::getShortcut("add-parentheses");
886 QAction* action = s->action();
887 QIcon icon(action->icon());
888 ik->setAction("add-parentheses", icon);
889 sp->append(ik, s->help());
890 return sp;
891 }
892
893 //---------------------------------------------------------
894 // newArticulationsPalettePanel
895 //---------------------------------------------------------
896
newArticulationsPalettePanel()897 PalettePanel* MuseScore::newArticulationsPalettePanel()
898 {
899 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Articulation);
900 sp->setName(QT_TRANSLATE_NOOP("Palette", "Articulations"));
901 sp->setGrid(42, 25);
902 sp->setDrawGrid(true);
903
904 // do not include additional symbol-based fingerings (temporarily?) implemented as articulations
905 static const std::vector<SymId> fermatas {
906 SymId::fermataAbove,
907 SymId::fermataShortAbove,
908 SymId::fermataLongAbove,
909 SymId::fermataLongHenzeAbove,
910 SymId::fermataShortHenzeAbove,
911 SymId::fermataVeryLongAbove,
912 SymId::fermataVeryShortAbove,
913 };
914 for (auto i : fermatas) {
915 Fermata* f = new Fermata(i, gscore);
916 sp->append(f, f->userName());
917 }
918 static const std::vector<SymId> art {
919 SymId::articAccentAbove,
920 SymId::articStaccatoAbove,
921 SymId::articStaccatissimoAbove,
922 SymId::articTenutoAbove,
923 SymId::articTenutoStaccatoAbove,
924 SymId::articMarcatoAbove,
925 SymId::articAccentStaccatoAbove,
926 SymId::articLaissezVibrerAbove,
927 SymId::articMarcatoStaccatoAbove,
928 SymId::articMarcatoTenutoAbove,
929 SymId::articStaccatissimoStrokeAbove,
930 SymId::articStaccatissimoWedgeAbove,
931 SymId::articStressAbove,
932 SymId::articTenutoAccentAbove,
933 SymId::articUnstressAbove,
934
935 SymId::articSoftAccentAbove, // supplemental articulations
936 SymId::articSoftAccentStaccatoAbove,
937 SymId::articSoftAccentTenutoAbove,
938 SymId::articSoftAccentTenutoStaccatoAbove,
939
940 SymId::guitarFadeIn,
941 SymId::guitarFadeOut,
942 SymId::guitarVolumeSwell,
943 SymId::wiggleSawtooth,
944 SymId::wiggleSawtoothWide,
945 SymId::wiggleVibratoLargeFaster,
946 SymId::wiggleVibratoLargeSlowest,
947 SymId::brassMuteOpen,
948 SymId::brassMuteClosed,
949 SymId::stringsHarmonic,
950 SymId::stringsUpBow,
951 SymId::stringsDownBow,
952 SymId::pluckedSnapPizzicatoAbove,
953 // SymId::stringsThumbPosition,
954 // SymId::luteFingeringRHThumb,
955 // SymId::luteFingeringRHFirst,
956 // SymId::luteFingeringRHSecond,
957 // SymId::luteFingeringRHThird,
958 };
959 for (auto i : art) {
960 Articulation* s = new Articulation(i, gscore);
961 sp->append(s, s->userName());
962 }
963 Bend* bend = new Bend(gscore);
964 bend->points().append(PitchValue(0, 0, false));
965 bend->points().append(PitchValue(15, 100, false));
966 bend->points().append(PitchValue(60, 100, false));
967 sp->append(bend, QT_TRANSLATE_NOOP("Palette", "Bend"));
968
969 TremoloBar* tb = new TremoloBar(gscore);
970 tb->points().append(PitchValue(0, 0, false)); // "Dip"
971 tb->points().append(PitchValue(30, -100, false));
972 tb->points().append(PitchValue(60, 0, false));
973 sp->append(tb, QT_TRANSLATE_NOOP("Palette", "Tremolo bar"));
974
975 return sp;
976 }
977
978 //---------------------------------------------------------
979 // newOrnamentsPalettePanel
980 //---------------------------------------------------------
981
newOrnamentsPalettePanel()982 PalettePanel* MuseScore::newOrnamentsPalettePanel()
983 {
984 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Ornament);
985 sp->setName(QT_TRANSLATE_NOOP("Palette", "Ornaments"));
986 sp->setGrid(42, 25);
987 sp->setDrawGrid(true);
988
989 // do not include additional symbol-based fingerings (temporarily?) implemented as articulations
990 static const std::vector<SymId> art {
991 SymId::ornamentTurnInverted,
992 SymId::ornamentTurnSlash,
993 SymId::ornamentTurn,
994 SymId::ornamentTrill,
995 SymId::ornamentShortTrill,
996 SymId::ornamentMordent,
997 SymId::ornamentTremblement,
998 SymId::ornamentPrallMordent,
999 SymId::ornamentUpPrall,
1000 SymId::ornamentPrecompMordentUpperPrefix, // SymId::ornamentDownPrall,
1001 SymId::ornamentUpMordent,
1002 SymId::ornamentDownMordent,
1003 SymId::ornamentPrallDown,
1004 SymId::ornamentPrallUp,
1005 SymId::ornamentLinePrall,
1006 SymId::ornamentPrecompSlide,
1007 };
1008 for (auto i : art) {
1009 Articulation* s = new Articulation(i, gscore);
1010 sp->append(s, s->userName());
1011 }
1012 return sp;
1013 }
1014
1015 //---------------------------------------------------------
1016 // newAccordionPalettePanel
1017 //---------------------------------------------------------
1018
newAccordionPalettePanel()1019 PalettePanel* MuseScore::newAccordionPalettePanel()
1020 {
1021 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Accordion);
1022 sp->setName(QT_TRANSLATE_NOOP("Palette", "Accordion"));
1023 sp->setGrid(42, 25);
1024 sp->setDrawGrid(true);
1025
1026 // do not include additional symbol-based fingerings (temporarily?) implemented as articulations
1027 static std::vector<SymId> art {
1028 SymId::accdnCombDot,
1029 SymId::accdnCombLH2RanksEmpty,
1030 SymId::accdnCombLH3RanksEmptySquare,
1031 SymId::accdnCombRH3RanksEmpty,
1032 SymId::accdnCombRH4RanksEmpty,
1033 SymId::accdnDiatonicClef,
1034 SymId::accdnLH2Ranks16Round,
1035 SymId::accdnLH2Ranks8Plus16Round,
1036 SymId::accdnLH2Ranks8Round,
1037 SymId::accdnLH2RanksFullMasterRound,
1038
1039 SymId::accdnLH2RanksMasterPlus16Round,
1040 SymId::accdnLH2RanksMasterRound,
1041 SymId::accdnLH3Ranks2Plus8Square,
1042 SymId::accdnLH3Ranks2Square,
1043 SymId::accdnLH3Ranks8Square,
1044 SymId::accdnLH3RanksDouble8Square,
1045 SymId::accdnLH3RanksTuttiSquare,
1046 SymId::accdnPull,
1047 SymId::accdnPush,
1048 SymId::accdnRH3RanksAccordion,
1049
1050 SymId::accdnRH3RanksAuthenticMusette,
1051 SymId::accdnRH3RanksBandoneon,
1052 SymId::accdnRH3RanksBassoon,
1053 SymId::accdnRH3RanksClarinet,
1054 SymId::accdnRH3RanksDoubleTremoloLower8ve,
1055 SymId::accdnRH3RanksDoubleTremoloUpper8ve,
1056 SymId::accdnRH3RanksFullFactory,
1057 SymId::accdnRH3RanksHarmonium,
1058 SymId::accdnRH3RanksImitationMusette,
1059 SymId::accdnRH3RanksLowerTremolo8,
1060
1061 SymId::accdnRH3RanksMaster,
1062 SymId::accdnRH3RanksOboe,
1063 SymId::accdnRH3RanksOrgan,
1064 SymId::accdnRH3RanksPiccolo,
1065 SymId::accdnRH3RanksTremoloLower8ve,
1066 SymId::accdnRH3RanksTremoloUpper8ve,
1067 SymId::accdnRH3RanksTwoChoirs,
1068 SymId::accdnRH3RanksUpperTremolo8,
1069 SymId::accdnRH3RanksViolin,
1070 SymId::accdnRH4RanksAlto,
1071
1072 SymId::accdnRH4RanksBassAlto,
1073 SymId::accdnRH4RanksMaster,
1074 SymId::accdnRH4RanksSoftBass,
1075 SymId::accdnRH4RanksSoftTenor,
1076 SymId::accdnRH4RanksSoprano,
1077 SymId::accdnRH4RanksTenor,
1078 SymId::accdnRicochet2,
1079 SymId::accdnRicochet3,
1080 SymId::accdnRicochet4,
1081 SymId::accdnRicochet5,
1082
1083 SymId::accdnRicochet6,
1084 SymId::accdnRicochetStem2,
1085 SymId::accdnRicochetStem3,
1086 SymId::accdnRicochetStem4,
1087 SymId::accdnRicochetStem5,
1088 SymId::accdnRicochetStem6
1089 };
1090 for (auto i : art) {
1091 Symbol* s = new Symbol(gscore);
1092 s->setSym(i);
1093 sp->append(s, Sym::id2userName(i));
1094 }
1095 return sp;
1096 }
1097
1098 //---------------------------------------------------------
1099 // newBracketsPalettePanel
1100 //---------------------------------------------------------
1101
newBracketsPalettePanel()1102 PalettePanel* MuseScore::newBracketsPalettePanel()
1103 {
1104 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Bracket);
1105 sp->setName(QT_TRANSLATE_NOOP("Palette", "Brackets"));
1106 sp->setMag(0.7);
1107 sp->setGrid(40, 60);
1108 sp->setDrawGrid(true);
1109
1110 for (auto t : std::array<std::pair<BracketType,const char*>, 4> {
1111 {{ BracketType::NORMAL, QT_TRANSLATE_NOOP("Palette", "Bracket") },
1112 { BracketType::BRACE, QT_TRANSLATE_NOOP("Palette", "Brace") },
1113 { BracketType::SQUARE, QT_TRANSLATE_NOOP("Palette", "Square") },
1114 { BracketType::LINE, QT_TRANSLATE_NOOP("Palette", "Line") }}
1115 } ) {
1116 Bracket* b1 = new Bracket(gscore);
1117 BracketItem* bi1 = new BracketItem(gscore);
1118 bi1->setBracketType(t.first);
1119 b1->setBracketItem(bi1);
1120 sp->append(b1, t.second); // Bracket, Brace, Square, Line
1121 }
1122 return sp;
1123 }
1124
1125 //---------------------------------------------------------
1126 // newBreathPalettePanel
1127 //---------------------------------------------------------
1128
newBreathPalettePanel()1129 PalettePanel* MuseScore::newBreathPalettePanel()
1130 {
1131 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Breath);
1132 sp->setName(QT_TRANSLATE_NOOP("Palette", "Breaths & Pauses"));
1133 sp->setGrid(42, 40);
1134 sp->setDrawGrid(true);
1135 sp->setDrawGrid(true);
1136
1137 for (BreathType bt : Breath::breathList) {
1138 Breath* a = new Breath(gscore);
1139 a->setSymId(bt.id);
1140 a->setPause(bt.pause);
1141 sp->append(a, Sym::id2userName(bt.id));
1142 }
1143 return sp;
1144 }
1145
1146 //---------------------------------------------------------
1147 // newArpeggioPalettePanel
1148 //---------------------------------------------------------
1149
newArpeggioPalettePanel()1150 PalettePanel* MuseScore::newArpeggioPalettePanel()
1151 {
1152 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Arpeggio);
1153 sp->setName(QT_TRANSLATE_NOOP("Palette", "Arpeggios & Glissandi"));
1154 sp->setGrid(27, 50);
1155 sp->setDrawGrid(true);
1156
1157 for (int i = 0; i < 6; ++i) {
1158 Arpeggio* a = new Arpeggio(gscore);
1159 a->setArpeggioType(ArpeggioType(i));
1160 sp->append(a, a->arpeggioTypeName());
1161 }
1162 for (int i = 0; i < 2; ++i) {
1163 Glissando* a = new Glissando(gscore);
1164 a->setGlissandoType(GlissandoType(i));
1165 sp->append(a, a->glissandoTypeName());
1166 }
1167
1168 //fall and doits
1169
1170 ChordLine* cl = new ChordLine(gscore);
1171 cl->setChordLineType(ChordLineType::FALL);
1172 sp->append(cl, scorelineNames[0]);
1173
1174 cl = new ChordLine(gscore);
1175 cl->setChordLineType(ChordLineType::DOIT);
1176 sp->append(cl, scorelineNames[1]);
1177
1178 cl = new ChordLine(gscore);
1179 cl->setChordLineType(ChordLineType::PLOP);
1180 sp->append(cl, scorelineNames[2]);
1181
1182 cl = new ChordLine(gscore);
1183 cl->setChordLineType(ChordLineType::SCOOP);
1184 sp->append(cl, scorelineNames[3]);
1185
1186 cl = new ChordLine(gscore);
1187 cl->setChordLineType(ChordLineType::FALL);
1188 cl->setStraight(true);
1189 sp->append(cl, QT_TRANSLATE_NOOP("Ms", "Slide out down"));
1190
1191 cl = new ChordLine(gscore);
1192 cl->setChordLineType(ChordLineType::DOIT);
1193 cl->setStraight(true);
1194 sp->append(cl, QT_TRANSLATE_NOOP("Ms", "Slide out up"));
1195
1196 cl = new ChordLine(gscore);
1197 cl->setChordLineType(ChordLineType::PLOP);
1198 cl->setStraight(true);
1199 sp->append(cl, QT_TRANSLATE_NOOP("Ms", "Slide in above"));
1200
1201 cl = new ChordLine(gscore);
1202 cl->setChordLineType(ChordLineType::SCOOP);
1203 cl->setStraight(true);
1204 sp->append(cl, QT_TRANSLATE_NOOP("Ms", "Slide in below"));
1205
1206 return sp;
1207 }
1208
1209 //---------------------------------------------------------
1210 // newClefsPalettePanel
1211 //---------------------------------------------------------
1212
newClefsPalettePanel(bool defaultPalettePanel)1213 PalettePanel* MuseScore::newClefsPalettePanel(bool defaultPalettePanel)
1214 {
1215 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Clef);
1216 sp->setName(QT_TRANSLATE_NOOP("Palette", "Clefs"));
1217 sp->setMag(0.8);
1218 sp->setGrid(35, 50);
1219 sp->setYOffset(1.0);
1220
1221 static std::vector<ClefType> clefsDefault {
1222 ClefType::G, ClefType::G8_VA, ClefType::G15_MA, ClefType::G8_VB, ClefType::G15_MB, ClefType::G8_VB_O,
1223 ClefType::G8_VB_P, ClefType::G_1, ClefType::C1, ClefType::C2, ClefType::C3,
1224 ClefType::C4, ClefType::C5, ClefType::F, ClefType::F_8VA, ClefType::F_15MA,
1225 ClefType::F8_VB, ClefType::F15_MB, ClefType::F_B, ClefType::F_C, ClefType::PERC,
1226 ClefType::PERC2, ClefType::TAB, ClefType::TAB4
1227 };
1228 static std::vector<ClefType> clefsMaster {
1229 ClefType::G, ClefType::G8_VA, ClefType::G15_MA, ClefType::G8_VB, ClefType::G15_MB, ClefType::G8_VB_O,
1230 ClefType::G8_VB_P, ClefType::G_1, ClefType::C1, ClefType::C2, ClefType::C3,
1231 ClefType::C4, ClefType::C5, ClefType::C_19C, ClefType::C1_F18C, ClefType::C3_F18C, ClefType::C4_F18C, ClefType::C1_F20C, ClefType::C3_F20C, ClefType::C4_F20C,
1232 ClefType::F, ClefType::F_8VA, ClefType::F_15MA,
1233 ClefType::F8_VB, ClefType::F15_MB, ClefType::F_B, ClefType::F_C, ClefType::F_F18C, ClefType::F_19C, ClefType::PERC,
1234 ClefType::PERC2, ClefType::TAB, ClefType::TAB4, ClefType::TAB_SERIF, ClefType::TAB4_SERIF
1235 };
1236
1237 std::vector<ClefType>* items = nullptr;
1238 if (defaultPalettePanel) {
1239 items = &clefsDefault;
1240 sp->setMoreElements(true);
1241 }
1242 else {
1243 items = &clefsMaster;
1244 sp->setMoreElements(false);
1245 }
1246
1247 for (ClefType j : *items) {
1248 Clef* k = new Ms::Clef(gscore);
1249 k->setClefType(ClefTypeList(j, j));
1250 sp->append(k, ClefInfo::name(j));
1251 }
1252 return sp;
1253 }
1254
1255 //---------------------------------------------------------
1256 // newGraceNotePalettePanel
1257 //---------------------------------------------------------
1258
newGraceNotePalettePanel()1259 PalettePanel* MuseScore::newGraceNotePalettePanel()
1260 {
1261 PalettePanel* sp = new PalettePanel(PalettePanel::Type::GraceNote);
1262 sp->setName(QT_TRANSLATE_NOOP("Palette", "Grace Notes"));
1263 sp->setGrid(32, 40);
1264 sp->setDrawGrid(true);
1265 static const IconAction gna[] = {
1266 { IconType::ACCIACCATURA, "acciaccatura" },
1267 { IconType::APPOGGIATURA, "appoggiatura" },
1268 { IconType::GRACE4, "grace4" },
1269 { IconType::GRACE16, "grace16" },
1270 { IconType::GRACE32, "grace32" },
1271 { IconType::GRACE8_AFTER, "grace8after" },
1272 { IconType::GRACE16_AFTER, "grace16after" },
1273 { IconType::GRACE32_AFTER, "grace32after" },
1274 { IconType::NONE, "" }
1275 };
1276 populateIconPalettePanel(sp, gna);
1277 return sp;
1278 }
1279
1280 //---------------------------------------------------------
1281 // newBagpipeEmbellishmentPalettePanel
1282 //---------------------------------------------------------
1283
newBagpipeEmbellishmentPalettePanel()1284 PalettePanel* MuseScore::newBagpipeEmbellishmentPalettePanel()
1285 {
1286 PalettePanel* sp = new PalettePanel(PalettePanel::Type::BagpipeEmbellishment);
1287 sp->setName(QT_TRANSLATE_NOOP("Palette", "Bagpipe Embellishments"));
1288 sp->setMag(0.8);
1289 sp->setYOffset(2.0);
1290 sp->setGrid(55, 55);
1291 for (int i = 0; i < BagpipeEmbellishment::nEmbellishments(); ++i) {
1292 BagpipeEmbellishment* b = new BagpipeEmbellishment(gscore);
1293 b->setEmbelType(i);
1294 sp->append(b, BagpipeEmbellishment::BagpipeEmbellishmentList[i].name);
1295 }
1296
1297 return sp;
1298 }
1299
1300 //---------------------------------------------------------
1301 // newLinesPalettePanel
1302 //---------------------------------------------------------
1303
newLinesPalettePanel()1304 PalettePanel* MuseScore::newLinesPalettePanel()
1305 {
1306 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Line);
1307 sp->setName(QT_TRANSLATE_NOOP("Palette", "Lines"));
1308 sp->setMag(.8);
1309 sp->setGrid(75, 28);
1310 sp->setDrawGrid(true);
1311
1312 qreal w = gscore->spatium() * 8;
1313
1314 Slur* slur = new Slur(gscore);
1315 sp->append(slur, QT_TRANSLATE_NOOP("Palette", "Slur"));
1316
1317 Hairpin* gabel0 = new Hairpin(gscore);
1318 gabel0->setHairpinType(HairpinType::CRESC_HAIRPIN);
1319 gabel0->setLen(w);
1320 sp->append(gabel0, QT_TRANSLATE_NOOP("Palette", "Crescendo hairpin"));
1321
1322 Hairpin* gabel1 = new Hairpin(gscore);
1323 gabel1->setHairpinType(HairpinType::DECRESC_HAIRPIN);
1324 gabel1->setLen(w);
1325 sp->append(gabel1, QT_TRANSLATE_NOOP("Palette", "Diminuendo hairpin"));
1326
1327 Hairpin* gabel2 = new Hairpin(gscore);
1328 gabel2->setHairpinType(HairpinType::CRESC_LINE);
1329 gabel2->setLen(w);
1330 sp->append(gabel2, QT_TRANSLATE_NOOP("Palette", "Crescendo line"));
1331
1332 Hairpin* gabel3 = new Hairpin(gscore);
1333 gabel3->setHairpinType(HairpinType::DECRESC_LINE);
1334 gabel3->setLen(w);
1335 sp->append(gabel3, QT_TRANSLATE_NOOP("Palette", "Diminuendo line"));
1336
1337 Hairpin* gabel4 = new Hairpin(gscore);
1338 gabel4->setHairpinType(HairpinType::CRESC_HAIRPIN);
1339 gabel4->setBeginText("<sym>dynamicMezzo</sym><sym>dynamicForte</sym>");
1340 gabel4->setPropertyFlags(Pid::BEGIN_TEXT, PropertyFlags::UNSTYLED);
1341 gabel4->setBeginTextAlign(Align::VCENTER);
1342 gabel4->setPropertyFlags(Pid::BEGIN_TEXT_ALIGN, PropertyFlags::UNSTYLED);
1343 gabel4->setLen(w);
1344 sp->append(gabel4, QT_TRANSLATE_NOOP("Palette", "Dynamic + hairpin"));
1345
1346 Volta* volta = new Volta(gscore);
1347 volta->setVoltaType(Volta::Type::CLOSED);
1348 volta->setLen(w);
1349 volta->setText("1.");
1350 QList<int> il;
1351 il.append(1);
1352 volta->setEndings(il);
1353 sp->append(volta, QT_TRANSLATE_NOOP("Palette", "Prima volta"));
1354
1355 volta = new Volta(gscore);
1356 volta->setVoltaType(Volta::Type::CLOSED);
1357 volta->setLen(w);
1358 volta->setText("2.");
1359 il.clear();
1360 il.append(2);
1361 volta->setEndings(il);
1362 sp->append(volta, QT_TRANSLATE_NOOP("Palette", "Seconda volta"));
1363
1364 volta = new Volta(gscore);
1365 volta->setVoltaType(Volta::Type::CLOSED);
1366 volta->setLen(w);
1367 volta->setText("3.");
1368 il.clear();
1369 il.append(3);
1370 volta->setEndings(il);
1371 sp->append(volta, QT_TRANSLATE_NOOP("Palette", "Terza volta"));
1372
1373 volta = new Volta(gscore);
1374 volta->setVoltaType(Volta::Type::OPEN);
1375 volta->setLen(w);
1376 volta->setText("2.");
1377 il.clear();
1378 il.append(2);
1379 volta->setEndings(il);
1380 sp->append(volta, QT_TRANSLATE_NOOP("Palette", "Seconda volta, open"));
1381
1382 Ottava* ottava = new Ottava(gscore);
1383 ottava->setOttavaType(OttavaType::OTTAVA_8VA);
1384 ottava->setLen(w);
1385 ottava->styleChanged();
1386 sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "8va alta"));
1387
1388 ottava = new Ottava(gscore);
1389 ottava->setOttavaType(OttavaType::OTTAVA_8VB);
1390 ottava->setLen(w);
1391 ottava->setPlacement(Placement::BELOW);
1392 ottava->styleChanged();
1393 sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "8va bassa"));
1394
1395 ottava = new Ottava(gscore);
1396 ottava->setOttavaType(OttavaType::OTTAVA_15MA);
1397 ottava->setLen(w);
1398 ottava->styleChanged();
1399 sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "15ma alta"));
1400
1401 ottava = new Ottava(gscore);
1402 ottava->setOttavaType(OttavaType::OTTAVA_15MB);
1403 ottava->setLen(w);
1404 ottava->setPlacement(Placement::BELOW);
1405 ottava->styleChanged();
1406 sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "15ma bassa"));
1407
1408 ottava = new Ottava(gscore);
1409 ottava->setOttavaType(OttavaType::OTTAVA_22MA);
1410 ottava->setLen(w);
1411 ottava->styleChanged();
1412 sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "22ma alta"));
1413
1414 ottava = new Ottava(gscore);
1415 ottava->setOttavaType(OttavaType::OTTAVA_22MB);
1416 ottava->setLen(w);
1417 ottava->styleChanged();
1418 sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "22ma bassa"));
1419
1420 Pedal* pedal;
1421 pedal = new Pedal(gscore);
1422 pedal->setLen(w);
1423 pedal->setBeginText("<sym>keyboardPedalPed</sym>");
1424 pedal->setContinueText("(<sym>keyboardPedalPed</sym>)");
1425 pedal->setEndHookType(HookType::HOOK_90);
1426 sp->append(pedal, QT_TRANSLATE_NOOP("Palette", "Pedal (with ped and line)"));
1427
1428 pedal = new Pedal(gscore);
1429 pedal->setLen(w);
1430 pedal->setBeginText("<sym>keyboardPedalPed</sym>");
1431 pedal->setContinueText("(<sym>keyboardPedalPed</sym>)");
1432 pedal->setEndText("<sym>keyboardPedalUp</sym>");
1433 pedal->setLineVisible(false);
1434 sp->append(pedal, QT_TRANSLATE_NOOP("Palette", "Pedal (with ped and asterisk)"));
1435
1436 pedal = new Pedal(gscore);
1437 pedal->setLen(w);
1438 pedal->setBeginHookType(HookType::HOOK_90);
1439 pedal->setEndHookType(HookType::HOOK_90);
1440 sp->append(pedal, QT_TRANSLATE_NOOP("Palette", "Pedal (straight hooks)"));
1441
1442 pedal = new Pedal(gscore);
1443 pedal->setLen(w);
1444 pedal->setBeginHookType(HookType::HOOK_90);
1445 pedal->setEndHookType(HookType::HOOK_45);
1446 sp->append(pedal, QT_TRANSLATE_NOOP("Palette", "Pedal (angled end hook)"));
1447
1448 pedal = new Pedal(gscore);
1449 pedal->setLen(w);
1450 pedal->setBeginHookType(HookType::HOOK_45);
1451 pedal->setEndHookType(HookType::HOOK_45);
1452 sp->append(pedal, QT_TRANSLATE_NOOP("Palette", "Pedal (both hooks angled)"));
1453
1454 pedal = new Pedal(gscore);
1455 pedal->setLen(w);
1456 pedal->setBeginHookType(HookType::HOOK_45);
1457 pedal->setEndHookType(HookType::HOOK_90);
1458 sp->append(pedal, QT_TRANSLATE_NOOP("Palette", "Pedal (angled start hook)"));
1459
1460 for (int i = 0; i < trillTableSize(); i++) {
1461 Trill* trill = new Trill(gscore);
1462 trill->setTrillType(trillTable[i].type);
1463 trill->setLen(w);
1464 sp->append(trill, trillTable[i].userName);
1465 }
1466
1467 TextLine* textLine = new TextLine(gscore);
1468 textLine->setLen(w);
1469 textLine->setBeginText("Staff");
1470 textLine->setEndHookType(HookType::HOOK_90);
1471 sp->append(textLine, QT_TRANSLATE_NOOP("Palette", "Staff Text line"));
1472
1473 TextLine* systemTextLine = new TextLine(gscore, true);
1474 systemTextLine->setLen(w);
1475 systemTextLine->setBeginText("System");
1476 systemTextLine->setEndHookType(HookType::HOOK_90);
1477 sp->append(systemTextLine, QT_TRANSLATE_NOOP("Palette", "System Text line"));
1478
1479 TextLine* line = new TextLine(gscore);
1480 line->setLen(w);
1481 line->setDiagonal(true);
1482 sp->append(line, QT_TRANSLATE_NOOP("Palette", "Line"));
1483
1484 Ambitus* a = new Ambitus(gscore);
1485 sp->append(a, QT_TRANSLATE_NOOP("Palette", "Ambitus"));
1486
1487 LetRing* letRing = new LetRing(gscore);
1488 letRing->setLen(w);
1489 sp->append(letRing, QT_TRANSLATE_NOOP("Palette", "Let Ring"));
1490
1491 for (int i = 0; i < vibratoTableSize(); i++) {
1492 Vibrato* vibrato = new Vibrato(gscore);
1493 vibrato->setVibratoType(vibratoTable[i].type);
1494 vibrato->setLen(w);
1495 sp->append(vibrato, vibratoTable[i].userName);
1496 }
1497
1498 PalmMute* pm = new PalmMute(gscore);
1499 pm->setLen(w);
1500 sp->append(pm, QT_TRANSLATE_NOOP("Palette", "Palm Mute"));
1501
1502 return sp;
1503 }
1504
1505 //---------------------------------------------------------
1506 // newTempoPalettePanel
1507 //---------------------------------------------------------
1508
newTempoPalettePanel(bool defaultPalettePanel)1509 PalettePanel* MuseScore::newTempoPalettePanel(bool defaultPalettePanel)
1510 {
1511 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Tempo);
1512 sp->setName(QT_TRANSLATE_NOOP("Palette", "Tempo"));
1513 sp->setMag(0.65);
1514 if (defaultPalettePanel)
1515 sp->setGrid(66, 28);
1516 else
1517 sp->setGrid(116, 28);
1518 sp->setDrawGrid(true);
1519
1520 static const TempoPattern tps[] = {
1521 TempoPattern("<sym>metNoteHalfUp</sym> = 80", QT_TRANSLATE_NOOP("Palette", "Half note = 80 BPM"), 80.0/ 30.0, false, false, true, true, false), // 1/2
1522 TempoPattern("<sym>metNoteQuarterUp</sym> = 80", QT_TRANSLATE_NOOP("Palette", "Quarter note = 80 BPM"), 80.0/ 60.0, false, false, true, true, false), // 1/4
1523 TempoPattern("<sym>metNote8thUp</sym> = 80", QT_TRANSLATE_NOOP("Palette", "Eighth note = 80 BPM"), 80.0/120.0, false, false, true, true, false), // 1/8
1524 TempoPattern("<sym>metNoteHalfUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = 80", QT_TRANSLATE_NOOP("Palette", "Dotted half note = 80 BPM"), 120/ 30.0, false, false, true, false, false), // dotted 1/2
1525 TempoPattern("<sym>metNoteQuarterUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = 80", QT_TRANSLATE_NOOP("Palette", "Dotted quarter note = 80 BPM"), 120/ 60.0, false, false, true, true, false), // dotted 1/4
1526 TempoPattern("<sym>metNote8thUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = 80", QT_TRANSLATE_NOOP("Palette", "Dotted eighth note = 80 BPM"), 120/120.0, false, false, true, false, false), // dotted 1/8
1527
1528 TempoPattern("Grave", "Grave", 35.0/60.0, false, true, false, false, false),
1529 TempoPattern("Largo", "Largo", 50.0/60.0, false, true, false, false, false),
1530 TempoPattern("Lento", "Lento", 52.5/60.0, false, true, false, false, false),
1531 TempoPattern("Larghetto", "Larghetto", 63.0/60.0, false, true, false, false, true),
1532 TempoPattern("Adagio", "Adagio", 71.0/60.0, false, true, false, false, false),
1533 TempoPattern("Andante", "Andante", 92.0/60.0, false, true, false, false, false),
1534 TempoPattern("Andantino", "Andantino", 94.0/60.0, false, true, false, false, true),
1535 TempoPattern("Moderato", "Moderato", 114.0/60.0, false, true, false, false, false),
1536 TempoPattern("Allegretto", "Allegretto", 116.0/60.0, false, true, false, false, false),
1537 TempoPattern("Allegro moderato", "Allegro moderato", 118.0/60.0, false, true, false, false, true),
1538 TempoPattern("Allegro", "Allegro", 144.0/60.0, false, true, false, false, false),
1539 TempoPattern("Vivace", "Vivace", 172.0/60.0, false, true, false, false, false),
1540 TempoPattern("Presto", "Presto", 187.0/60.0, false, true, false, false, false),
1541 TempoPattern("Prestissimo", "Prestissimo", 200.0/60.0, false, true, false, false, true),
1542
1543 TempoPattern("<sym>metNoteQuarterUp</sym> = <sym>metNoteQuarterUp</sym><sym>space</sym><sym>metAugmentationDot</sym>", QT_TRANSLATE_NOOP("Palette", "Quarter note = dotted quarter note metric modulation"), 3.0/2.0, true, false, true, false, false),
1544 TempoPattern("<sym>metNoteQuarterUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = <sym>metNoteQuarterUp</sym>", QT_TRANSLATE_NOOP("Palette", "Dotted quarter note = quarter note metric modulation"), 2.0/3.0, true, false, true, false, false),
1545 TempoPattern("<sym>metNoteHalfUp</sym> = <sym>metNoteQuarterUp</sym>", QT_TRANSLATE_NOOP("Palette", "Half note = quarter note metric modulation"), 1.0/2.0, true, false, true, false, false),
1546 TempoPattern("<sym>metNoteQuarterUp</sym> = <sym>metNoteHalfUp</sym>", QT_TRANSLATE_NOOP("Palette", "Quarter note = half note metric modulation"), 2.0/1.0, true, false, true, false, false),
1547 TempoPattern("<sym>metNote8thUp</sym> = <sym>metNote8thUp</sym>", QT_TRANSLATE_NOOP("Palette", "Eighth note = eighth note metric modulation"), 1.0/1.0, true, false, true, false, false),
1548 TempoPattern("<sym>metNoteQuarterUp</sym> = <sym>metNoteQuarterUp</sym>", QT_TRANSLATE_NOOP("Palette", "Quarter note = quarter note metric modulation"), 1.0/1.0, true, false, true, false, false),
1549 TempoPattern("<sym>metNote8thUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = <sym>metNoteQuarterUp</sym>", QT_TRANSLATE_NOOP("Palette", "Dotted eighth note = quarter note metric modulation"), 2.0/3.0, true, false, true, false, false),
1550 };
1551 for (TempoPattern tp : tps) {
1552 TempoText* tt = new TempoText(gscore);
1553 tt->setFollowText(tp.followText);
1554 tt->setXmlText(tp.pattern);
1555 if (tp.relative) {
1556 tt->setRelative(tp.f);
1557 sp->append(tt, qApp->translate("Palette", tp.name), QString(), 1.5);
1558 }
1559 else if (tp.italian) {
1560 tt->setTempo(tp.f);
1561 sp->append(tt, tp.name, QString(), 1.3);
1562 }
1563 else {
1564 tt->setTempo(tp.f);
1565 sp->append(tt, qApp->translate("Palette", tp.name), QString(), 1.5);
1566 }
1567 }
1568 sp->setMoreElements(false);
1569
1570 return sp;
1571 }
1572
1573 //---------------------------------------------------------
1574 // newTextPalettePanel
1575 //---------------------------------------------------------
1576
newTextPalettePanel(bool defaultPalettePanel)1577 PalettePanel* MuseScore::newTextPalettePanel(bool defaultPalettePanel)
1578 {
1579 PalettePanel* sp = new PalettePanel(PalettePanel::Type::Text);
1580 sp->setName(QT_TRANSLATE_NOOP("Palette", "Text"));
1581 sp->setMag(0.85);
1582 sp->setGrid(84, 28);
1583 sp->setDrawGrid(true);
1584
1585 StaffText* st = new StaffText(gscore);
1586 st->setXmlText(QT_TRANSLATE_NOOP("Palette", "Staff Text"));
1587 sp->append(st, QT_TRANSLATE_NOOP("Palette", "Staff text"))->setElementTranslated(true);
1588
1589 st = new StaffText(gscore, Tid::EXPRESSION);
1590 st->setXmlText(QT_TRANSLATE_NOOP("Palette", "Expression"));
1591 st->setPlacement(Placement::BELOW);
1592 st->setPropertyFlags(Pid::PLACEMENT, PropertyFlags::UNSTYLED);
1593 sp->append(st, QT_TRANSLATE_NOOP("Palette", "Expression text"))->setElementTranslated(true);
1594
1595 InstrumentChange* is = new InstrumentChange(gscore);
1596 is->setXmlText(QT_TRANSLATE_NOOP("Palette", "Change Instr."));
1597 sp->append(is, QT_TRANSLATE_NOOP("Palette", "Instrument change"))->setElementTranslated(true);
1598
1599 StaffTypeChange* stc = new StaffTypeChange(gscore);
1600 sp->append(stc, QT_TRANSLATE_NOOP("Palette", "Staff type change"));
1601
1602 RehearsalMark* rhm = new RehearsalMark(gscore);
1603 rhm->setXmlText("B1");
1604 sp->append(rhm, QT_TRANSLATE_NOOP("Palette", "Rehearsal mark"));
1605
1606 SystemText* stxt = new SystemText(gscore, Tid::TEMPO);
1607 stxt->setXmlText(QT_TRANSLATE_NOOP("Palette", "Swing"));
1608 stxt->setSwing(true);
1609 sp->append(stxt, QT_TRANSLATE_NOOP("Palette", "Swing"))->setElementTranslated(true);
1610
1611 stxt = new SystemText(gscore, Tid::TEMPO);
1612 /*: System text to switch from swing rhythm back to straight rhythm */
1613 stxt->setXmlText(QT_TRANSLATE_NOOP("Palette", "Straight"));
1614 // need to be true to enable the "Off" option
1615 stxt->setSwing(true);
1616 // 0 (swingUnit) turns of swing; swingRatio is set to default
1617 stxt->setSwingParameters(0, stxt->score()->styleI(Sid::swingRatio));
1618 /*: System text to switch from swing rhythm back to straight rhythm */
1619 sp->append(stxt, QT_TRANSLATE_NOOP("Palette", "Straight"))->setElementTranslated(true);
1620
1621 stxt = new SystemText(gscore);
1622 stxt->setXmlText(QT_TRANSLATE_NOOP("Palette", "System Text"));
1623 sp->append(stxt, QT_TRANSLATE_NOOP("Palette", "System text"))->setElementTranslated(true);
1624
1625 // Measure numbers, unlike other elements (but like most text elements),
1626 // are not copied directly into the score when drop.
1627 // Instead, they simply set the corresponding measure's MeasureNumberMode to SHOW
1628 // Because of that, the element shown in the palettes does not have to have any particular formatting.
1629 MeasureNumber* meaNum = new MeasureNumber(gscore);
1630 meaNum->setProperty(Pid::SUB_STYLE, int(Tid::STAFF)); // Make the element bigger in the palettes (using the default measure number style makes it too small)
1631 meaNum->setXmlText(QT_TRANSLATE_NOOP("Palette", "Measure Number"));
1632 sp->append(meaNum, QT_TRANSLATE_NOOP("Palette", "Measure Number"))->setElementTranslated(true);
1633
1634 if (!defaultPalettePanel) {
1635 StaffText* pz = new StaffText(gscore);
1636 pz->setXmlText(QT_TRANSLATE_NOOP("Palette", "pizz."));
1637 pz->setChannelName(0, "pizzicato");
1638 pz->setChannelName(1, "pizzicato");
1639 pz->setChannelName(2, "pizzicato");
1640 pz->setChannelName(3, "pizzicato");
1641 sp->append(pz, QT_TRANSLATE_NOOP("Palette", "Pizzicato"))->setElementTranslated(true);
1642
1643 StaffText* ar = new StaffText(gscore);
1644 ar->setXmlText(QT_TRANSLATE_NOOP("Palette", "arco"));
1645 ar->setChannelName(0, "arco");
1646 ar->setChannelName(1, "arco");
1647 ar->setChannelName(2, "arco");
1648 ar->setChannelName(3, "arco");
1649 sp->append(ar, QT_TRANSLATE_NOOP("Palette", "Arco"))->setElementTranslated(true);
1650
1651 StaffText* tm = new StaffText(gscore, Tid::EXPRESSION);
1652 tm->setXmlText(QT_TRANSLATE_NOOP("Palette", "tremolo"));
1653 tm->setChannelName(0, "tremolo");
1654 tm->setChannelName(1, "tremolo");
1655 tm->setChannelName(2, "tremolo");
1656 tm->setChannelName(3, "tremolo");
1657 sp->append(tm, QT_TRANSLATE_NOOP("Palette", "Tremolo"))->setElementTranslated(true);
1658
1659 StaffText* mu = new StaffText(gscore);
1660 /*: For brass and plucked string instruments: staff text that prescribes to use mute while playing, see https://en.wikipedia.org/wiki/Mute_(music) */
1661 mu->setXmlText(QT_TRANSLATE_NOOP("Palette", "mute"));
1662 mu->setChannelName(0, "mute");
1663 mu->setChannelName(1, "mute");
1664 mu->setChannelName(2, "mute");
1665 mu->setChannelName(3, "mute");
1666 /*: For brass and plucked string instruments: staff text that prescribes to use mute while playing, see https://en.wikipedia.org/wiki/Mute_(music) */
1667 sp->append(mu, QT_TRANSLATE_NOOP("Palette", "Mute"))->setElementTranslated(true);
1668
1669 StaffText* no = new StaffText(gscore);
1670 /*: For brass and plucked string instruments: staff text that prescribes to play without mute, see https://en.wikipedia.org/wiki/Mute_(music) */
1671 no->setXmlText(QT_TRANSLATE_NOOP("Palette", "open"));
1672 no->setChannelName(0, "open");
1673 no->setChannelName(1, "open");
1674 no->setChannelName(2, "open");
1675 no->setChannelName(3, "open");
1676 /*: For brass and plucked string instruments: staff text that prescribes to play without mute, see https://en.wikipedia.org/wiki/Mute_(music) */
1677 sp->append(no, QT_TRANSLATE_NOOP("Palette", "Open"))->setElementTranslated(true);
1678
1679 StaffText* sa = new StaffText(gscore);
1680 sa->setXmlText(QT_TRANSLATE_NOOP("Palette", "S/A"));
1681 sa->setChannelName(0, "Soprano");
1682 sa->setChannelName(1, "Alto");
1683 sa->setChannelName(2, "Soprano");
1684 sa->setChannelName(3, "Alto");
1685 sa->setVisible(false);
1686 sp->append(sa, QT_TRANSLATE_NOOP("Palette", "Soprano/Alto"))->setElementTranslated(true);
1687
1688 StaffText* tb = new StaffText(gscore);
1689 tb->setXmlText(QT_TRANSLATE_NOOP("Palette", "T/B"));
1690 tb->setChannelName(0, "Tenor");
1691 tb->setChannelName(1, "Bass");
1692 tb->setChannelName(2, "Tenor");
1693 tb->setChannelName(3, "Bass");
1694 tb->setVisible(false);
1695 sp->append(tb, QT_TRANSLATE_NOOP("Palette", "Tenor/Bass"))->setElementTranslated(true);
1696
1697 StaffText* tl = new StaffText(gscore);
1698 tl->setXmlText(QT_TRANSLATE_NOOP("Palette", "T/L"));
1699 tl->setChannelName(0, "TENOR");
1700 tl->setChannelName(1, "LEAD");
1701 tl->setChannelName(2, "TENOR");
1702 tl->setChannelName(3, "LEAD");
1703 tl->setVisible(false);
1704 sp->append(tl, QT_TRANSLATE_NOOP("Palette", "Tenor/Lead"))->setElementTranslated(true);
1705
1706 StaffText* bb = new StaffText(gscore);
1707 bb->setXmlText(QT_TRANSLATE_NOOP("Palette", "B/B"));
1708 bb->setChannelName(0, "BARI");
1709 bb->setChannelName(1, "BASS");
1710 bb->setChannelName(2, "BARI");
1711 bb->setChannelName(3, "BASS");
1712 bb->setVisible(false);
1713 sp->append(bb, QT_TRANSLATE_NOOP("Palette", "Bari/Bass"))->setElementTranslated(true);
1714 }
1715
1716 return sp;
1717 }
1718
1719 //---------------------------------------------------------
1720 // newTimePalettePanel
1721 // create default time signature palette
1722 //---------------------------------------------------------
1723
newTimePalettePanel()1724 PalettePanel* MuseScore::newTimePalettePanel()
1725 {
1726 struct TS {
1727 int numerator;
1728 int denominator;
1729 TimeSigType type;
1730 QString name;
1731 };
1732
1733 TS tsList[] = {
1734 { 2, 4, TimeSigType::NORMAL, "2/4" },
1735 { 3, 4, TimeSigType::NORMAL, "3/4" },
1736 { 4, 4, TimeSigType::NORMAL, "4/4" },
1737 { 5, 4, TimeSigType::NORMAL, "5/4" },
1738 { 6, 4, TimeSigType::NORMAL, "6/4" },
1739 { 3, 8, TimeSigType::NORMAL, "3/8" },
1740 { 6, 8, TimeSigType::NORMAL, "6/8" },
1741 { 7, 8, TimeSigType::NORMAL, "7/8" },
1742 { 9, 8, TimeSigType::NORMAL, "9/8" },
1743 { 12, 8, TimeSigType::NORMAL, "12/8" },
1744 { 4, 4, TimeSigType::FOUR_FOUR, qApp->translate("symUserNames", "Common time") },
1745 { 2, 2, TimeSigType::ALLA_BREVE, qApp->translate("symUserNames", "Cut time") },
1746 { 2, 2, TimeSigType::NORMAL, "2/2" },
1747 { 3, 2, TimeSigType::NORMAL, "3/2" },
1748 { 4, 2, TimeSigType::NORMAL, "4/2" },
1749 { 2, 2, TimeSigType::CUT_BACH, qApp->translate("symUserNames", "Cut time (Bach)") },
1750 { 9, 8, TimeSigType::CUT_TRIPLE, qApp->translate("symUserNames", "Cut triple time (9/8)") },
1751 };
1752
1753 PalettePanel* sp = new PalettePanel(PalettePanel::Type::TimeSig);
1754 sp->setName(QT_TRANSLATE_NOOP("Palette", "Time Signatures"));
1755 sp->setMag(.8);
1756 sp->setGrid(42, 38);
1757
1758 for (unsigned i = 0; i < sizeof(tsList)/sizeof(*tsList); ++i) {
1759 TimeSig* ts;
1760 ts = new TimeSig(gscore);
1761 ts->setSig(Fraction(tsList[i].numerator, tsList[i].denominator), tsList[i].type);
1762 sp->append(ts, tsList[i].name);
1763 }
1764 return sp;
1765 }
1766
1767 //-----------------------------------
1768 // newFretboardDiagramPalettePanel
1769 //-----------------------------------
1770
newFretboardDiagramPalettePanel()1771 PalettePanel* MuseScore::newFretboardDiagramPalettePanel()
1772 {
1773 PalettePanel* sp = new PalettePanel(PalettePanel::Type::FretboardDiagram);
1774 sp->setName(QT_TRANSLATE_NOOP("Palette", "Fretboard Diagrams"));
1775 sp->setGrid(42, 45);
1776 sp->setDrawGrid(true);
1777
1778 FretDiagram* fret = FretDiagram::fromString(gscore, "X32O1O");
1779 fret->setHarmony("C");
1780 sp->append(fret, "C");
1781 fret = FretDiagram::fromString(gscore, "X-554-");
1782 fret->setHarmony("Cm");
1783 sp->append(fret, "Cm");
1784 fret = FretDiagram::fromString(gscore, "X3231O");
1785 fret->setHarmony("C7");
1786 sp->append(fret, "C7");
1787
1788 fret = FretDiagram::fromString(gscore, "XXO232");
1789 fret->setHarmony("D");
1790 sp->append(fret, "D");
1791 fret = FretDiagram::fromString(gscore, "XXO231");
1792 fret->setHarmony("Dm");
1793 sp->append(fret, "Dm");
1794 fret = FretDiagram::fromString(gscore, "XXO212");
1795 fret->setHarmony("D7");
1796 sp->append(fret, "D7");
1797
1798 fret = FretDiagram::fromString(gscore, "O221OO");
1799 fret->setHarmony("E");
1800 sp->append(fret, "E");
1801 fret = FretDiagram::fromString(gscore, "O22OOO");
1802 fret->setHarmony("Em");
1803 sp->append(fret, "Em");
1804 fret = FretDiagram::fromString(gscore, "O2O1OO");
1805 fret->setHarmony("E7");
1806 sp->append(fret, "E7");
1807
1808 fret = FretDiagram::fromString(gscore, "-332--");
1809 fret->setHarmony("F");
1810 sp->append(fret, "F");
1811 fret = FretDiagram::fromString(gscore, "-33---");
1812 fret->setHarmony("Fm");
1813 sp->append(fret, "Fm");
1814 fret = FretDiagram::fromString(gscore, "-3-2--");
1815 fret->setHarmony("F7");
1816 sp->append(fret, "F7");
1817
1818 fret = FretDiagram::fromString(gscore, "32OOO3");
1819 fret->setHarmony("G");
1820 sp->append(fret, "G");
1821 fret = FretDiagram::fromString(gscore, "-55---");
1822 fret->setHarmony("Gm");
1823 sp->append(fret, "Gm");
1824 fret = FretDiagram::fromString(gscore, "32OOO1");
1825 fret->setHarmony("G7");
1826 sp->append(fret, "G7");
1827
1828 fret = FretDiagram::fromString(gscore, "XO222O");
1829 fret->setHarmony("A");
1830 sp->append(fret, "A");
1831 fret = FretDiagram::fromString(gscore, "XO221O");
1832 fret->setHarmony("Am");
1833 sp->append(fret, "Am");
1834 fret = FretDiagram::fromString(gscore, "XO2O2O");
1835 fret->setHarmony("A7");
1836 sp->append(fret, "A7");
1837
1838 fret = FretDiagram::fromString(gscore, "X-444-");
1839 fret->setHarmony("B");
1840 sp->append(fret, "B");
1841 fret = FretDiagram::fromString(gscore, "X-443-");
1842 fret->setHarmony("Bm");
1843 sp->append(fret, "Bm");
1844 fret = FretDiagram::fromString(gscore, "X212O2");
1845 fret->setHarmony("B7");
1846 sp->append(fret, "B7");
1847
1848 return sp;
1849 }
1850 //########END DEBUG: new palettes #########################
1851
1852 //---------------------------------------------------------
1853 // setDefaultPalette
1854 //---------------------------------------------------------
1855
setDefaultPalette()1856 void MuseScore::setDefaultPalette()
1857 {
1858 std::unique_ptr<PaletteTree> defaultPalette(new PaletteTree);
1859
1860 defaultPalette->append(newClefsPalettePanel(true));
1861 defaultPalette->append(newKeySigPalettePanel());
1862 defaultPalette->append(newTimePalettePanel());
1863 defaultPalette->append(newBracketsPalettePanel());
1864 defaultPalette->append(newAccidentalsPalettePanel(true));
1865 defaultPalette->append(newArticulationsPalettePanel());
1866 defaultPalette->append(newOrnamentsPalettePanel());
1867 defaultPalette->append(newBreathPalettePanel());
1868 defaultPalette->append(newGraceNotePalettePanel());
1869 defaultPalette->append(newNoteHeadsPalettePanel());
1870 defaultPalette->append(newLinesPalettePanel());
1871 defaultPalette->append(newBarLinePalettePanel());
1872 defaultPalette->append(newArpeggioPalettePanel());
1873 defaultPalette->append(newTremoloPalettePanel());
1874 defaultPalette->append(newTextPalettePanel(true));
1875 defaultPalette->append(newTempoPalettePanel(true));
1876 defaultPalette->append(newDynamicsPalettePanel(true));
1877 defaultPalette->append(newFingeringPalettePanel());
1878 defaultPalette->append(newRepeatsPalettePanel());
1879 defaultPalette->append(newFretboardDiagramPalettePanel());
1880 defaultPalette->append(newAccordionPalettePanel());
1881 defaultPalette->append(newBagpipeEmbellishmentPalettePanel());
1882 defaultPalette->append(newBreaksPalettePanel());
1883 defaultPalette->append(newFramePalettePanel());
1884 defaultPalette->append(newBeamPalettePanel());
1885
1886 mscore->getPaletteWorkspace()->setUserPaletteTree(std::move(defaultPalette));
1887 }
1888
1889 //---------------------------------------------------------
1890 // addTempo
1891 //---------------------------------------------------------
1892
addTempo()1893 void MuseScore::addTempo()
1894 {
1895 ChordRest* cr = cs->getSelectedChordRest();
1896 if (!cr)
1897 return;
1898 // double bps = 2.0;
1899
1900 SigEvent event = cs->sigmap()->timesig(cr->tick());
1901 Fraction f = event.nominal();
1902 QString text("<sym>metNoteQuarterUp</sym> = 80");
1903 switch (f.denominator()) {
1904 case 1:
1905 text = "<sym>metNoteWhole</sym> = 80";
1906 break;
1907 case 2:
1908 text = "<sym>metNoteHalfUp</sym> = 80";
1909 break;
1910 case 4:
1911 text = "<sym>metNoteQuarterUp</sym> = 80";
1912 break;
1913 case 8:
1914 if(f.numerator() % 3 == 0)
1915 text = "<sym>metNoteQuarterUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = 80";
1916 else
1917 text = "<sym>metNote8thUp</sym> = 80";
1918 break;
1919 case 16:
1920 if(f.numerator() % 3 == 0)
1921 text = "<sym>metNote8thUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = 80";
1922 else
1923 text = "<sym>metNote16thUp</sym> = 80";
1924 break;
1925 case 32:
1926 if(f.numerator() % 3 == 0)
1927 text = "<sym>metNote16thUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = 80";
1928 else
1929 text = "<sym>metNote32ndUp</sym> = 80";
1930 break;
1931 case 64:
1932 if(f.numerator() % 3 == 0)
1933 text = "<sym>metNote32ndUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = 80";
1934 else
1935 text = "<sym>metNote64thUp</sym> = 80";
1936 break;
1937 default:
1938 break;
1939 }
1940
1941 TempoText* tt = new TempoText(cs);
1942 cs->startCmd();
1943 tt->setParent(cr->segment());
1944 tt->setTrack(0);
1945 tt->setXmlText(text);
1946 tt->setFollowText(true);
1947 //tt->setTempo(bps);
1948 cs->undoAddElement(tt);
1949 cs->select(tt, SelectType::SINGLE, 0);
1950 cs->endCmd();
1951 Measure* m = tt->findMeasure();
1952 if (m && m->hasMMRest() && tt->links()) {
1953 Measure* mmRest = m->mmRest();
1954 for (ScoreElement* se : *tt->links()) {
1955 TempoText* tt1 = toTempoText(se);
1956 if (tt != tt1 && tt1->findMeasure() == mmRest) {
1957 tt = tt1;
1958 break;
1959 }
1960 }
1961 }
1962 cv->startEditMode(tt);
1963 }
1964
1965 //---------------------------------------------------------
1966 // smuflRanges
1967 // read smufl ranges.json file
1968 //---------------------------------------------------------
1969
smuflRanges()1970 QMap<QString, QStringList>* smuflRanges()
1971 {
1972 static QMap<QString, QStringList> ranges;
1973 QStringList allSymbols;
1974
1975 if (ranges.empty()) {
1976 QFile fi(":fonts/smufl/ranges.json");
1977 if (!fi.open(QIODevice::ReadOnly))
1978 qDebug("ScoreFont: open ranges file <%s> failed", qPrintable(fi.fileName()));
1979 QJsonParseError error;
1980 QJsonObject o = QJsonDocument::fromJson(fi.readAll(), &error).object();
1981 if (error.error != QJsonParseError::NoError)
1982 qDebug("Json parse error in <%s>(offset: %d): %s", qPrintable(fi.fileName()),
1983 error.offset, qPrintable(error.errorString()));
1984
1985 for (auto s : o.keys()) {
1986 QJsonObject range = o.value(s).toObject();
1987 QString desc = range.value("description").toString();
1988 QJsonArray glyphs = range.value("glyphs").toArray();
1989 if (glyphs.size() > 0) {
1990 QStringList glyphNames;
1991 for (QJsonValue g : glyphs)
1992 glyphNames.append(g.toString());
1993 ranges.insert(desc, glyphNames);
1994 allSymbols << glyphNames;
1995 }
1996 }
1997 ranges.insert(SMUFL_ALL_SYMBOLS, allSymbols); // TODO: make translatable as well as ranges.json
1998 }
1999 return &ranges;
2000 }
2001 }
2002
2003