Line data Source code
1 : /*
2 : * SPDX-License-Identifier: GPL-3.0-only
3 : * MuseScore-Studio-CLA-applies
4 : *
5 : * MuseScore Studio
6 : * Music Composition & Notation
7 : *
8 : * Copyright (C) 2021 MuseScore Limited and others
9 : *
10 : * This program is free software: you can redistribute it and/or modify
11 : * it under the terms of the GNU General Public License version 3 as
12 : * published by the Free Software Foundation.
13 : *
14 : * This program is distributed in the hope that it will be useful,
15 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 : * GNU General Public License for more details.
18 : *
19 : * You should have received a copy of the GNU General Public License
20 : * along with this program. If not, see <https://www.gnu.org/licenses/>.
21 : */
22 :
23 : #include "palettecreator.h"
24 :
25 : #include "translation.h"
26 :
27 : #include "engraving/types/typesconv.h"
28 : #include "engraving/types/symnames.h"
29 :
30 : #include "engraving/dom/accidental.h"
31 : #include "engraving/dom/actionicon.h"
32 : #include "engraving/dom/ambitus.h"
33 : #include "engraving/dom/arpeggio.h"
34 : #include "engraving/dom/articulation.h"
35 : #include "engraving/dom/bagpembell.h"
36 : #include "engraving/dom/barline.h"
37 : #include "engraving/dom/bracket.h"
38 : #include "engraving/dom/breath.h"
39 : #include "engraving/dom/capo.h"
40 : #include "engraving/dom/chord.h"
41 : #include "engraving/dom/chordbracket.h"
42 : #include "engraving/dom/chordline.h"
43 : #include "engraving/dom/chordrest.h"
44 : #include "engraving/dom/clef.h"
45 : #include "engraving/dom/dynamic.h"
46 : #include "engraving/dom/expression.h"
47 : #include "engraving/dom/factory.h"
48 : #include "engraving/dom/fermata.h"
49 : #include "engraving/dom/fingering.h"
50 : #include "engraving/dom/fret.h"
51 : #include "engraving/dom/glissando.h"
52 : #include "engraving/dom/gradualtempochange.h"
53 : #include "engraving/dom/guitarbend.h"
54 : #include "engraving/dom/hairpin.h"
55 : #include "engraving/dom/hammeronpulloff.h"
56 : #include "engraving/dom/harppedaldiagram.h"
57 : #include "engraving/dom/instrchange.h"
58 : #include "engraving/dom/jump.h"
59 : #include "engraving/dom/keysig.h"
60 : #include "engraving/dom/layoutbreak.h"
61 : #include "engraving/dom/letring.h"
62 : #include "engraving/dom/marker.h"
63 : #include "engraving/dom/masterscore.h"
64 : #include "engraving/dom/measure.h"
65 : #include "engraving/dom/measurenumber.h"
66 : #include "engraving/dom/measurerepeat.h"
67 : #include "engraving/dom/note.h"
68 : #include "engraving/dom/ornament.h"
69 : #include "engraving/dom/ottava.h"
70 : #include "engraving/dom/palmmute.h"
71 : #include "engraving/dom/part.h"
72 : #include "engraving/dom/pedal.h"
73 : #include "engraving/dom/playtechannotation.h"
74 : #include "engraving/dom/rehearsalmark.h"
75 : #include "engraving/dom/segment.h"
76 : #include "engraving/dom/slur.h"
77 : #include "engraving/dom/spacer.h"
78 : #include "engraving/dom/staff.h"
79 : #include "engraving/dom/stafftext.h"
80 : #include "engraving/dom/stringtunings.h"
81 : #include "engraving/dom/systemtext.h"
82 : #include "engraving/dom/tapping.h"
83 : #include "engraving/dom/tempotext.h"
84 : #include "engraving/dom/textline.h"
85 : #include "engraving/dom/timesig.h"
86 : #include "engraving/dom/tremolosinglechord.h"
87 : #include "engraving/dom/tremolotwochord.h"
88 : #include "engraving/dom/tremolobar.h"
89 : #include "engraving/dom/trill.h"
90 : #include "engraving/dom/vibrato.h"
91 : #include "engraving/dom/volta.h"
92 : #include "engraving/dom/whammybar.h"
93 :
94 : #include "engraving/editing/editstaffbrackets.h"
95 :
96 : using namespace mu;
97 : using namespace mu::palette;
98 : using namespace mu::engraving;
99 :
100 : static const qreal FRAME_MAG = 1.25;
101 :
102 : // Default wrapper...
103 : template<class C>
104 : struct makeElementImplWrapper {
105 : template<typename ... Args>
106 0 : static std::shared_ptr<C> makeElementImpl(mu::engraving::Score* score, Args&&... args)
107 : {
108 0 : return std::make_shared<C>(score->dummy(), std::forward<Args>(args)...);
109 : }
110 : };
111 :
112 : // Specialised wrappers...
113 : #define IMPL_WRAPPER(T, P) \
114 : template<> \
115 : struct makeElementImplWrapper<T> { \
116 : template<typename ... Args> \
117 : static std::shared_ptr<T> makeElementImpl(mu::engraving::Score * score, Args && ... args) \
118 : { \
119 : return std::make_shared<T>(P, std::forward<Args>(args)...); \
120 : } \
121 : }; \
122 :
123 0 : IMPL_WRAPPER(Dynamic, score->dummy())
124 0 : IMPL_WRAPPER(MeasureRepeat, score->dummy())
125 : IMPL_WRAPPER(Hairpin, score->dummy())
126 0 : IMPL_WRAPPER(SystemText, score->dummy())
127 0 : IMPL_WRAPPER(TempoText, score->dummy())
128 0 : IMPL_WRAPPER(StaffText, score->dummy())
129 0 : IMPL_WRAPPER(Expression, score->dummy())
130 0 : IMPL_WRAPPER(PlayTechAnnotation, score->dummy())
131 0 : IMPL_WRAPPER(Capo, score->dummy())
132 0 : IMPL_WRAPPER(StringTunings, score->dummy())
133 0 : IMPL_WRAPPER(RehearsalMark, score->dummy())
134 :
135 0 : IMPL_WRAPPER(Jump, score->dummy())
136 0 : IMPL_WRAPPER(MeasureNumber, score->dummy())
137 :
138 0 : IMPL_WRAPPER(Fingering, score->dummy())
139 0 : IMPL_WRAPPER(NoteHead, score->dummy())
140 :
141 : // Dispatcher method ...
142 : template<class C, typename ... Args>
143 0 : std::shared_ptr<C> makeElement(mu::engraving::Score* score, Args&&... args)
144 : {
145 0 : return makeElementImplWrapper<C>::makeElementImpl(score, std::forward<Args>(args)...);
146 : }
147 :
148 0 : engraving::MasterScore* PaletteCreator::paletteScore() const
149 : {
150 0 : return paletteScoreProvider()->paletteScore();
151 : }
152 :
153 0 : PaletteTreePtr PaletteCreator::newMasterPaletteTree()
154 : {
155 0 : PaletteTreePtr tree = std::make_shared<PaletteTree>();
156 :
157 0 : tree->append(newClefsPalette());
158 0 : tree->append(newKeySigPalette());
159 0 : tree->append(newTimePalette());
160 0 : tree->append(newTempoPalette());
161 0 : tree->append(newPitchPalette());
162 0 : tree->append(newAccidentalsPalette());
163 0 : tree->append(newDynamicsPalette());
164 0 : tree->append(newArticulationsPalette());
165 0 : tree->append(newTextPalette());
166 0 : tree->append(newKeyboardPalette());
167 0 : tree->append(newRepeatsPalette());
168 0 : tree->append(newBarLinePalette());
169 0 : tree->append(newLayoutPalette());
170 0 : tree->append(newBracketsPalette());
171 0 : tree->append(newOrnamentsPalette());
172 0 : tree->append(newBreathPalette());
173 0 : tree->append(newGraceNotePalette());
174 0 : tree->append(newNoteHeadsPalette());
175 0 : tree->append(newArpeggioPalette());
176 0 : tree->append(newTremoloPalette());
177 0 : tree->append(newHarpPalette());
178 0 : tree->append(newGuitarPalette());
179 0 : tree->append(newFingeringPalette());
180 0 : tree->append(newFretboardDiagramPalette());
181 0 : tree->append(newAccordionPalette());
182 0 : tree->append(newBagpipeEmbellishmentPalette());
183 0 : tree->append(newHandbellsPalette());
184 0 : tree->append(newBeamPalette());
185 0 : tree->append(newLinesPalette());
186 :
187 0 : return tree;
188 0 : }
189 :
190 0 : PaletteTreePtr PaletteCreator::newDefaultPaletteTree()
191 : {
192 0 : PaletteTreePtr defaultPalette = std::make_shared<PaletteTree>();
193 :
194 0 : defaultPalette->append(newClefsPalette(true));
195 0 : defaultPalette->append(newKeySigPalette());
196 0 : defaultPalette->append(newTimePalette(true));
197 0 : defaultPalette->append(newTempoPalette(true));
198 0 : defaultPalette->append(newPitchPalette(true));
199 0 : defaultPalette->append(newAccidentalsPalette(true));
200 0 : defaultPalette->append(newDynamicsPalette(true));
201 0 : defaultPalette->append(newArticulationsPalette(true));
202 0 : defaultPalette->append(newTextPalette(true));
203 0 : defaultPalette->append(newKeyboardPalette());
204 0 : defaultPalette->append(newRepeatsPalette(true));
205 0 : defaultPalette->append(newBarLinePalette(true));
206 0 : defaultPalette->append(newLayoutPalette());
207 0 : defaultPalette->append(newBracketsPalette());
208 0 : defaultPalette->append(newOrnamentsPalette(true));
209 0 : defaultPalette->append(newBreathPalette(true));
210 0 : defaultPalette->append(newGraceNotePalette());
211 0 : defaultPalette->append(newNoteHeadsPalette());
212 0 : defaultPalette->append(newArpeggioPalette());
213 0 : defaultPalette->append(newTremoloPalette());
214 0 : defaultPalette->append(newHarpPalette());
215 0 : defaultPalette->append(newGuitarPalette(true));
216 0 : defaultPalette->append(newFingeringPalette(true));
217 0 : defaultPalette->append(newFretboardDiagramPalette(true));
218 0 : defaultPalette->append(newAccordionPalette());
219 0 : defaultPalette->append(newBagpipeEmbellishmentPalette());
220 0 : defaultPalette->append(newHandbellsPalette(true));
221 0 : defaultPalette->append(newBeamPalette());
222 0 : defaultPalette->append(newLinesPalette(true));
223 0 : return defaultPalette;
224 0 : }
225 :
226 0 : PalettePtr PaletteCreator::newBeamPalette()
227 : {
228 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Beam);
229 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Beam properties"));
230 0 : sp->setGridSize(35, 33);
231 0 : sp->setDrawGrid(true);
232 0 : sp->setVisible(false);
233 :
234 0 : sp->appendActionIcon(ActionIconType::BEAM_AUTO)->mag = 1.4;
235 0 : sp->appendActionIcon(ActionIconType::BEAM_NONE)->mag = 1.4;
236 0 : sp->appendActionIcon(ActionIconType::BEAM_BREAK_LEFT)->mag = 1.4;
237 0 : sp->appendActionIcon(ActionIconType::BEAM_BREAK_INNER_8TH)->mag = 1.4;
238 0 : sp->appendActionIcon(ActionIconType::BEAM_BREAK_INNER_16TH)->mag = 1.4;
239 0 : sp->appendActionIcon(ActionIconType::BEAM_JOIN)->mag = 1.4;
240 0 : sp->appendActionIcon(ActionIconType::BEAM_FEATHERED_DECELERATE)->mag = 1.4;
241 0 : sp->appendActionIcon(ActionIconType::BEAM_FEATHERED_ACCELERATE)->mag = 1.4;
242 :
243 0 : return sp;
244 0 : }
245 :
246 0 : PalettePtr PaletteCreator::newDynamicsPalette(bool defaultPalette)
247 : {
248 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Dynamic);
249 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Dynamics"));
250 0 : sp->setGridSize(defaultPalette ? 50 : 60, 28);
251 0 : sp->setDrawGrid(true);
252 :
253 : static const std::vector<const char*> defaultDynamics = {
254 : "ppp", "pp", "p", "mp", "mf", "f", "ff", "fff",
255 : "fp", "pf", "sf", "sfz", "sff", "sffz", "sfp",
256 : "rfz", "rf", "fz"
257 0 : };
258 :
259 : static const std::vector<const char*> masterDynamics = {
260 : "pppppp", "ppppp", "pppp",
261 : "ppp", "pp", "p", "mp", "mf", "f", "ff", "fff",
262 : "ffff", "fffff", "ffffff",
263 : "fp", "pf", "sf", "sfz", "sff", "sffz", "sfff", "sfffz",
264 : "sfp", "sfpp", "rfz", "rf", "fz", "m", "r", "s", "z", "n"
265 0 : };
266 :
267 0 : for (const char* dynamicType : defaultPalette ? defaultDynamics : masterDynamics) {
268 0 : auto dynamic = makeElement<Dynamic>(paletteScore());
269 0 : dynamic->setDynamicType(String::fromAscii(dynamicType));
270 0 : sp->appendElement(dynamic, TConv::userName(dynamic->dynamicType()));
271 0 : }
272 :
273 : static const std::vector<HairpinType> hairpins {
274 : HairpinType::CRESC_LINE,
275 : HairpinType::DIM_LINE,
276 : HairpinType::CRESC_HAIRPIN,
277 : HairpinType::DIM_HAIRPIN,
278 0 : };
279 :
280 0 : for (HairpinType hairpinType : hairpins) {
281 0 : auto hairpin = Factory::makeHairpin(paletteScore()->dummy());
282 0 : hairpin->setHairpinType(hairpinType);
283 0 : qreal mag = (hairpinType == HairpinType::CRESC_LINE || hairpinType == HairpinType::DIM_LINE) ? 1 : 0.9;
284 0 : const QPointF offset = hairpinType == HairpinType::CRESC_LINE ? QPointF(1, 0.25)
285 0 : : hairpinType == HairpinType::DIM_LINE ? QPointF(1, 0.0)
286 0 : : QPointF(0, 0);
287 0 : sp->appendElement(hairpin, hairpin->subtypeUserName(), mag, offset);
288 0 : }
289 :
290 0 : return sp;
291 0 : }
292 :
293 0 : PalettePtr PaletteCreator::newKeySigPalette()
294 : {
295 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::KeySig);
296 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Key signatures"));
297 0 : sp->setMag(0.8);
298 0 : sp->setGridSize(56, 47);
299 0 : sp->setDrawGrid(true);
300 0 : sp->setYOffset(1.0);
301 :
302 0 : for (int i = 0; i < 7; ++i) {
303 0 : auto k = Factory::makeKeySig(paletteScore()->dummy());
304 0 : k->setKey(Key(i + 1));
305 0 : sp->appendElement(k, TConv::userName(Key(i + 1)));
306 0 : }
307 0 : for (int i = -7; i < 0; ++i) {
308 0 : auto k = Factory::makeKeySig(paletteScore()->dummy());
309 0 : k->setKey(Key(i));
310 0 : sp->appendElement(k, TConv::userName(Key(i)));
311 0 : }
312 0 : auto k = Factory::makeKeySig(paletteScore()->dummy());
313 0 : k->setKey(Key::C);
314 0 : sp->appendElement(k, TConv::userName(Key::C));
315 :
316 : // atonal key signature
317 0 : KeySigEvent nke;
318 0 : nke.setConcertKey(Key::C);
319 0 : nke.setCustom(true);
320 0 : nke.setMode(KeyMode::NONE);
321 0 : auto nk = Factory::makeKeySig(paletteScore()->dummy());
322 0 : nk->setKeySigEvent(nke);
323 0 : sp->appendElement(nk, TConv::userName(Key::C, true));
324 :
325 0 : return sp;
326 0 : }
327 :
328 0 : PalettePtr PaletteCreator::newAccidentalsPalette(bool defaultPalette)
329 : {
330 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Accidental);
331 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Accidentals"));
332 0 : sp->setGridSize(33, 36);
333 0 : sp->setDrawGrid(true);
334 :
335 0 : int end = 0;
336 0 : if (defaultPalette) {
337 0 : end = int(AccidentalType::SHARP3);
338 : } else {
339 0 : end = int(AccidentalType::END);
340 : }
341 :
342 0 : for (int i = int(AccidentalType::FLAT); i < end; ++i) {
343 0 : auto ac = Factory::makeAccidental(paletteScore()->dummy());
344 0 : ac->setAccidentalType(AccidentalType(i));
345 0 : if (ac->symId() != SymId::noSym) {
346 0 : sp->appendElement(ac, ac->subtypeUserName());
347 : }
348 0 : }
349 :
350 0 : if (!defaultPalette) {
351 0 : sp->appendActionIcon(ActionIconType::PARENTHESES);
352 0 : sp->appendActionIcon(ActionIconType::BRACKETS);
353 : }
354 :
355 0 : return sp;
356 0 : }
357 :
358 0 : PalettePtr PaletteCreator::newBarLinePalette(bool defaultPalette)
359 : {
360 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::BarLine);
361 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Barlines"));
362 0 : sp->setMag(0.8);
363 0 : sp->setGridSize(48, 38);
364 0 : sp->setDrawGrid(true);
365 :
366 : // bar line styles
367 0 : for (const BarLineTableItem& bti : BarLine::barLineTable) {
368 0 : auto b = Factory::makeBarLine(paletteScore()->dummy());
369 0 : b->setBarLineType(bti.type);
370 0 : sp->appendElement(b, bti.userName);
371 0 : }
372 :
373 : // bar line spans
374 0 : if (!defaultPalette) {
375 : const struct {
376 : int from, to;
377 : muse::TranslatableString userName;
378 : } spans[] = {
379 : { BARLINE_SPAN_TICK1_FROM, BARLINE_SPAN_TICK1_TO, SymNames::userNameForSymId(SymId::barlineTick) },
380 : { BARLINE_SPAN_TICK2_FROM, BARLINE_SPAN_TICK2_TO, muse::TranslatableString("engraving/sym", "Tick barline 2") }, // Not in SMuFL
381 : { BARLINE_SPAN_SHORT1_FROM, BARLINE_SPAN_SHORT1_TO, SymNames::userNameForSymId(SymId::barlineShort) },
382 : { BARLINE_SPAN_SHORT2_FROM, BARLINE_SPAN_SHORT2_TO, muse::TranslatableString("engraving/sym", "Short barline 2") }, // Not in SMuFL
383 0 : };
384 0 : for (auto span : spans) {
385 0 : auto b = Factory::makeBarLine(paletteScore()->dummy());
386 0 : b->setBarLineType(BarLineType::NORMAL);
387 0 : b->setSpanFrom(span.from);
388 0 : b->setSpanTo(span.to);
389 0 : sp->appendElement(b, span.userName);
390 0 : }
391 0 : }
392 0 : return sp;
393 0 : }
394 :
395 0 : PalettePtr PaletteCreator::newRepeatsPalette(bool defaultPalette)
396 : {
397 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Repeat);
398 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Repeats & jumps"));
399 0 : sp->setMag(0.75);
400 0 : sp->setGridSize(100, 28);
401 0 : sp->setDrawGrid(true);
402 :
403 : struct MeasureRepeatInfo
404 : {
405 : SymId id = SymId::noSym;
406 : int measuresCount = 0;
407 : };
408 :
409 : const std::vector<MeasureRepeatInfo> defaultMeasureRepeats {
410 : { SymId::repeat1Bar, 1 }
411 0 : };
412 :
413 : const std::vector<MeasureRepeatInfo> masterMeasureRepeats {
414 : { SymId::repeat1Bar, 1 },
415 : { SymId::repeat2Bars, 2 },
416 : { SymId::repeat4Bars, 4 }
417 0 : };
418 :
419 0 : for (MeasureRepeatInfo repeat: defaultPalette ? defaultMeasureRepeats : masterMeasureRepeats) {
420 0 : std::shared_ptr<MeasureRepeat> rm = makeElement<MeasureRepeat>(paletteScore());
421 0 : rm->mutldata()->symId = repeat.id;
422 0 : rm->setNumMeasures(repeat.measuresCount);
423 0 : sp->appendElement(rm, SymNames::userNameForSymId(repeat.id));
424 0 : }
425 :
426 : const std::vector<MarkerType> defaultMarkers = {
427 : MarkerType::SEGNO, MarkerType::CODA, MarkerType::FINE, MarkerType::TOCODA, MarkerType::TOCODASYM
428 0 : };
429 :
430 : const std::vector<MarkerType> allMarkers = {
431 : MarkerType::SEGNO,
432 : MarkerType::VARSEGNO,
433 : MarkerType::CODA,
434 : MarkerType::VARCODA,
435 : MarkerType::CODETTA,
436 : MarkerType::FINE,
437 : MarkerType::TOCODA,
438 : MarkerType::TOCODASYM,
439 : MarkerType::DA_CODA,
440 : MarkerType::DA_DBLCODA,
441 : MarkerType::USER
442 0 : };
443 :
444 0 : for (MarkerType markerType : (defaultPalette ? defaultMarkers : allMarkers)) {
445 0 : if (markerType == MarkerType::CODETTA || markerType == MarkerType::USER) {// Codetta not in SMuFL
446 0 : continue;
447 : }
448 :
449 0 : auto mk = makeElement<Marker>(paletteScore());
450 0 : mk->setMarkerType(markerType);
451 0 : mk->styleChanged();
452 0 : sp->appendElement(mk, TConv::userName(markerType));
453 0 : }
454 :
455 : const std::vector<JumpTypeTableItem> defaultJumpTypeTable {
456 : { JumpType::DC, "D.C.", "start", "end", "" },
457 : { JumpType::DC_AL_FINE, "D.C. al Fine", "start", "fine", "" },
458 : { JumpType::DC_AL_CODA, "D.C. al Coda", "start", "coda", "codab" },
459 : { JumpType::DS_AL_CODA, "D.S. al Coda", "segno", "coda", "codab" },
460 : { JumpType::DS_AL_FINE, "D.S. al Fine", "segno", "fine", "" },
461 : { JumpType::DS, "D.S.", "segno", "end", "" },
462 0 : };
463 :
464 0 : for (const JumpTypeTableItem& item : (defaultPalette ? defaultJumpTypeTable : jumpTypeTable)) {
465 0 : auto jp = makeElement<Jump>(paletteScore());
466 0 : jp->setJumpType(item.type);
467 0 : sp->appendElement(jp, TConv::userName(item.type));
468 0 : }
469 :
470 0 : for (const BarLineTableItem& bti : BarLine::barLineTable) {
471 0 : switch (bti.type) {
472 0 : case BarLineType::START_REPEAT:
473 : case BarLineType::END_REPEAT:
474 : case BarLineType::END_START_REPEAT:
475 0 : break;
476 0 : default:
477 0 : continue;
478 : }
479 :
480 0 : auto b = Factory::makeBarLine(paletteScore()->dummy());
481 0 : b->setBarLineType(bti.type);
482 0 : PaletteCellPtr cell = sp->appendElement(b, bti.userName);
483 0 : cell->drawStaff = false;
484 0 : }
485 :
486 0 : auto volta = makeElement<Volta>(paletteScore());
487 0 : volta->setVoltaType(Volta::Type::CLOSED);
488 0 : volta->setText(u"1.");
489 0 : std::vector<int> il;
490 0 : il.push_back(1);
491 0 : volta->setEndings(il);
492 0 : sp->appendElement(volta, QT_TRANSLATE_NOOP("palette", "Prima volta"));
493 :
494 0 : volta = makeElement<Volta>(paletteScore());
495 0 : volta->setVoltaType(Volta::Type::OPEN);
496 0 : volta->setText(u"2.");
497 0 : il.clear();
498 0 : il.push_back(2);
499 0 : volta->setEndings(il);
500 0 : sp->appendElement(volta, QT_TRANSLATE_NOOP("palette", "Seconda volta, open"));
501 :
502 0 : volta = makeElement<Volta>(paletteScore());
503 0 : volta->setVoltaType(Volta::Type::CLOSED);
504 0 : volta->setText(u"2.");
505 0 : il.clear();
506 0 : il.push_back(2);
507 0 : volta->setEndings(il);
508 0 : sp->appendElement(volta, QT_TRANSLATE_NOOP("palette", "Seconda volta"));
509 :
510 0 : volta = makeElement<Volta>(paletteScore());
511 0 : volta->setVoltaType(Volta::Type::CLOSED);
512 0 : volta->setText(u"3.");
513 0 : il.clear();
514 0 : il.push_back(3);
515 0 : volta->setEndings(il);
516 0 : sp->appendElement(volta, QT_TRANSLATE_NOOP("palette", "Terza volta"));
517 :
518 0 : if (!defaultPalette) {
519 0 : auto vibrato = makeElement<Vibrato>(paletteScore());
520 0 : vibrato->setVibratoType(VibratoType::VIBRATO_SAWTOOTH);
521 0 : sp->appendElement(vibrato, TConv::userName(VibratoType::VIBRATO_SAWTOOTH));
522 :
523 0 : vibrato = makeElement<Vibrato>(paletteScore());
524 0 : vibrato->setVibratoType(VibratoType::VIBRATO_SAWTOOTH_WIDE);
525 0 : sp->appendElement(vibrato, TConv::userName(VibratoType::VIBRATO_SAWTOOTH_WIDE));
526 0 : }
527 :
528 0 : return sp;
529 0 : }
530 :
531 0 : PalettePtr PaletteCreator::newLayoutPalette()
532 : {
533 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Layout);
534 : //: The name of a palette
535 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Layout"));
536 0 : sp->setGridSize(42, 36);
537 0 : sp->setDrawGrid(true);
538 :
539 : static const std::vector<LayoutBreakType> layoutBreaks {
540 : LayoutBreakType::LINE,
541 : LayoutBreakType::PAGE,
542 : LayoutBreakType::SECTION,
543 : LayoutBreakType::NOBREAK
544 0 : };
545 0 : for (LayoutBreakType layoutBreakType : layoutBreaks) {
546 0 : auto lb = Factory::makeLayoutBreak(paletteScore()->dummy());
547 0 : lb->setLayoutBreakType(layoutBreakType);
548 0 : sp->appendElement(lb, TConv::userName(layoutBreakType));
549 0 : }
550 :
551 0 : sp->appendActionIcon(ActionIconType::SYSTEM_LOCK);
552 0 : sp->appendActionIcon(ActionIconType::PAGE_LOCK);
553 :
554 : static const std::vector<SpacerType> spacers {
555 : SpacerType::DOWN,
556 : SpacerType::UP,
557 : SpacerType::FIXED
558 0 : };
559 0 : for (SpacerType spacerType : spacers) {
560 0 : auto spacer = Factory::makeSpacer(paletteScore()->dummy());
561 0 : spacer->setSpacerType(spacerType);
562 0 : spacer->setGap(3_sp);
563 0 : PaletteCellPtr cell = sp->appendElement(spacer, spacer->subtypeUserName());
564 0 : cell->mag = .7;
565 0 : }
566 :
567 0 : sp->appendActionIcon(ActionIconType::VFRAME, FRAME_MAG);
568 0 : sp->appendActionIcon(ActionIconType::HFRAME, FRAME_MAG);
569 0 : sp->appendActionIcon(ActionIconType::TFRAME, FRAME_MAG);
570 0 : sp->appendActionIcon(ActionIconType::FFRAME, FRAME_MAG);
571 0 : sp->appendActionIcon(ActionIconType::STAFF_TYPE_CHANGE);
572 0 : sp->appendActionIcon(ActionIconType::MEASURE);
573 :
574 0 : return sp;
575 0 : }
576 :
577 0 : PalettePtr PaletteCreator::newFingeringPalette(bool defaultPalette)
578 : {
579 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Fingering);
580 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Fingerings"));
581 0 : sp->setMag(1.5);
582 0 : sp->setGridSize(28, 30);
583 0 : sp->setDrawGrid(true);
584 0 : sp->setVisible(false);
585 :
586 0 : const char* finger = "012345";
587 0 : for (unsigned i = 0; i < strlen(finger); ++i) {
588 0 : auto f = makeElement<Fingering>(paletteScore());
589 0 : f->setXmlText(QString(finger[i]));
590 0 : sp->appendElement(f, QT_TRANSLATE_NOOP("palette", "Fingering %1"));
591 0 : }
592 :
593 0 : finger = "pimac";
594 0 : for (unsigned i = 0; i < strlen(finger); ++i) {
595 0 : auto f = makeElement<Fingering>(paletteScore());
596 0 : f->setTextStyleType(TextStyleType::RH_GUITAR_FINGERING);
597 0 : f->setXmlText(QString(finger[i]));
598 0 : sp->appendElement(f, QT_TRANSLATE_NOOP("palette", "RH guitar fingering %1"));
599 0 : }
600 :
601 0 : finger = "012345T";
602 0 : for (unsigned i = 0; i < strlen(finger); ++i) {
603 0 : auto f = makeElement<Fingering>(paletteScore());
604 0 : f->setTextStyleType(TextStyleType::LH_GUITAR_FINGERING);
605 0 : f->setXmlText(QString(finger[i]));
606 0 : sp->appendElement(f, QT_TRANSLATE_NOOP("palette", "LH guitar fingering %1"));
607 0 : }
608 0 : finger = defaultPalette ? "123456" : "0123456789";
609 0 : for (unsigned i = 0; i < strlen(finger); ++i) {
610 0 : auto f = makeElement<Fingering>(paletteScore());
611 0 : f->initTextStyleType(TextStyleType::STRING_NUMBER);
612 0 : f->setXmlText(QString(finger[i]));
613 0 : sp->appendElement(f, QT_TRANSLATE_NOOP("palette", "String number %1"));
614 0 : }
615 :
616 : static const SymIdList defaultLute {
617 : SymId::stringsThumbPosition
618 0 : };
619 : static const SymIdList masterLute {
620 : SymId::stringsThumbPosition,
621 : SymId::luteFingeringRHThumb, SymId::luteFingeringRHFirst,
622 : SymId::luteFingeringRHSecond, SymId::luteFingeringRHThird
623 0 : };
624 : // include additional symbol-based fingerings (temporarily?) implemented as articulations
625 0 : for (auto i : defaultPalette ? defaultLute : masterLute) {
626 0 : auto s = Factory::makeArticulation(paletteScore()->dummy());
627 0 : s->setSymId(i);
628 0 : sp->appendElement(s, s->subtypeUserName());
629 0 : }
630 0 : return sp;
631 0 : }
632 :
633 0 : PalettePtr PaletteCreator::newTremoloPalette()
634 : {
635 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Tremolo);
636 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Tremolos"));
637 0 : sp->setGridSize(27, 40);
638 0 : sp->setDrawGrid(true);
639 0 : sp->setVisible(false);
640 :
641 0 : for (int i = int(TremoloType::R8); i <= int(TremoloType::BUZZ_ROLL); ++i) {
642 0 : auto tremolo = Factory::makeTremoloSingleChord(paletteScore()->dummy());
643 0 : tremolo->setTremoloType(TremoloType(i));
644 0 : sp->appendElement(tremolo, tremolo->subtypeUserName());
645 0 : }
646 :
647 0 : for (int i = int(TremoloType::C8); i <= int(TremoloType::C256); ++i) {
648 0 : auto tremolo = Factory::makeTremoloTwoChord(paletteScore()->dummy());
649 0 : tremolo->setTremoloType(TremoloType(i));
650 0 : sp->appendElement(tremolo, tremolo->subtypeUserName());
651 0 : }
652 :
653 : static const SymIdList dots {
654 : SymId::tremoloDivisiDots2,
655 : SymId::tremoloDivisiDots3,
656 : SymId::tremoloDivisiDots4,
657 : SymId::tremoloDivisiDots6
658 0 : };
659 : // include additional symbol-based tremolo articulations, implemented as articulations
660 0 : for (auto i : dots) {
661 0 : auto s = Factory::makeArticulation(paletteScore()->dummy());
662 0 : s->setSymId(i);
663 0 : sp->appendElement(s, s->subtypeUserName());
664 0 : }
665 0 : return sp;
666 0 : }
667 :
668 0 : PalettePtr PaletteCreator::newNoteHeadsPalette()
669 : {
670 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::NoteHead);
671 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Noteheads"));
672 0 : sp->setMag(1.3);
673 0 : sp->setGridSize(33, 36);
674 0 : sp->setDrawGrid(true);
675 0 : sp->setVisible(false);
676 :
677 0 : for (int i = 0; i < int(NoteHeadGroup::HEAD_DO_WALKER); ++i) {
678 0 : SymId sym = Note::noteHead(0, NoteHeadGroup(i), NoteHeadType::HEAD_HALF);
679 : // HEAD_BREVIS_ALT shows up only for brevis value
680 0 : if (i == int(NoteHeadGroup::HEAD_BREVIS_ALT)) {
681 0 : sym = Note::noteHead(0, NoteHeadGroup(i), NoteHeadType::HEAD_BREVIS);
682 : }
683 0 : auto nh = makeElement<NoteHead>(paletteScore());
684 0 : nh->setSym(sym);
685 0 : sp->appendElement(nh, TConv::userName((NoteHeadGroup(i))));
686 0 : }
687 :
688 0 : sp->appendActionIcon(ActionIconType::PARENTHESES);
689 :
690 0 : return sp;
691 0 : }
692 :
693 0 : PalettePtr PaletteCreator::newArticulationsPalette(bool defaultPalette)
694 : {
695 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Articulation);
696 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Articulations"));
697 0 : sp->setGridSize(42, 25);
698 0 : sp->setDrawGrid(true);
699 :
700 0 : auto slur = Factory::makeSlur(paletteScore()->dummy());
701 0 : sp->appendElement(slur, QT_TRANSLATE_NOOP("palette", "Slur"));
702 :
703 : // do not include additional symbol-based fingerings (temporarily?) implemented as articulations
704 : static const SymIdList defaultArticulations {
705 : SymId::articAccentAbove,
706 : SymId::articStaccatoAbove,
707 : SymId::articStaccatissimoAbove,
708 : SymId::articTenutoAbove,
709 : SymId::articTenutoStaccatoAbove,
710 : SymId::articMarcatoAbove,
711 : SymId::articAccentStaccatoAbove,
712 : SymId::articMarcatoStaccatoAbove,
713 : SymId::articMarcatoTenutoAbove,
714 : SymId::articStaccatissimoStrokeAbove,
715 : SymId::articStaccatissimoWedgeAbove,
716 : SymId::articStressAbove,
717 : SymId::articTenutoAccentAbove,
718 : SymId::articUnstressAbove,
719 : SymId::brassMuteOpen,
720 : SymId::brassMuteClosed,
721 : SymId::stringsHarmonic,
722 : SymId::stringsUpBow,
723 : SymId::stringsDownBow
724 0 : };
725 :
726 : static const SymIdList masterArticulations {
727 : SymId::articAccentAbove,
728 : SymId::articStaccatoAbove,
729 : SymId::articStaccatissimoAbove,
730 : SymId::articTenutoAbove,
731 : SymId::articTenutoStaccatoAbove,
732 : SymId::articMarcatoAbove,
733 : SymId::articAccentStaccatoAbove,
734 : SymId::articMarcatoStaccatoAbove,
735 : SymId::articMarcatoTenutoAbove,
736 : SymId::articStaccatissimoStrokeAbove,
737 : SymId::articStaccatissimoWedgeAbove,
738 : SymId::articStressAbove,
739 : SymId::articTenutoAccentAbove,
740 : SymId::articUnstressAbove,
741 :
742 : SymId::articSoftAccentAbove, // supplemental articulations
743 : SymId::articSoftAccentStaccatoAbove,
744 : SymId::articSoftAccentTenutoAbove,
745 : SymId::articSoftAccentTenutoStaccatoAbove,
746 :
747 : SymId::guitarFadeIn,
748 : SymId::guitarFadeOut,
749 : SymId::guitarVolumeSwell,
750 : SymId::wiggleSawtooth,
751 : SymId::wiggleSawtoothWide,
752 : SymId::wiggleVibratoLargeFaster,
753 : SymId::wiggleVibratoLargeSlowest,
754 : SymId::brassMuteOpen,
755 : SymId::brassMuteClosed,
756 : SymId::stringsHarmonic,
757 : SymId::stringsUpBow,
758 : SymId::stringsDownBow,
759 : SymId::pluckedSnapPizzicatoAbove,
760 : SymId::pictHalfOpen2,
761 : // SymId::stringsThumbPosition,
762 : // SymId::luteFingeringRHThumb,
763 : // SymId::luteFingeringRHFirst,
764 : // SymId::luteFingeringRHSecond,
765 : // SymId::luteFingeringRHThird,
766 0 : };
767 :
768 0 : for (SymId articulationType : defaultPalette ? defaultArticulations : masterArticulations) {
769 0 : auto artic = Factory::makeArticulation(paletteScore()->dummy());
770 0 : artic->setSymId(articulationType);
771 0 : sp->appendElement(artic, artic->subtypeUserName());
772 0 : }
773 :
774 0 : return sp;
775 0 : }
776 :
777 0 : PalettePtr PaletteCreator::newOrnamentsPalette(bool defaultPalette)
778 : {
779 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Ornament);
780 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Ornaments"));
781 0 : sp->setGridSize(73, 27);
782 0 : sp->setMag(1);
783 0 : sp->setDrawGrid(true);
784 0 : sp->setVisible(false);
785 :
786 : static const SymIdList defaultOrnaments {
787 : SymId::ornamentTurn,
788 : SymId::ornamentTurnInverted,
789 : SymId::ornamentTrill,
790 : SymId::ornamentShortTrill,
791 : SymId::ornamentMordent
792 0 : };
793 :
794 : static const SymIdList masterOrnaments {
795 : SymId::ornamentTurn,
796 : SymId::ornamentTurnInverted,
797 : SymId::ornamentTurnSlash,
798 : SymId::ornamentTurnUp,
799 : SymId::ornamentTurnUpS,
800 : SymId::ornamentTrill,
801 : SymId::ornamentShortTrill,
802 : SymId::ornamentMordent,
803 : SymId::ornamentHaydn,
804 : SymId::ornamentTremblement,
805 : SymId::ornamentPrallMordent,
806 : SymId::ornamentUpPrall,
807 : SymId::ornamentPrecompMordentUpperPrefix, // SymId::ornamentDownPrall,
808 : SymId::ornamentUpMordent,
809 : SymId::ornamentDownMordent,
810 : SymId::ornamentPrallDown,
811 : SymId::ornamentPrallUp,
812 : SymId::ornamentLinePrall,
813 : SymId::ornamentPrecompSlide,
814 : SymId::ornamentShake3,
815 : SymId::ornamentShakeMuffat1,
816 : SymId::ornamentTremblementCouperin,
817 : SymId::ornamentPinceCouperin
818 0 : };
819 :
820 0 : for (auto ornamentType : defaultPalette ? defaultOrnaments : masterOrnaments) {
821 0 : auto ornament = Factory::makeOrnament(paletteScore()->dummy());
822 0 : ornament->setSymId(ornamentType);
823 0 : qreal mag = ornament->symId() == SymId::ornamentTrill ? 1.0 : 1.2;
824 0 : sp->appendElement(ornament, ornament->subtypeUserName(), mag);
825 0 : }
826 :
827 : static const std::vector<TrillType> trillTypes = {
828 : TrillType::TRILL_LINE, TrillType::UPPRALL_LINE, TrillType::DOWNPRALL_LINE, TrillType::PRALLPRALL_LINE,
829 0 : };
830 :
831 0 : for (TrillType trillType : trillTypes) {
832 0 : auto trill = makeElement<Trill>(paletteScore());
833 0 : trill->setTrillType(trillType);
834 :
835 0 : qreal mag = (trillType == TrillType::TRILL_LINE || trillType == TrillType::PRALLPRALL_LINE) ? 1.0 : 0.8;
836 0 : sp->appendElement(trill, TConv::userName(trillType), mag);
837 0 : }
838 :
839 0 : return sp;
840 0 : }
841 :
842 0 : PalettePtr PaletteCreator::newAccordionPalette()
843 : {
844 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Accordion);
845 : //: The name of a palette
846 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Accordion"));
847 0 : sp->setGridSize(42, 25);
848 0 : sp->setDrawGrid(true);
849 0 : sp->setVisible(false);
850 :
851 : static const SymIdList art {
852 : SymId::accdnCombDot,
853 : SymId::accdnCombLH2RanksEmpty,
854 : SymId::accdnCombLH3RanksEmptySquare,
855 : SymId::accdnCombRH3RanksEmpty,
856 : SymId::accdnCombRH4RanksEmpty,
857 : SymId::accdnDiatonicClef,
858 : SymId::accdnLH2Ranks16Round,
859 : SymId::accdnLH2Ranks8Plus16Round,
860 : SymId::accdnLH2Ranks8Round,
861 : SymId::accdnLH2RanksFullMasterRound,
862 :
863 : SymId::accdnLH2RanksMasterPlus16Round,
864 : SymId::accdnLH2RanksMasterRound,
865 : SymId::accdnLH3Ranks2Plus8Square,
866 : SymId::accdnLH3Ranks2Square,
867 : SymId::accdnLH3Ranks8Square,
868 : SymId::accdnLH3RanksDouble8Square,
869 : SymId::accdnLH3RanksTuttiSquare,
870 : SymId::accdnPull,
871 : SymId::accdnPush,
872 : SymId::accdnRH3RanksAccordion,
873 :
874 : SymId::accdnRH3RanksAuthenticMusette,
875 : SymId::accdnRH3RanksBandoneon,
876 : SymId::accdnRH3RanksBassoon,
877 : SymId::accdnRH3RanksClarinet,
878 : SymId::accdnRH3RanksDoubleTremoloLower8ve,
879 : SymId::accdnRH3RanksDoubleTremoloUpper8ve,
880 : SymId::accdnRH3RanksFullFactory,
881 : SymId::accdnRH3RanksHarmonium,
882 : SymId::accdnRH3RanksImitationMusette,
883 : SymId::accdnRH3RanksLowerTremolo8,
884 :
885 : SymId::accdnRH3RanksMaster,
886 : SymId::accdnRH3RanksOboe,
887 : SymId::accdnRH3RanksOrgan,
888 : SymId::accdnRH3RanksPiccolo,
889 : SymId::accdnRH3RanksTremoloLower8ve,
890 : SymId::accdnRH3RanksTremoloUpper8ve,
891 : SymId::accdnRH3RanksTwoChoirs,
892 : SymId::accdnRH3RanksUpperTremolo8,
893 : SymId::accdnRH3RanksViolin,
894 : SymId::accdnRH4RanksAlto,
895 :
896 : SymId::accdnRH4RanksBassAlto,
897 : SymId::accdnRH4RanksMaster,
898 : SymId::accdnRH4RanksSoftBass,
899 : SymId::accdnRH4RanksSoftTenor,
900 : SymId::accdnRH4RanksSoprano,
901 : SymId::accdnRH4RanksTenor,
902 : SymId::accdnRicochet2,
903 : SymId::accdnRicochet3,
904 : SymId::accdnRicochet4,
905 : SymId::accdnRicochet5,
906 :
907 : SymId::accdnRicochet6,
908 : SymId::accdnRicochetStem2,
909 : SymId::accdnRicochetStem3,
910 : SymId::accdnRicochetStem4,
911 : SymId::accdnRicochetStem5,
912 : SymId::accdnRicochetStem6
913 0 : };
914 0 : for (auto i : art) {
915 0 : auto s = makeElement<Symbol>(paletteScore());
916 0 : s->setSym(i);
917 0 : sp->appendElement(s, SymNames::userNameForSymId(i));
918 0 : }
919 0 : return sp;
920 0 : }
921 :
922 0 : PalettePtr PaletteCreator::newBracketsPalette()
923 : {
924 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Bracket);
925 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Brackets"));
926 0 : sp->setMag(0.7);
927 0 : sp->setGridSize(40, 80);
928 0 : sp->setDrawGrid(true);
929 0 : sp->setVisible(false);
930 :
931 0 : const std::array<std::pair<BracketType, const char*>, 5> types { {
932 : { BracketType::NORMAL, QT_TRANSLATE_NOOP("palette", "Bracket") },
933 : { BracketType::BRACE, QT_TRANSLATE_NOOP("palette", "Brace") },
934 : { BracketType::SQUARE, QT_TRANSLATE_NOOP("palette", "Square") },
935 : { BracketType::LINE, QT_TRANSLATE_NOOP("palette", "Line") },
936 : { BracketType::GROUP, QT_TRANSLATE_NOOP("palette", "Group bracket") }
937 : } };
938 :
939 : static Part* bracketItemOwnerPart = nullptr;
940 : static Staff* bracketItemOwner = nullptr;
941 0 : if (!bracketItemOwner) {
942 0 : bracketItemOwnerPart = new Part(paletteScore());
943 0 : bracketItemOwner = Factory::createStaff(bracketItemOwnerPart);
944 0 : paletteScore()->appendStaff(bracketItemOwner);
945 : }
946 :
947 0 : EditStaffBrackets::setBracketType(paletteScore(), bracketItemOwner->idx(), types.size() - 1, BracketType::NORMAL);
948 :
949 0 : for (size_t i = 0; i < types.size(); ++i) {
950 0 : auto b1 = Factory::makeBracket(paletteScore()->dummy());
951 0 : auto bi1 = paletteScore()->brackets(bracketItemOwner->idx())[i];
952 0 : const auto& type = types[i];
953 0 : bi1->setBracketType(type.first);
954 0 : b1->setBracketItem(bi1);
955 0 : sp->appendElement(b1, type.second); // Bracket, Brace, Square, Line, Group
956 0 : }
957 0 : return sp;
958 0 : }
959 :
960 0 : PalettePtr PaletteCreator::newBreathPalette(bool defaultPalette)
961 : {
962 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Breath);
963 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Breaths & pauses"));
964 0 : sp->setGridSize(40, 40);
965 0 : sp->setDrawGrid(true);
966 0 : sp->setVisible(false);
967 :
968 : // Fermatas
969 :
970 : static const SymIdList defaultFermatas {
971 : SymId::fermataAbove,
972 : SymId::fermataShortAbove,
973 : SymId::fermataLongAbove
974 0 : };
975 :
976 : static const SymIdList masterFermatas {
977 : SymId::fermataAbove,
978 : SymId::fermataShortAbove,
979 : SymId::fermataLongAbove,
980 : SymId::fermataLongHenzeAbove,
981 : SymId::fermataShortHenzeAbove,
982 : SymId::fermataVeryLongAbove,
983 : SymId::fermataVeryShortAbove,
984 0 : };
985 :
986 : // Breaths
987 :
988 0 : for (auto i : defaultPalette ? defaultFermatas : masterFermatas) {
989 0 : auto f = Factory::makeFermata(paletteScore()->dummy());
990 0 : f->setSymIdAndTimeStretch(i);
991 0 : sp->appendElement(f, f->subtypeUserName());
992 0 : }
993 :
994 0 : for (BreathType breath : Breath::BREATH_LIST) {
995 0 : if ((breath.id == SymId::chantCaesura || breath.id == SymId::caesuraSingleStroke) && defaultPalette) {
996 0 : continue;
997 : }
998 0 : auto a = Factory::makeBreath(paletteScore()->dummy());
999 0 : a->setSymId(breath.id);
1000 0 : a->setPause(breath.pause);
1001 0 : sp->appendElement(a, SymNames::userNameForSymId(breath.id));
1002 0 : }
1003 :
1004 0 : return sp;
1005 0 : }
1006 :
1007 0 : PalettePtr PaletteCreator::newArpeggioPalette()
1008 : {
1009 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Arpeggio);
1010 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Arpeggios & glissandos"));
1011 0 : sp->setGridSize(42, 44);
1012 0 : sp->setDrawGrid(true);
1013 0 : sp->setVisible(false);
1014 :
1015 0 : for (int i = 0; i < 6; ++i) {
1016 0 : if (ArpeggioType(i) == ArpeggioType::BRACKET) {
1017 : // Deprecated, now handled by CHORD_BRACKET
1018 0 : continue;
1019 : }
1020 0 : auto a = Factory::makeArpeggio(paletteScore()->dummy());
1021 0 : a->setArpeggioType(ArpeggioType(i));
1022 0 : sp->appendElement(a, a->arpeggioTypeName());
1023 0 : }
1024 :
1025 0 : for (int i = 0; i < 2; ++i) {
1026 0 : auto a = makeElement<Glissando>(paletteScore());
1027 0 : a->setGlissandoType(GlissandoType(i));
1028 0 : if (a->glissandoType() != a->style().styleV(Sid::glissandoType).value<GlissandoType>()) {
1029 0 : a->setPropertyFlags(Pid::GLISS_TYPE, PropertyFlags::UNSTYLED);
1030 : }
1031 0 : sp->appendElement(a, a->subtypeUserName());
1032 0 : }
1033 :
1034 : //fall and doits
1035 :
1036 : static const std::vector<ChordLineType> chordLineTypes {
1037 : ChordLineType::FALL,
1038 : ChordLineType::DOIT,
1039 : ChordLineType::PLOP,
1040 : ChordLineType::SCOOP
1041 0 : };
1042 :
1043 0 : for (ChordLineType chordLineType : chordLineTypes) {
1044 0 : auto cl = Factory::makeChordLine(paletteScore()->dummy());
1045 0 : cl->setChordLineType(chordLineType);
1046 0 : sp->appendElement(cl, cl->chordLineTypeName());
1047 0 : }
1048 :
1049 0 : for (ChordLineType chordLineType : chordLineTypes) {
1050 0 : auto cl = Factory::makeChordLine(paletteScore()->dummy());
1051 0 : cl->setChordLineType(chordLineType);
1052 0 : cl->setStraight(true);
1053 0 : sp->appendElement(cl, cl->chordLineTypeName());
1054 0 : }
1055 :
1056 0 : for (ChordLineType chordLineType : chordLineTypes) {
1057 0 : auto cl = Factory::makeChordLine(paletteScore()->dummy());
1058 0 : cl->setChordLineType(chordLineType);
1059 0 : cl->setStraight(true);
1060 0 : cl->setWavy(true);
1061 0 : sp->appendElement(cl, cl->chordLineTypeName());
1062 0 : }
1063 0 : return sp;
1064 0 : }
1065 :
1066 0 : PalettePtr PaletteCreator::newClefsPalette(bool defaultPalette)
1067 : {
1068 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Clef);
1069 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Clefs"));
1070 0 : sp->setMag(0.8);
1071 0 : sp->setGridSize(36, 55);
1072 0 : sp->setDrawGrid(true);
1073 0 : sp->setYOffset(1.0);
1074 :
1075 : static const std::vector<ClefType> clefsDefault {
1076 : ClefType::G, ClefType::G8_VA, ClefType::G15_MA, ClefType::G8_VB, ClefType::C3,
1077 : ClefType::C4, ClefType::F, ClefType::F_8VA,
1078 : ClefType::F8_VB, ClefType::PERC, ClefType::TAB, ClefType::TAB4
1079 0 : };
1080 : static const std::vector<ClefType> clefsMaster {
1081 : ClefType::G, ClefType::G8_VA, ClefType::G15_MA, ClefType::G8_VB, ClefType::G15_MB, ClefType::G8_VB_O,
1082 : ClefType::G8_VB_C, ClefType::G8_VB_P, ClefType::G_1, ClefType::C1, ClefType::C2, ClefType::C3,
1083 : ClefType::C4, ClefType::C4_8VB, ClefType::C5, ClefType::C_19C, ClefType::C1_F18C, ClefType::C3_F18C, ClefType::C4_F18C,
1084 : ClefType::C1_F20C, ClefType::C3_F20C, ClefType::C4_F20C,
1085 : ClefType::F, ClefType::F_8VA, ClefType::F_15MA,
1086 : ClefType::F8_VB, ClefType::F15_MB, ClefType::F_B, ClefType::F_C, ClefType::F_F18C, ClefType::F_19C,
1087 : ClefType::PERC,
1088 : ClefType::PERC2, ClefType::TAB, ClefType::TAB4, ClefType::TAB_SERIF, ClefType::TAB4_SERIF
1089 0 : };
1090 :
1091 0 : for (ClefType clefType : defaultPalette ? clefsDefault : clefsMaster) {
1092 0 : auto clef = Factory::makeClef(paletteScore()->dummy());
1093 0 : clef->setClefType(ClefTypeList(clefType, clefType));
1094 0 : sp->appendElement(clef, TConv::userName(clefType));
1095 0 : }
1096 0 : return sp;
1097 0 : }
1098 :
1099 0 : PalettePtr PaletteCreator::newGraceNotePalette()
1100 : {
1101 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::GraceNote);
1102 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Grace notes"));
1103 0 : sp->setMag(1.35);
1104 0 : sp->setGridSize(45, 40);
1105 0 : sp->setDrawGrid(true);
1106 0 : sp->setVisible(false);
1107 :
1108 0 : sp->appendActionIcon(ActionIconType::ACCIACCATURA);
1109 0 : sp->appendActionIcon(ActionIconType::APPOGGIATURA);
1110 0 : sp->appendActionIcon(ActionIconType::GRACE4);
1111 0 : sp->appendActionIcon(ActionIconType::GRACE16);
1112 0 : sp->appendActionIcon(ActionIconType::GRACE32);
1113 0 : sp->appendActionIcon(ActionIconType::GRACE8_AFTER);
1114 0 : sp->appendActionIcon(ActionIconType::GRACE16_AFTER);
1115 0 : sp->appendActionIcon(ActionIconType::GRACE32_AFTER);
1116 :
1117 0 : return sp;
1118 0 : }
1119 :
1120 0 : PalettePtr PaletteCreator::newBagpipeEmbellishmentPalette()
1121 : {
1122 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::BagpipeEmbellishment);
1123 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Bagpipe embellishments"));
1124 0 : sp->setMag(0.8);
1125 0 : sp->setYOffset(2.0);
1126 0 : sp->setGridSize(55, 72);
1127 0 : sp->setDrawGrid(true);
1128 0 : sp->setVisible(false);
1129 :
1130 0 : for (size_t i = 0; i < TConv::embellishmentsCount(); ++i) {
1131 0 : auto b = makeElement<BagpipeEmbellishment>(paletteScore());
1132 0 : b->setEmbelType(EmbellishmentType(i));
1133 : // TODO: pass TranslatableString
1134 0 : sp->appendElement(b, TConv::userName(static_cast<EmbellishmentType>(i)).str);
1135 0 : }
1136 :
1137 0 : return sp;
1138 0 : }
1139 :
1140 0 : PalettePtr PaletteCreator::newLinesPalette(bool defaultPalette)
1141 : {
1142 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Line);
1143 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Lines"));
1144 0 : sp->setMag(.8);
1145 0 : sp->setGridSize(75, 28);
1146 0 : sp->setDrawGrid(true);
1147 0 : sp->setVisible(false);
1148 :
1149 0 : auto slur = Factory::makeSlur(paletteScore()->dummy());
1150 0 : sp->appendElement(slur, QT_TRANSLATE_NOOP("palette", "Slur"));
1151 :
1152 : static const std::vector<HairpinType> hairpins {
1153 : HairpinType::CRESC_HAIRPIN,
1154 : HairpinType::DIM_HAIRPIN,
1155 : HairpinType::CRESC_LINE,
1156 : HairpinType::DIM_LINE
1157 0 : };
1158 :
1159 0 : for (HairpinType hairpinType : hairpins) {
1160 0 : auto hairpin = Factory::makeHairpin(paletteScore()->dummy());
1161 0 : hairpin->setHairpinType(hairpinType);
1162 0 : sp->appendElement(hairpin, hairpin->subtypeUserName());
1163 0 : }
1164 :
1165 0 : auto volta = makeElement<Volta>(paletteScore());
1166 0 : volta->setVoltaType(Volta::Type::CLOSED);
1167 0 : volta->setText(u"1.");
1168 0 : std::vector<int> il;
1169 0 : il.push_back(1);
1170 0 : volta->setEndings(il);
1171 0 : sp->appendElement(volta, QT_TRANSLATE_NOOP("palette", "Prima volta"));
1172 :
1173 0 : if (!defaultPalette) {
1174 0 : volta = makeElement<Volta>(paletteScore());
1175 0 : volta->setVoltaType(Volta::Type::CLOSED);
1176 0 : volta->setText(u"2.");
1177 0 : il.clear();
1178 0 : il.push_back(2);
1179 0 : volta->setEndings(il);
1180 0 : sp->appendElement(volta, QT_TRANSLATE_NOOP("palette", "Seconda volta"));
1181 :
1182 0 : volta = makeElement<Volta>(paletteScore());
1183 0 : volta->setVoltaType(Volta::Type::CLOSED);
1184 0 : volta->setText(u"3.");
1185 0 : il.clear();
1186 0 : il.push_back(3);
1187 0 : volta->setEndings(il);
1188 0 : sp->appendElement(volta, QT_TRANSLATE_NOOP("palette", "Terza volta"));
1189 : }
1190 :
1191 0 : volta = makeElement<Volta>(paletteScore());
1192 0 : volta->setVoltaType(Volta::Type::OPEN);
1193 0 : volta->setText(u"2.");
1194 0 : il.clear();
1195 0 : il.push_back(2);
1196 0 : volta->setEndings(il);
1197 0 : sp->appendElement(volta, QT_TRANSLATE_NOOP("palette", "Seconda volta, open"));
1198 :
1199 : static const std::vector<OttavaType> ottavasDefault {
1200 : OttavaType::OTTAVA_8VA,
1201 : OttavaType::OTTAVA_8VB,
1202 : OttavaType::OTTAVA_15MA
1203 0 : };
1204 : static const std::vector<OttavaType> ottavasMaster {
1205 : OttavaType::OTTAVA_8VA,
1206 : OttavaType::OTTAVA_8VB,
1207 : OttavaType::OTTAVA_15MA,
1208 : OttavaType::OTTAVA_15MB,
1209 : OttavaType::OTTAVA_22MA,
1210 : OttavaType::OTTAVA_22MB
1211 0 : };
1212 0 : for (OttavaType ottavaType : defaultPalette ? ottavasDefault : ottavasMaster) {
1213 0 : auto ottava = makeElement<Ottava>(paletteScore());
1214 0 : ottava->setOttavaType(ottavaType);
1215 0 : ottava->styleChanged();
1216 0 : sp->appendElement(ottava, ottava->subtypeUserName());
1217 0 : }
1218 :
1219 0 : auto pedal = makeElement<Pedal>(paletteScore());
1220 0 : pedal->setEndHookType(HookType::HOOK_90);
1221 0 : pedal->setBeginText(pedal->propertyDefault(Pid::BEGIN_TEXT).value<String>());
1222 0 : pedal->setContinueText(pedal->propertyDefault(Pid::CONTINUE_TEXT).value<String>());
1223 0 : pedal->setEndText(pedal->propertyDefault(Pid::END_TEXT).value<String>());
1224 0 : sp->appendElement(pedal, QT_TRANSLATE_NOOP("palette", "Pedal (with ped and line)"));
1225 :
1226 0 : pedal = makeElement<Pedal>(paletteScore());
1227 0 : pedal->setLineVisible(false);
1228 0 : pedal->setEndHookType(HookType::ROSETTE);
1229 0 : pedal->setBeginText(pedal->propertyDefault(Pid::BEGIN_TEXT).value<String>());
1230 0 : pedal->setContinueText(pedal->propertyDefault(Pid::CONTINUE_TEXT).value<String>());
1231 0 : pedal->setEndText(pedal->propertyDefault(Pid::END_TEXT).value<String>());
1232 0 : sp->appendElement(pedal, QT_TRANSLATE_NOOP("palette", "Pedal (with ped and asterisk)"));
1233 :
1234 0 : pedal = makeElement<Pedal>(paletteScore());
1235 0 : pedal->setBeginHookType(HookType::HOOK_90);
1236 0 : pedal->setEndHookType(HookType::HOOK_90);
1237 0 : pedal->setBeginText(pedal->propertyDefault(Pid::BEGIN_TEXT).value<String>());
1238 0 : pedal->setContinueText(pedal->propertyDefault(Pid::CONTINUE_TEXT).value<String>());
1239 0 : pedal->setEndText(pedal->propertyDefault(Pid::END_TEXT).value<String>());
1240 0 : sp->appendElement(pedal, QT_TRANSLATE_NOOP("palette", "Pedal (straight hooks)"));
1241 :
1242 0 : if (!defaultPalette) {
1243 0 : pedal = makeElement<Pedal>(paletteScore());
1244 0 : pedal->setBeginHookType(HookType::HOOK_90);
1245 0 : pedal->setEndHookType(HookType::HOOK_45);
1246 0 : pedal->setBeginText(pedal->propertyDefault(Pid::BEGIN_TEXT).value<String>());
1247 0 : pedal->setContinueText(pedal->propertyDefault(Pid::CONTINUE_TEXT).value<String>());
1248 0 : pedal->setEndText(pedal->propertyDefault(Pid::END_TEXT).value<String>());
1249 0 : sp->appendElement(pedal, QT_TRANSLATE_NOOP("palette", "Pedal (angled end hook)"));
1250 :
1251 0 : pedal = makeElement<Pedal>(paletteScore());
1252 0 : pedal->setBeginHookType(HookType::HOOK_45);
1253 0 : pedal->setEndHookType(HookType::HOOK_45);
1254 0 : pedal->setBeginText(pedal->propertyDefault(Pid::BEGIN_TEXT).value<String>());
1255 0 : pedal->setContinueText(pedal->propertyDefault(Pid::CONTINUE_TEXT).value<String>());
1256 0 : pedal->setEndText(pedal->propertyDefault(Pid::END_TEXT).value<String>());
1257 0 : sp->appendElement(pedal, QT_TRANSLATE_NOOP("palette", "Pedal (both hooks angled)"));
1258 :
1259 0 : pedal = makeElement<Pedal>(paletteScore());
1260 0 : pedal->setBeginHookType(HookType::HOOK_45);
1261 0 : pedal->setEndHookType(HookType::HOOK_90);
1262 0 : pedal->setBeginText(pedal->propertyDefault(Pid::BEGIN_TEXT).value<String>());
1263 0 : pedal->setContinueText(pedal->propertyDefault(Pid::CONTINUE_TEXT).value<String>());
1264 0 : pedal->setEndText(pedal->propertyDefault(Pid::END_TEXT).value<String>());
1265 0 : sp->appendElement(pedal, QT_TRANSLATE_NOOP("palette", "Pedal (angled start hook)"));
1266 : }
1267 :
1268 : static const std::vector<TrillType> trillTypes = {
1269 : TrillType::TRILL_LINE, TrillType::UPPRALL_LINE, TrillType::DOWNPRALL_LINE, TrillType::PRALLPRALL_LINE,
1270 0 : };
1271 :
1272 : static const std::vector<TrillType> defaultTrills = {
1273 : { TrillType::TRILL_LINE, TrillType::DOWNPRALL_LINE, TrillType::PRALLPRALL_LINE }
1274 0 : };
1275 :
1276 0 : for (TrillType trillType : defaultPalette ? defaultTrills : trillTypes) {
1277 0 : auto trill = makeElement<Trill>(paletteScore());
1278 0 : trill->setTrillType(trillType);
1279 0 : sp->appendElement(trill, TConv::userName(trillType));
1280 0 : }
1281 :
1282 0 : auto staffTextLine = makeElement<TextLine>(paletteScore());
1283 0 : staffTextLine->setBeginText(u"Staff");
1284 0 : staffTextLine->setEndHookType(HookType::HOOK_90);
1285 0 : sp->appendElement(staffTextLine, QT_TRANSLATE_NOOP("palette", "Staff text line"));
1286 :
1287 0 : auto systemTextLine = makeElement<TextLine>(paletteScore(), true);
1288 0 : systemTextLine->setLen(12 * paletteScore()->style().spatium());
1289 0 : systemTextLine->setBeginText(u"System");
1290 0 : systemTextLine->setEndHookType(HookType::HOOK_90);
1291 0 : sp->appendElement(systemTextLine, QT_TRANSLATE_NOOP("palette", "System text line"));
1292 :
1293 0 : if (!defaultPalette) {
1294 0 : auto textLine = makeElement<TextLine>(paletteScore());
1295 0 : textLine->setBeginText(u"VII");
1296 0 : textLine->setEndHookType(HookType::HOOK_90);
1297 0 : sp->appendElement(textLine, QT_TRANSLATE_NOOP("palette", "Text line"));
1298 0 : }
1299 :
1300 0 : auto line = makeElement<TextLine>(paletteScore());
1301 0 : line->setDiagonal(true);
1302 0 : sp->appendElement(line, QT_TRANSLATE_NOOP("palette", "Line"));
1303 :
1304 0 : auto rightArrowLine = makeElement<TextLine>(paletteScore());
1305 0 : rightArrowLine->setDiagonal(true);
1306 0 : rightArrowLine->setEndHookType(HookType::ARROW);
1307 0 : sp->appendElement(rightArrowLine, QT_TRANSLATE_NOOP("palette", "Line (right arrowhead)"));
1308 :
1309 0 : auto leftArrowLine = makeElement<TextLine>(paletteScore());
1310 0 : leftArrowLine->setDiagonal(true);
1311 0 : leftArrowLine->setBeginHookType(HookType::ARROW);
1312 0 : sp->appendElement(leftArrowLine, QT_TRANSLATE_NOOP("palette", "Line (left arrowhead)"));
1313 :
1314 0 : sp->appendActionIcon(ActionIconType::NOTE_ANCHORED_LINE, 2);
1315 :
1316 0 : auto a = Factory::makeAmbitus(paletteScore()->dummy());
1317 0 : sp->appendElement(a, QT_TRANSLATE_NOOP("palette", "Ambitus"));
1318 :
1319 0 : auto letRing = makeElement<LetRing>(paletteScore());
1320 0 : sp->appendElement(letRing, QT_TRANSLATE_NOOP("palette", "Let ring"));
1321 :
1322 : static const std::vector<VibratoType> vibratoTable = {
1323 : { VibratoType::GUITAR_VIBRATO, VibratoType::GUITAR_VIBRATO_WIDE, VibratoType::VIBRATO_SAWTOOTH,
1324 : VibratoType::VIBRATO_SAWTOOTH_WIDE },
1325 0 : };
1326 :
1327 : static const std::vector<VibratoType> defaultVibratoTable = {
1328 : { VibratoType::GUITAR_VIBRATO, VibratoType::VIBRATO_SAWTOOTH },
1329 0 : };
1330 :
1331 0 : for (VibratoType vibratoType : defaultPalette ? defaultVibratoTable : vibratoTable) {
1332 0 : auto vibrato = makeElement<Vibrato>(paletteScore());
1333 0 : vibrato->setVibratoType(vibratoType);
1334 0 : sp->appendElement(vibrato, TConv::userName(vibratoType));
1335 0 : }
1336 :
1337 0 : auto pm = makeElement<PalmMute>(paletteScore());
1338 0 : sp->appendElement(pm, QT_TRANSLATE_NOOP("palette", "Palm mute"));
1339 :
1340 : std::array<QString, 3> names = { QT_TRANSLATE_NOOP("palette", "Chord bracket"),
1341 : QT_TRANSLATE_NOOP("palette", "Chord bracket (play with left hand)"),
1342 0 : QT_TRANSLATE_NOOP("palette", "Chord bracket (play with right hand)") };
1343 0 : for (int i = 0; i < 3; ++i) {
1344 0 : DirectionV hookPos = DirectionV(i);
1345 0 : auto c = Factory::makeChordBracket(paletteScore()->dummy());
1346 0 : c->setProperty(Pid::BRACKET_HOOK_POS, hookPos);
1347 0 : sp->appendElement(c, names[i]);
1348 0 : }
1349 :
1350 0 : return sp;
1351 0 : }
1352 :
1353 0 : PalettePtr PaletteCreator::newTempoPalette(bool defaultPalette)
1354 : {
1355 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Tempo);
1356 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Tempo"));
1357 0 : sp->setMag(0.65);
1358 0 : sp->setGridSize(90, 30);
1359 0 : sp->setDrawGrid(true);
1360 :
1361 : struct TempoPattern {
1362 : QString pattern;
1363 : const char* name;
1364 : double f;
1365 : bool relative;
1366 : bool italian;
1367 : bool followText;
1368 : bool basic;
1369 : bool masterOnly;
1370 :
1371 0 : TempoPattern(const QString& s, const char* n, double v, bool r, bool i, bool f, bool b, bool m)
1372 0 : : pattern(s), name(n), f(v), relative(r), italian(i), followText(f), basic(b), masterOnly(m) {}
1373 : };
1374 :
1375 : static const TempoPattern tps[] = {
1376 : TempoPattern("<sym>metNoteHalfUp</sym> = 80",
1377 : QT_TRANSLATE_NOOP("palette", "Half note = 80 BPM"),
1378 0 : 80.0 / 30.0, false, false, true, true, false),
1379 : TempoPattern("<sym>metNoteQuarterUp</sym> = 80",
1380 : QT_TRANSLATE_NOOP("palette", "Quarter note = 80 BPM"),
1381 0 : 80.0 / 60.0, false, false, true, true, false),
1382 : TempoPattern("<sym>metNote8thUp</sym> = 80",
1383 : QT_TRANSLATE_NOOP("palette", "Eighth note = 80 BPM"),
1384 0 : 80.0 / 120.0, false, false, true, true, false),
1385 : TempoPattern("<sym>metNoteHalfUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = 80",
1386 : QT_TRANSLATE_NOOP("palette", "Dotted half note = 80 BPM"),
1387 0 : 120 / 30.0, false, false, true, false, false),
1388 : TempoPattern("<sym>metNoteQuarterUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = 80",
1389 : QT_TRANSLATE_NOOP("palette", "Dotted quarter note = 80 BPM"),
1390 0 : 120 / 60.0, false, false, true, true, false),
1391 : TempoPattern("<sym>metNote8thUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = 80",
1392 : QT_TRANSLATE_NOOP("palette", "Dotted eighth note = 80 BPM"),
1393 0 : 120 / 120.0, false, false, true, false, false),
1394 :
1395 0 : TempoPattern("Grave", "Grave", 35.0 / 60.0, false, true, false, false, false),
1396 0 : TempoPattern("Largo", "Largo", 50.0 / 60.0, false, true, false, false, false),
1397 0 : TempoPattern("Lento", "Lento", 52.5 / 60.0, false, true, false, false, false),
1398 0 : TempoPattern("Larghetto", "Larghetto", 63.0 / 60.0, false, true, false, false, true),
1399 0 : TempoPattern("Adagio", "Adagio", 71.0 / 60.0, false, true, false, false, false),
1400 0 : TempoPattern("Andante", "Andante", 92.0 / 60.0, false, true, false, false, false),
1401 0 : TempoPattern("Andantino", "Andantino", 94.0 / 60.0, false, true, false, false, true),
1402 0 : TempoPattern("Moderato", "Moderato", 114.0 / 60.0, false, true, false, false, false),
1403 0 : TempoPattern("Allegretto", "Allegretto", 116.0 / 60.0, false, true, false, false, false),
1404 0 : TempoPattern("Allegro", "Allegro", 144.0 / 60.0, false, true, false, false, false),
1405 0 : TempoPattern("Vivace", "Vivace", 172.0 / 60.0, false, true, false, false, false),
1406 0 : TempoPattern("Presto", "Presto", 187.0 / 60.0, false, true, false, false, false),
1407 0 : TempoPattern("Prestissimo", "Prestissimo", 200.0 / 60.0, false, true, false, false, true),
1408 :
1409 : TempoPattern("<sym>metNoteQuarterUp</sym> = <sym>metNoteQuarterUp</sym><sym>space</sym><sym>metAugmentationDot</sym>",
1410 : QT_TRANSLATE_NOOP("palette", "Metric modulation: quarter note = dotted quarter note"),
1411 0 : 3.0 / 2.0, true, false, true, false, false),
1412 : TempoPattern("<sym>metNoteQuarterUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = <sym>metNoteQuarterUp</sym>",
1413 : QT_TRANSLATE_NOOP("palette", "Metric modulation: dotted quarter note = quarter note"),
1414 0 : 2.0 / 3.0, true, false, true, false, false),
1415 : TempoPattern("<sym>metNoteHalfUp</sym> = <sym>metNoteQuarterUp</sym>",
1416 : QT_TRANSLATE_NOOP("palette", "Metric modulation: half note = quarter note"),
1417 0 : 1.0 / 2.0, true, false, true, false, false),
1418 : TempoPattern("<sym>metNoteQuarterUp</sym> = <sym>metNoteHalfUp</sym>",
1419 : QT_TRANSLATE_NOOP("palette", "Metric modulation: quarter note = half note"),
1420 0 : 2.0 / 1.0, true, false, true, false, false),
1421 : TempoPattern("<sym>metNote8thUp</sym> = <sym>metNote8thUp</sym>",
1422 : QT_TRANSLATE_NOOP("palette", "Metric modulation: eighth note = eighth note"),
1423 0 : 1.0 / 1.0, true, false, true, false, false),
1424 : TempoPattern("<sym>metNoteQuarterUp</sym> = <sym>metNoteQuarterUp</sym>",
1425 : QT_TRANSLATE_NOOP("palette", "Metric modulation: quarter note = quarter note"),
1426 0 : 1.0 / 1.0, true, false, true, false, false),
1427 : TempoPattern("<sym>metNote8thUp</sym><sym>space</sym><sym>metAugmentationDot</sym> = <sym>metNoteQuarterUp</sym>",
1428 : QT_TRANSLATE_NOOP("palette", "Metric modulation: dotted eighth note = quarter note"),
1429 0 : 4.0 / 3.0, true, false, true, false, false),
1430 0 : };
1431 :
1432 0 : for (TempoPattern tp : tps) {
1433 0 : auto tt = makeElement<TempoText>(paletteScore());
1434 0 : tt->setFollowText(tp.followText);
1435 0 : tt->setXmlText(tp.pattern);
1436 0 : if (tp.relative) {
1437 0 : tt->setRelative(tp.f);
1438 0 : sp->appendElement(tt, tp.name, 1.5);
1439 0 : } else if (tp.italian) {
1440 0 : tt->setTempo(tp.f);
1441 0 : sp->appendElement(tt, tp.name, 1.3);
1442 : } else {
1443 0 : tt->setTempo(tp.f);
1444 0 : sp->appendElement(tt, tp.name, 1.5);
1445 : }
1446 0 : }
1447 :
1448 : static const std::map<GradualTempoChangeType, const char*> DEFAULT_TEMPO_CHANGE = {
1449 : { GradualTempoChangeType::Accelerando, QT_TRANSLATE_NOOP("palette", "accel.") },
1450 : { GradualTempoChangeType::Allargando, QT_TRANSLATE_NOOP("palette", "allarg.") },
1451 : { GradualTempoChangeType::Rallentando, QT_TRANSLATE_NOOP("palette", "rall.") },
1452 : { GradualTempoChangeType::Ritardando, QT_TRANSLATE_NOOP("palette", "rit.") },
1453 0 : };
1454 :
1455 : static const std::map<GradualTempoChangeType, const char*> MASTER_TEMPO_CHANGE = {
1456 : { GradualTempoChangeType::Accelerando, QT_TRANSLATE_NOOP("palette", "accel.") },
1457 : { GradualTempoChangeType::Allargando, QT_TRANSLATE_NOOP("palette", "allarg.") },
1458 : { GradualTempoChangeType::Calando, QT_TRANSLATE_NOOP("palette", "calando") },
1459 : { GradualTempoChangeType::Lentando, QT_TRANSLATE_NOOP("palette", "lentando") },
1460 : { GradualTempoChangeType::Morendo, QT_TRANSLATE_NOOP("palette", "morendo") },
1461 : { GradualTempoChangeType::Precipitando, QT_TRANSLATE_NOOP("palette", "precipitando") },
1462 : { GradualTempoChangeType::Rallentando, QT_TRANSLATE_NOOP("palette", "rall.") },
1463 : { GradualTempoChangeType::Ritardando, QT_TRANSLATE_NOOP("palette", "rit.") },
1464 : { GradualTempoChangeType::Smorzando, QT_TRANSLATE_NOOP("palette", "smorz.") },
1465 : { GradualTempoChangeType::Sostenuto, QT_TRANSLATE_NOOP("palette", "sost.") },
1466 : { GradualTempoChangeType::Stringendo, QT_TRANSLATE_NOOP("palette", "string.") }
1467 0 : };
1468 :
1469 0 : for (const auto& pair : defaultPalette ? DEFAULT_TEMPO_CHANGE : MASTER_TEMPO_CHANGE) {
1470 0 : auto item = makeElement<GradualTempoChange>(paletteScore());
1471 0 : item->setTempoChangeType(pair.first);
1472 0 : const String& text = String::fromUtf8(pair.second);
1473 0 : item->setBeginText(text);
1474 0 : item->setContinueText(String(u"(%1)").arg(text));
1475 0 : sp->appendElement(item, pair.second, 1.3)->yoffset = 0.4;
1476 0 : }
1477 :
1478 0 : const char* aTempoStr = QT_TRANSLATE_NOOP("palette", "a tempo");
1479 0 : auto aTempoTxt = makeElement<TempoText>(paletteScore());
1480 0 : aTempoTxt->setFollowText(true);
1481 0 : aTempoTxt->setXmlText(aTempoStr);
1482 0 : aTempoTxt->setATempo();
1483 0 : sp->appendElement(aTempoTxt, aTempoStr, 1.3);
1484 :
1485 0 : const char* tempoPrimoStr = QT_TRANSLATE_NOOP("palette", "tempo primo");
1486 0 : auto tempoPrimoTxt = makeElement<TempoText>(paletteScore());
1487 0 : tempoPrimoTxt->setFollowText(true);
1488 0 : tempoPrimoTxt->setXmlText(tempoPrimoStr);
1489 0 : tempoPrimoTxt->setTempoPrimo();
1490 0 : sp->appendElement(tempoPrimoTxt, tempoPrimoStr, 1.3);
1491 :
1492 0 : auto stxt = makeElement<SystemText>(paletteScore());
1493 0 : stxt->initTextStyleType(TextStyleType::TEMPO);
1494 0 : stxt->setXmlText(String::fromAscii(QT_TRANSLATE_NOOP("palette", "Swing")));
1495 0 : stxt->setSwing(true);
1496 0 : PaletteCellPtr cell = sp->appendElement(stxt, QT_TRANSLATE_NOOP("palette", "Swing"), 1.3);
1497 0 : cell->yoffset = 0.4;
1498 0 : cell->setElementTranslated(true);
1499 :
1500 0 : stxt = makeElement<SystemText>(paletteScore());
1501 0 : stxt->initTextStyleType(TextStyleType::TEMPO);
1502 : /*: System text to switch from swing rhythm back to straight rhythm */
1503 0 : stxt->setXmlText(QT_TRANSLATE_NOOP("palette", "Straight"));
1504 : // need to be true to enable the "Off" option
1505 0 : stxt->setSwing(true);
1506 : // 0 (swingUnit) turns of swing; swingRatio is set to default
1507 0 : stxt->setSwingParameters(0, stxt->style().styleI(Sid::swingRatio));
1508 : /*: System text to switch from swing rhythm back to straight rhythm */
1509 0 : cell = sp->appendElement(stxt, QT_TRANSLATE_NOOP("palette", "Straight"), 1.3);
1510 0 : cell->yoffset = 0.4;
1511 0 : cell->setElementTranslated(true);
1512 0 : return sp;
1513 0 : }
1514 :
1515 0 : PalettePtr PaletteCreator::newTextPalette(bool defaultPalette)
1516 : {
1517 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Text);
1518 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Text"));
1519 0 : sp->setGridSize(100, 28);
1520 0 : sp->setMag(0.85);
1521 0 : sp->setDrawGrid(true);
1522 :
1523 0 : auto st = makeElement<StaffText>(paletteScore());
1524 0 : st->setXmlText(QT_TRANSLATE_NOOP("palette", "Staff text"));
1525 0 : sp->appendElement(st, QT_TRANSLATE_NOOP("palette", "Staff text"))->setElementTranslated(true);
1526 :
1527 0 : auto staffTextLine = makeElement<TextLine>(paletteScore());
1528 0 : staffTextLine->setBeginText(u"Staff");
1529 0 : staffTextLine->setEndHookType(HookType::HOOK_90);
1530 0 : sp->appendElement(staffTextLine, QT_TRANSLATE_NOOP("palette", "Staff text line"));
1531 :
1532 0 : auto stxt = makeElement<SystemText>(paletteScore());
1533 0 : stxt->setXmlText(QT_TRANSLATE_NOOP("palette", "System text"));
1534 0 : sp->appendElement(stxt, QT_TRANSLATE_NOOP("palette", "System text"))->setElementTranslated(true);
1535 :
1536 0 : auto systemTextLine = makeElement<TextLine>(paletteScore(), true);
1537 0 : systemTextLine->setLen(12 * paletteScore()->style().spatium());
1538 0 : systemTextLine->setBeginText(u"System");
1539 0 : systemTextLine->setEndHookType(HookType::HOOK_90);
1540 0 : sp->appendElement(systemTextLine, QT_TRANSLATE_NOOP("palette", "System text line"));
1541 :
1542 0 : auto expressionText = makeElement<Expression>(paletteScore());
1543 0 : expressionText->setTextStyleType(TextStyleType::EXPRESSION);
1544 0 : expressionText->setXmlText(QT_TRANSLATE_NOOP("palette", "expression"));
1545 0 : expressionText->setPlacement(PlacementV::BELOW);
1546 0 : sp->appendElement(expressionText, QT_TRANSLATE_NOOP("palette", "Expression text"))->setElementTranslated(true);
1547 :
1548 0 : auto is = makeElement<InstrumentChange>(paletteScore());
1549 0 : is->setXmlText(QT_TRANSLATE_NOOP("palette", "Change instr."));
1550 0 : sp->appendElement(is, QT_TRANSLATE_NOOP("palette", "Instrument change"))->setElementTranslated(true);
1551 :
1552 0 : auto rhm = makeElement<RehearsalMark>(paletteScore());
1553 0 : rhm->setXmlText("B1");
1554 0 : sp->appendElement(rhm, QT_TRANSLATE_NOOP("palette", "Rehearsal mark"));
1555 :
1556 : struct PlayTechAnnotationInfo {
1557 : const char* xmlText;
1558 : PlayingTechniqueType playTechType;
1559 : bool expressionType = false;
1560 : muse::TranslatableString userName = TConv::userName(playTechType);
1561 : };
1562 :
1563 : static const std::vector<PlayTechAnnotationInfo> playTechAnnotations = {
1564 : { QT_TRANSLATE_NOOP("palette", "legato"), PlayingTechniqueType::Legato },
1565 : { QT_TRANSLATE_NOOP("palette", "pizz."), PlayingTechniqueType::Pizzicato },
1566 : { QT_TRANSLATE_NOOP("palette", "arco"), PlayingTechniqueType::Natural, false, muse::TranslatableString("palette", "Arco") },
1567 : { QT_TRANSLATE_NOOP("palette", "tremolo"), PlayingTechniqueType::Tremolo, true },
1568 : //: For brass and plucked string instruments: staff text that prescribes to use mute while playing, see https://en.wikipedia.org/wiki/Mute_(music)
1569 : { QT_TRANSLATE_NOOP("palette", "mute"), PlayingTechniqueType::Mute },
1570 : //: For brass and plucked string instruments: staff text that prescribes to play without mute, see https://en.wikipedia.org/wiki/Mute_(music)
1571 : { QT_TRANSLATE_NOOP("palette", "open"), PlayingTechniqueType::Open },
1572 : { QT_TRANSLATE_NOOP("palette", "distort"), PlayingTechniqueType::Distortion },
1573 : { QT_TRANSLATE_NOOP("palette", "overdrive"), PlayingTechniqueType::Overdrive },
1574 : { QT_TRANSLATE_NOOP("palette", "harmonics"), PlayingTechniqueType::Harmonics },
1575 : { QT_TRANSLATE_NOOP("palette", "jazz tone"), PlayingTechniqueType::JazzTone },
1576 : { QT_TRANSLATE_NOOP("palette", "normal"), PlayingTechniqueType::Natural },
1577 0 : };
1578 :
1579 0 : for (PlayTechAnnotationInfo playTechAnnotation : playTechAnnotations) {
1580 0 : auto pta = makeElement<PlayTechAnnotation>(paletteScore());
1581 0 : if (playTechAnnotation.expressionType) {
1582 0 : pta->setTextStyleType(TextStyleType::EXPRESSION);
1583 : }
1584 0 : pta->setXmlText(playTechAnnotation.xmlText);
1585 0 : pta->setTechniqueType(playTechAnnotation.playTechType);
1586 0 : sp->appendElement(pta, playTechAnnotation.userName)->setElementTranslated(true);
1587 0 : }
1588 :
1589 0 : if (!defaultPalette) {
1590 : // Measure numbers, unlike other elements (but like most text elements),
1591 : // are not copied directly into the score when drop.
1592 : // Instead, they simply set the corresponding measure's MeasureNumberMode to SHOW
1593 : // Because of that, the element shown in the palettes does not have to have any particular formatting.
1594 0 : auto meaNum = makeElement<MeasureNumber>(paletteScore());
1595 0 : meaNum->setProperty(Pid::TEXT_STYLE, TextStyleType::STAFF); // Make the element bigger in the palettes (using the default measure number style makes it too small)
1596 0 : meaNum->setXmlText(QT_TRANSLATE_NOOP("palette", "Measure number"));
1597 0 : sp->appendElement(meaNum, QT_TRANSLATE_NOOP("palette", "Measure number"))->setElementTranslated(true);
1598 :
1599 : static const std::vector<PlayTechAnnotationInfo> playTechAnnotationsMaster = {
1600 : { QT_TRANSLATE_NOOP("palette", "détaché"), PlayingTechniqueType::Detache },
1601 : { QT_TRANSLATE_NOOP("palette", "martelé"), PlayingTechniqueType::Martele },
1602 : { QT_TRANSLATE_NOOP("palette", "col legno"), PlayingTechniqueType::ColLegno },
1603 : { QT_TRANSLATE_NOOP("palette", "sul pont."), PlayingTechniqueType::SulPonticello },
1604 : { QT_TRANSLATE_NOOP("palette", "sul tasto"), PlayingTechniqueType::SulTasto },
1605 : { QT_TRANSLATE_NOOP("palette", "vibrato"), PlayingTechniqueType::Vibrato },
1606 0 : };
1607 :
1608 0 : for (PlayTechAnnotationInfo playTechAnnotation : playTechAnnotationsMaster) {
1609 0 : auto pta = makeElement<PlayTechAnnotation>(paletteScore());
1610 0 : pta->setXmlText(playTechAnnotation.xmlText);
1611 0 : pta->setTechniqueType(playTechAnnotation.playTechType);
1612 0 : sp->appendElement(pta, TConv::userName(playTechAnnotation.playTechType))->setElementTranslated(true);
1613 0 : }
1614 0 : }
1615 :
1616 0 : return sp;
1617 0 : }
1618 :
1619 0 : PalettePtr PaletteCreator::newTimePalette(bool defaultPalette)
1620 : {
1621 : struct TS {
1622 : int numerator;
1623 : int denominator;
1624 : TimeSigType type;
1625 : const char* name;
1626 : };
1627 :
1628 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::TimeSig);
1629 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Time signatures"));
1630 0 : sp->setMag(.8);
1631 0 : sp->setGridSize(42, 38);
1632 0 : sp->setDrawGrid(true);
1633 :
1634 : static const std::vector<TS> defaultTimeSignatureList = {
1635 : { 2, 4, TimeSigType::NORMAL, "2/4" },
1636 : { 3, 4, TimeSigType::NORMAL, "3/4" },
1637 : { 4, 4, TimeSigType::NORMAL, "4/4" },
1638 : { 5, 4, TimeSigType::NORMAL, "5/4" },
1639 : { 6, 4, TimeSigType::NORMAL, "6/4" },
1640 : { 3, 8, TimeSigType::NORMAL, "3/8" },
1641 : { 4, 8, TimeSigType::NORMAL, "4/8" },
1642 : { 5, 8, TimeSigType::NORMAL, "5/8" },
1643 : { 6, 8, TimeSigType::NORMAL, "6/8" },
1644 : { 7, 8, TimeSigType::NORMAL, "7/8" },
1645 : { 9, 8, TimeSigType::NORMAL, "9/8" },
1646 : { 12, 8, TimeSigType::NORMAL, "12/8" },
1647 : { 4, 4, TimeSigType::FOUR_FOUR, QT_TRANSLATE_NOOP("engraving/timesig", "Common time") },
1648 : { 2, 2, TimeSigType::ALLA_BREVE, QT_TRANSLATE_NOOP("engraving/timesig", "Cut time") },
1649 : { 2, 2, TimeSigType::NORMAL, "2/2" },
1650 : { 3, 2, TimeSigType::NORMAL, "3/2" }
1651 0 : };
1652 :
1653 : static const std::vector<TS> masterTimeSignatureList = {
1654 : { 2, 4, TimeSigType::NORMAL, "2/4" },
1655 : { 3, 4, TimeSigType::NORMAL, "3/4" },
1656 : { 4, 4, TimeSigType::NORMAL, "4/4" },
1657 : { 5, 4, TimeSigType::NORMAL, "5/4" },
1658 : { 6, 4, TimeSigType::NORMAL, "6/4" },
1659 : { 3, 8, TimeSigType::NORMAL, "3/8" },
1660 : { 4, 8, TimeSigType::NORMAL, "4/8" },
1661 : { 5, 8, TimeSigType::NORMAL, "5/8" },
1662 : { 6, 8, TimeSigType::NORMAL, "6/8" },
1663 : { 7, 8, TimeSigType::NORMAL, "7/8" },
1664 : { 9, 8, TimeSigType::NORMAL, "9/8" },
1665 : { 12, 8, TimeSigType::NORMAL, "12/8" },
1666 : { 4, 4, TimeSigType::FOUR_FOUR, QT_TRANSLATE_NOOP("engraving/timesig", "Common time") },
1667 : { 2, 2, TimeSigType::ALLA_BREVE, QT_TRANSLATE_NOOP("engraving/timesig", "Cut time") },
1668 : { 2, 2, TimeSigType::NORMAL, "2/2" },
1669 : { 3, 2, TimeSigType::NORMAL, "3/2" },
1670 : { 4, 2, TimeSigType::NORMAL, "4/2" },
1671 : { 2, 2, TimeSigType::CUT_BACH, QT_TRANSLATE_NOOP("engraving/timesig", "Cut time (Bach)") },
1672 : { 9, 8, TimeSigType::CUT_TRIPLE, QT_TRANSLATE_NOOP("engraving/timesig", "Cut triple time (9/8)") }
1673 0 : };
1674 :
1675 0 : for (const TS& timeSignatureType : defaultPalette ? defaultTimeSignatureList : masterTimeSignatureList) {
1676 0 : auto timeSignature = Factory::makeTimeSig(paletteScore()->dummy());
1677 0 : timeSignature->setSig(Fraction(timeSignatureType.numerator, timeSignatureType.denominator), timeSignatureType.type);
1678 0 : sp->appendElement(timeSignature, timeSignatureType.name);
1679 0 : }
1680 :
1681 0 : return sp;
1682 0 : }
1683 :
1684 0 : PalettePtr PaletteCreator::newFretboardDiagramPalette(bool defaultPalette)
1685 : {
1686 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::FretboardDiagram);
1687 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Fretboard diagrams"));
1688 0 : sp->setGridSize(42, 45);
1689 0 : sp->setDrawGrid(true);
1690 0 : sp->setVisible(false);
1691 :
1692 : struct FretDiagramInfo {
1693 : String harmony;
1694 : muse::TranslatableString userName;
1695 : };
1696 :
1697 : static const std::vector<FretDiagramInfo> fretboardDiagrams = {
1698 : { u"", muse::TranslatableString("palette", "Blank") },
1699 :
1700 : { u"C", muse::TranslatableString("palette", "C") },
1701 : { u"Cm", muse::TranslatableString("palette", "Cm") },
1702 : { u"C7", muse::TranslatableString("palette", "C7") },
1703 :
1704 : { u"D", muse::TranslatableString("palette", "D") },
1705 : { u"Dm", muse::TranslatableString("palette", "Dm") },
1706 : { u"D7", muse::TranslatableString("palette", "D7") },
1707 :
1708 : { u"E", muse::TranslatableString("palette", "E") },
1709 : { u"Em", muse::TranslatableString("palette", "Em") },
1710 : { u"E7", muse::TranslatableString("palette", "E7") },
1711 :
1712 : { u"F", muse::TranslatableString("palette", "F") },
1713 : { u"Fm", muse::TranslatableString("palette", "Fm") },
1714 : { u"F7", muse::TranslatableString("palette", "F7") },
1715 :
1716 : { u"G", muse::TranslatableString("palette", "G") },
1717 : { u"Gm", muse::TranslatableString("palette", "Gm") },
1718 : { u"G7", muse::TranslatableString("palette", "G7") },
1719 :
1720 : { u"A", muse::TranslatableString("palette", "A") },
1721 : { u"Am", muse::TranslatableString("palette", "Am") },
1722 : { u"A7", muse::TranslatableString("palette", "A7") },
1723 :
1724 : { u"B", muse::TranslatableString("palette", "B") },
1725 : { u"Bm", muse::TranslatableString("palette", "Bm") },
1726 : { u"B7", muse::TranslatableString("palette", "B7") }
1727 0 : };
1728 :
1729 0 : for (const FretDiagramInfo& fretboardDiagram : fretboardDiagrams) {
1730 0 : auto fret = Factory::makeFretDiagram(paletteScore()->dummy());
1731 :
1732 0 : if (fretboardDiagram.harmony.empty()) {
1733 0 : fret->clear();
1734 : } else {
1735 0 : fret->setHarmony(fretboardDiagram.harmony);
1736 0 : fret->updateDiagram(fretboardDiagram.harmony);
1737 : }
1738 :
1739 0 : sp->appendElement(fret, fretboardDiagram.userName);
1740 0 : }
1741 :
1742 0 : if (!defaultPalette) {
1743 0 : sp->appendActionIcon(ActionIconType::FFRAME, FRAME_MAG);
1744 : }
1745 :
1746 0 : return sp;
1747 0 : }
1748 :
1749 0 : PalettePtr PaletteCreator::newGuitarPalette(bool defaultPalette)
1750 : {
1751 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Guitar);
1752 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Guitar"));
1753 0 : sp->setGridSize(60, 33);
1754 0 : sp->setMag(1.2);
1755 0 : sp->setDrawGrid(true);
1756 0 : sp->setVisible(false);
1757 :
1758 0 : auto capoLine = makeElement<TextLine>(paletteScore());
1759 0 : capoLine->setBeginText(u"VII");
1760 0 : capoLine->setEndHookType(HookType::HOOK_90);
1761 0 : sp->appendElement(capoLine, QT_TRANSLATE_NOOP("palette", "Barré line"), 0.8);
1762 :
1763 0 : auto pm = makeElement<PalmMute>(paletteScore());
1764 0 : sp->appendElement(pm, QT_TRANSLATE_NOOP("palette", "Palm mute"), 0.8);
1765 :
1766 0 : auto letRing = makeElement<LetRing>(paletteScore());
1767 0 : sp->appendElement(letRing, QT_TRANSLATE_NOOP("palette", "Let ring"), 0.8);
1768 :
1769 0 : auto whammyBar = makeElement<WhammyBar>(paletteScore());
1770 0 : sp->appendElement(whammyBar, QT_TRANSLATE_NOOP("palette", "Whammy bar"), 0.8);
1771 :
1772 : static const std::vector<VibratoType> vibratos = {
1773 : { VibratoType::GUITAR_VIBRATO, VibratoType::GUITAR_VIBRATO_WIDE }
1774 0 : };
1775 :
1776 0 : for (VibratoType vibratoType : vibratos) {
1777 0 : auto vibrato = makeElement<Vibrato>(paletteScore());
1778 0 : vibrato->setVibratoType(vibratoType);
1779 0 : sp->appendElement(vibrato, TConv::userName(vibratoType));
1780 0 : }
1781 :
1782 0 : sp->appendActionIcon(ActionIconType::DIVE, 1.5);
1783 0 : sp->appendActionIcon(ActionIconType::PRE_DIVE, 1.5);
1784 0 : sp->appendActionIcon(ActionIconType::DIP, 1.4);
1785 0 : sp->appendActionIcon(ActionIconType::SCOOP, 1.5);
1786 :
1787 0 : sp->appendActionIcon(ActionIconType::STANDARD_BEND, 1.5);
1788 0 : sp->appendActionIcon(ActionIconType::PRE_BEND, 1.5);
1789 0 : sp->appendActionIcon(ActionIconType::GRACE_NOTE_BEND, 1.4);
1790 0 : sp->appendActionIcon(ActionIconType::SLIGHT_BEND, 1.5);
1791 :
1792 0 : const char* finger = "pimac";
1793 0 : for (unsigned i = 0; i < strlen(finger); ++i) {
1794 0 : auto f = makeElement<Fingering>(paletteScore());
1795 0 : f->setTextStyleType(TextStyleType::RH_GUITAR_FINGERING);
1796 0 : f->setXmlText(QString(finger[i]));
1797 0 : sp->appendElement(f, QT_TRANSLATE_NOOP("palette", "RH guitar fingering %1"));
1798 0 : }
1799 :
1800 0 : finger = "012345T";
1801 0 : for (unsigned i = 0; i < strlen(finger); ++i) {
1802 0 : auto f = makeElement<Fingering>(paletteScore());
1803 0 : f->setTextStyleType(TextStyleType::LH_GUITAR_FINGERING);
1804 0 : f->setXmlText(QString(finger[i]));
1805 0 : sp->appendElement(f, QT_TRANSLATE_NOOP("palette", "LH guitar fingering %1"));
1806 0 : }
1807 0 : finger = defaultPalette ? "123456" : "0123456789";
1808 0 : for (unsigned i = 0; i < strlen(finger); ++i) {
1809 0 : auto f = makeElement<Fingering>(paletteScore());
1810 0 : f->initTextStyleType(TextStyleType::STRING_NUMBER);
1811 0 : f->setXmlText(QString(finger[i]));
1812 0 : sp->appendElement(f, QT_TRANSLATE_NOOP("palette", "String number %1"));
1813 0 : }
1814 :
1815 0 : auto lhTapping = Factory::makeTapping(paletteScore()->dummy());
1816 0 : lhTapping->setHand(TappingHand::LEFT);
1817 0 : sp->appendElement(lhTapping, QT_TRANSLATE_NOOP("palette", "Left-hand tapping"), 1.0);
1818 :
1819 0 : auto rhTapping = Factory::makeTapping(paletteScore()->dummy());
1820 0 : rhTapping->setHand(TappingHand::RIGHT);
1821 0 : sp->appendElement(rhTapping, QT_TRANSLATE_NOOP("palette", "Right-hand tapping"), 1.0);
1822 :
1823 0 : auto hopo = Factory::makeHammerOnPullOff(paletteScore()->dummy());
1824 0 : sp->appendElement(hopo, QT_TRANSLATE_NOOP("palette", "Hammer-on / pull-off"), 0.8);
1825 :
1826 : static const SymIdList luteSymbols {
1827 : SymId::stringsThumbPosition,
1828 : SymId::luteFingeringRHThumb, SymId::luteFingeringRHFirst,
1829 : SymId::luteFingeringRHSecond, SymId::luteFingeringRHThird
1830 0 : };
1831 :
1832 0 : for (auto i : luteSymbols) {
1833 0 : auto s = Factory::makeArticulation(paletteScore()->dummy());
1834 0 : s->setSymId(i);
1835 0 : sp->appendElement(s, s->subtypeUserName());
1836 0 : }
1837 :
1838 0 : auto capo = makeElement<Capo>(paletteScore());
1839 0 : capo->setXmlText(String::fromAscii(QT_TRANSLATE_NOOP("palette", "Capo")));
1840 0 : sp->appendElement(capo, QT_TRANSLATE_NOOP("palette", "Capo"), 0.9)->setElementTranslated(true);
1841 :
1842 0 : auto stringTunings = makeElement<StringTunings>(paletteScore());
1843 0 : stringTunings->setXmlText(u"<sym>guitarString6</sym> - D");
1844 0 : stringTunings->initTextStyleType(TextStyleType::STRING_TUNINGS);
1845 0 : sp->appendElement(stringTunings, QT_TRANSLATE_NOOP("palette", "String tunings"), 0.9)->setElementTranslated(true);
1846 :
1847 : struct PlayTechAnnotationInfo {
1848 : const char* xmlText;
1849 : PlayingTechniqueType playTechType;
1850 : };
1851 :
1852 : static const std::vector<PlayTechAnnotationInfo> playTechAnnotations = {
1853 : { QT_TRANSLATE_NOOP("palette", "distort"), PlayingTechniqueType::Distortion, },
1854 : { QT_TRANSLATE_NOOP("palette", "overdrive"), PlayingTechniqueType::Overdrive, },
1855 : { QT_TRANSLATE_NOOP("palette", "harmonics"), PlayingTechniqueType::Harmonics, },
1856 : { QT_TRANSLATE_NOOP("palette", "jazz tone"), PlayingTechniqueType::JazzTone, },
1857 : { QT_TRANSLATE_NOOP("palette", "normal"), PlayingTechniqueType::Natural },
1858 0 : };
1859 :
1860 0 : for (const PlayTechAnnotationInfo& playTechAnnotation : playTechAnnotations) {
1861 0 : auto pta = makeElement<PlayTechAnnotation>(paletteScore());
1862 0 : pta->setXmlText(playTechAnnotation.xmlText);
1863 0 : pta->setTechniqueType(playTechAnnotation.playTechType);
1864 0 : sp->appendElement(pta, TConv::userName(playTechAnnotation.playTechType), 0.8)->setElementTranslated(true);
1865 0 : }
1866 :
1867 0 : sp->appendActionIcon(ActionIconType::FFRAME, FRAME_MAG);
1868 :
1869 0 : return sp;
1870 0 : }
1871 :
1872 0 : PalettePtr PaletteCreator::newKeyboardPalette()
1873 : {
1874 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Keyboard);
1875 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Keyboard"));
1876 0 : sp->setGridSize(73, 30);
1877 0 : sp->setDrawGrid(true);
1878 :
1879 0 : auto pedal = makeElement<Pedal>(paletteScore());
1880 0 : pedal->setLineVisible(false);
1881 0 : pedal->setEndHookType(HookType::ROSETTE);
1882 0 : pedal->setBeginText(pedal->propertyDefault(Pid::BEGIN_TEXT).value<String>());
1883 0 : pedal->setContinueText(pedal->propertyDefault(Pid::CONTINUE_TEXT).value<String>());
1884 0 : pedal->setEndText(pedal->propertyDefault(Pid::END_TEXT).value<String>());
1885 0 : sp->appendElement(pedal, QT_TRANSLATE_NOOP("palette", "Pedal (with ped and asterisk)"));
1886 :
1887 0 : pedal = makeElement<Pedal>(paletteScore());
1888 0 : pedal->setEndHookType(HookType::HOOK_90);
1889 0 : pedal->setBeginText(pedal->propertyDefault(Pid::BEGIN_TEXT).value<String>());
1890 0 : pedal->setContinueText(pedal->propertyDefault(Pid::CONTINUE_TEXT).value<String>());
1891 0 : pedal->setEndText(pedal->propertyDefault(Pid::END_TEXT).value<String>());
1892 0 : sp->appendElement(pedal, QT_TRANSLATE_NOOP("palette", "Pedal (with ped and line)"));
1893 :
1894 0 : pedal = makeElement<Pedal>(paletteScore());
1895 0 : pedal->setBeginHookType(HookType::HOOK_90);
1896 0 : pedal->setEndHookType(HookType::HOOK_90);
1897 0 : pedal->setBeginText(pedal->propertyDefault(Pid::BEGIN_TEXT).value<String>());
1898 0 : pedal->setContinueText(pedal->propertyDefault(Pid::CONTINUE_TEXT).value<String>());
1899 0 : pedal->setEndText(pedal->propertyDefault(Pid::END_TEXT).value<String>());
1900 0 : sp->appendElement(pedal, QT_TRANSLATE_NOOP("palette", "Pedal (straight hooks)"));
1901 :
1902 0 : pedal = makeElement<Pedal>(paletteScore());
1903 0 : pedal->setBeginHookType(HookType::HOOK_90);
1904 0 : pedal->setEndHookType(HookType::HOOK_45);
1905 0 : pedal->setBeginText(pedal->propertyDefault(Pid::BEGIN_TEXT).value<String>());
1906 0 : pedal->setContinueText(pedal->propertyDefault(Pid::CONTINUE_TEXT).value<String>());
1907 0 : pedal->setEndText(pedal->propertyDefault(Pid::END_TEXT).value<String>());
1908 0 : sp->appendElement(pedal, QT_TRANSLATE_NOOP("palette", "Pedal (angled end hook)"));
1909 :
1910 0 : pedal = makeElement<Pedal>(paletteScore());
1911 0 : pedal->setBeginHookType(HookType::HOOK_45);
1912 0 : pedal->setEndHookType(HookType::HOOK_45);
1913 0 : pedal->setBeginText(pedal->propertyDefault(Pid::BEGIN_TEXT).value<String>());
1914 0 : pedal->setContinueText(pedal->propertyDefault(Pid::CONTINUE_TEXT).value<String>());
1915 0 : pedal->setEndText(pedal->propertyDefault(Pid::END_TEXT).value<String>());
1916 0 : sp->appendElement(pedal, QT_TRANSLATE_NOOP("palette", "Pedal (both hooks angled)"));
1917 :
1918 0 : pedal = makeElement<Pedal>(paletteScore());
1919 0 : pedal->setBeginHookType(HookType::HOOK_45);
1920 0 : pedal->setEndHookType(HookType::HOOK_90);
1921 0 : pedal->setBeginText(pedal->propertyDefault(Pid::BEGIN_TEXT).value<String>());
1922 0 : pedal->setContinueText(pedal->propertyDefault(Pid::CONTINUE_TEXT).value<String>());
1923 0 : pedal->setEndText(pedal->propertyDefault(Pid::END_TEXT).value<String>());
1924 0 : sp->appendElement(pedal, QT_TRANSLATE_NOOP("palette", "Pedal (angled start hook)"));
1925 :
1926 : std::array<QString, 3> names = { QT_TRANSLATE_NOOP("palette", "Chord bracket"),
1927 : QT_TRANSLATE_NOOP("palette", "Chord bracket (play with left hand)"),
1928 0 : QT_TRANSLATE_NOOP("palette", "Chord bracket (play with right hand)") };
1929 0 : for (int i = 0; i < 3; ++i) {
1930 0 : DirectionV hookPos = DirectionV(i);
1931 0 : auto c = Factory::makeChordBracket(paletteScore()->dummy());
1932 0 : c->setProperty(Pid::BRACKET_HOOK_POS, hookPos);
1933 0 : sp->appendElement(c, names[i]);
1934 0 : }
1935 :
1936 0 : return sp;
1937 0 : }
1938 :
1939 0 : PalettePtr PaletteCreator::newPitchPalette(bool defaultPalette)
1940 : {
1941 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Pitch);
1942 : //: The name of a palette
1943 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Pitch"));
1944 0 : sp->setGridSize(100, 30);
1945 0 : sp->setDrawGrid(true);
1946 0 : sp->setMag(0.8);
1947 :
1948 : static const std::vector<OttavaType> ottavasDefault {
1949 : OttavaType::OTTAVA_8VA,
1950 : OttavaType::OTTAVA_8VB,
1951 : OttavaType::OTTAVA_15MA,
1952 : OttavaType::OTTAVA_15MB
1953 0 : };
1954 :
1955 : static const std::vector<OttavaType> ottavasMaster {
1956 : OttavaType::OTTAVA_8VA,
1957 : OttavaType::OTTAVA_8VB,
1958 : OttavaType::OTTAVA_15MA,
1959 : OttavaType::OTTAVA_15MB,
1960 : OttavaType::OTTAVA_22MA,
1961 : OttavaType::OTTAVA_22MB
1962 0 : };
1963 :
1964 0 : for (OttavaType ottavaType : defaultPalette ? ottavasDefault : ottavasMaster) {
1965 0 : auto ottava = makeElement<Ottava>(paletteScore());
1966 0 : ottava->setOttavaType(ottavaType);
1967 0 : ottava->styleChanged();
1968 0 : sp->appendElement(ottava, ottava->subtypeUserName());
1969 0 : }
1970 :
1971 0 : auto a = Factory::makeAmbitus(paletteScore()->dummy());
1972 0 : sp->appendElement(a, QT_TRANSLATE_NOOP("palette", "Ambitus"));
1973 0 : return sp;
1974 0 : }
1975 :
1976 0 : PalettePtr PaletteCreator::newHarpPalette()
1977 : {
1978 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Harp);
1979 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Harp"));
1980 0 : sp->setGridSize(90, 30);
1981 0 : sp->setDrawGrid(true);
1982 0 : sp->setVisible(false);
1983 :
1984 0 : auto pedalDiagram = Factory::makeHarpPedalDiagram(paletteScore()->dummy());
1985 0 : sp->appendElement(pedalDiagram, QT_TRANSLATE_NOOP("palette", "Harp pedal diagram"));
1986 :
1987 0 : auto pedalTextDiagram = Factory::makeHarpPedalDiagram(paletteScore()->dummy());
1988 0 : pedalTextDiagram->setIsDiagram(false);
1989 :
1990 0 : sp->appendElement(pedalTextDiagram, QT_TRANSLATE_NOOP("palette", "Harp pedal text diagram"));
1991 :
1992 0 : return sp;
1993 0 : }
1994 :
1995 0 : PalettePtr PaletteCreator::newHandbellsPalette(bool defaultPalette)
1996 : {
1997 0 : PalettePtr sp = std::make_shared<Palette>(iocContext(), Palette::Type::Handbells);
1998 0 : sp->setName(QT_TRANSLATE_NOOP("palette", "Handbells"));
1999 0 : sp->setGridSize(42, 25);
2000 0 : sp->setDrawGrid(true);
2001 0 : sp->setVisible(false);
2002 :
2003 : static const std::vector<SymId> standardHandbellsArticSymbols {
2004 : SymId::handbellsMartellato,
2005 : SymId::handbellsMartellatoLift,
2006 : SymId::handbellsMalletBellSuspended,
2007 : SymId::handbellsMalletBellOnTable,
2008 : SymId::handbellsMalletLft,
2009 : SymId::handbellsPluckLift,
2010 : SymId::handbellsGyro,
2011 0 : };
2012 :
2013 : static const std::vector<ArticulationTextType> handbellsTextTypes {
2014 : ArticulationTextType::TD,
2015 : ArticulationTextType::BD,
2016 : ArticulationTextType::RT,
2017 : ArticulationTextType::PL,
2018 : ArticulationTextType::SB,
2019 : ArticulationTextType::VIB,
2020 0 : };
2021 :
2022 : struct HandbellsPlayTechInfo {
2023 : const char* xmlText;
2024 : PlayingTechniqueType playTechType;
2025 : };
2026 :
2027 : static const std::vector<HandbellsPlayTechInfo> standardHandbellsPlayTech {
2028 : { "R", PlayingTechniqueType::HandbellsR, },
2029 : { "LV", PlayingTechniqueType::HandbellsLV, },
2030 : { "<sym>handbellsDamp3</sym>", PlayingTechniqueType::HandbellsDamp, },
2031 : { "<sym>handbellsSwingUp</sym>", PlayingTechniqueType::HandbellsSwingUp, },
2032 : { "<sym>handbellsSwingDown</sym>", PlayingTechniqueType::HandbellsSwingDown, },
2033 : { "<sym>handbellsEcho1</sym>", PlayingTechniqueType::HandbellsEcho1, },
2034 0 : };
2035 :
2036 0 : for (SymId symId : standardHandbellsArticSymbols) {
2037 0 : auto artic = Factory::makeArticulation(paletteScore()->dummy());
2038 0 : artic->setSymId(symId);
2039 0 : sp->appendElement(artic, artic->subtypeUserName(),
2040 0 : symId == SymId::handbellsGyro ? 0.7 : symId == SymId::handbellsMalletBellSuspended ? 1.4 : 1.0);
2041 0 : }
2042 :
2043 0 : for (ArticulationTextType textType : handbellsTextTypes) {
2044 0 : auto artic = Factory::makeArticulation(paletteScore()->dummy());
2045 0 : artic->setTextType(textType);
2046 0 : sp->appendElement(artic, artic->subtypeUserName(), 1.1);
2047 0 : }
2048 :
2049 0 : for (const HandbellsPlayTechInfo& info : standardHandbellsPlayTech) {
2050 0 : auto element = makeElement<PlayTechAnnotation>(paletteScore());
2051 0 : element->setProperty(Pid::TEXT_STYLE, TextStyleType::ARTICULATION);
2052 0 : element->setXmlText(info.xmlText);
2053 0 : element->setTechniqueType(info.playTechType);
2054 0 : sp->appendElement(element, TConv::userName(info.playTechType),
2055 0 : info.playTechType == PlayingTechniqueType::HandbellsLV
2056 0 : || info.playTechType == PlayingTechniqueType::HandbellsR ? 1.1 : 1.0);
2057 0 : }
2058 :
2059 0 : if (!defaultPalette) {
2060 : static const std::vector<SymId> additionalHandbellsArticSymbols {
2061 : SymId::handbellsHandMartellato,
2062 : SymId::handbellsMutedMartellato,
2063 0 : };
2064 :
2065 0 : for (SymId symId : additionalHandbellsArticSymbols) {
2066 0 : auto artic = Factory::makeArticulation(paletteScore()->dummy());
2067 0 : artic->setSymId(symId);
2068 0 : sp->appendElement(artic, artic->subtypeUserName());
2069 0 : }
2070 :
2071 : static const std::vector<HandbellsPlayTechInfo> additionalHandbellsPlayTech {
2072 : { "<sym>handbellsSwing</sym>", PlayingTechniqueType::HandbellsSwing, },
2073 : { "<sym>handbellsEcho2</sym>", PlayingTechniqueType::HandbellsEcho2, },
2074 0 : };
2075 :
2076 0 : for (const HandbellsPlayTechInfo& info : additionalHandbellsPlayTech) {
2077 0 : auto element = makeElement<PlayTechAnnotation>(paletteScore());
2078 0 : element->setProperty(Pid::TEXT_STYLE, TextStyleType::ARTICULATION);
2079 0 : element->setXmlText(info.xmlText);
2080 0 : element->setTechniqueType(info.playTechType);
2081 0 : sp->appendElement(element, TConv::userName(info.playTechType));
2082 0 : }
2083 : }
2084 :
2085 0 : return sp;
2086 0 : }
|
