1 //=============================================================================
2 //  MuseScore
3 //  Music Composition & Notation
4 //
5 //  Copyright (C) 2002-2017 Werner Schweer
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 //  as published by the Free Software Foundation and appearing in
10 //  the file LICENCE.GPL
11 //=============================================================================
12 
13 #ifndef __UNDO_H__
14 #define __UNDO_H__
15 
16 /**
17  \file
18  Definition of undo-releated classes and structs.
19 */
20 
21 #include "spatium.h"
22 #include "mscore.h"
23 #include "sig.h"
24 #include "tempo.h"
25 #include "input.h"
26 #include "style.h"
27 #include "key.h"
28 #include "select.h"
29 #include "instrument.h"
30 #include "pitchvalue.h"
31 #include "timesig.h"
32 #include "noteevent.h"
33 #include "synthesizerstate.h"
34 #include "dynamic.h"
35 #include "staff.h"
36 #include "stafftype.h"
37 #include "cleflist.h"
38 #include "note.h"
39 #include "chord.h"
40 #include "drumset.h"
41 #include "rest.h"
42 #include "fret.h"
43 
44 #include "audio/midi/midipatch.h"
45 
46 Q_DECLARE_LOGGING_CATEGORY(undoRedo);
47 
48 namespace Ms {
49 
50 class ElementList;
51 class Element;
52 class Instrument;
53 class System;
54 class Measure;
55 class Segment;
56 class Staff;
57 class Part;
58 class Volta;
59 class Score;
60 class Note;
61 class Chord;
62 class ChordRest;
63 class Harmony;
64 class SlurTie;
65 class MStaff;
66 class MeasureBase;
67 class Dynamic;
68 class Selection;
69 class Text;
70 class Channel;
71 class Tuplet;
72 class KeySig;
73 class TimeSig;
74 class Clef;
75 class Image;
76 class Bend;
77 class TremoloBar;
78 class NoteEvent;
79 class SlurSegment;
80 class InstrumentChange;
81 class Box;
82 class Spanner;
83 class BarLine;
84 class ScoreOrder;
85 enum class ClefType : signed char;
86 enum class PlayEventType : char;
87 class Excerpt;
88 class EditData;
89 
90 #define UNDO_NAME(a)  virtual const char* name() const override { return a; }
91 
92 enum class LayoutMode : char;
93 
94 //---------------------------------------------------------
95 //   UndoCommand
96 //---------------------------------------------------------
97 
98 class UndoCommand {
99       QList<UndoCommand*> childList;
100 
101    protected:
flip(EditData *)102       virtual void flip(EditData*) {}
103       void appendChildren(UndoCommand*);
104 
105    public:
106       enum class Filter {
107             TextEdit,
108             AddElement,
109             AddElementLinked,
110             Link,
111             RemoveElement,
112             RemoveElementLinked,
113             ChangePropertyLinked,
114             };
115 
116       virtual ~UndoCommand();
117       virtual void undo(EditData*);
118       virtual void redo(EditData*);
appendChild(UndoCommand * cmd)119       void appendChild(UndoCommand* cmd) { childList.append(cmd);       }
removeChild()120       UndoCommand* removeChild()         { return childList.takeLast(); }
childCount()121       int childCount() const             { return childList.size();     }
122       void unwind();
commands()123       const QList<UndoCommand*>& commands() const { return childList; }
124       virtual void cleanup(bool undo);
125 // #ifndef QT_NO_DEBUG
name()126       virtual const char* name() const { return "UndoCommand"; }
127 // #endif
128 
isFiltered(Filter,const Element *)129       virtual bool isFiltered(Filter, const Element* /* target */) const { return false; }
130       bool hasFilteredChildren(Filter, const Element* target) const;
131       bool hasUnfilteredChildren(const std::vector<Filter>& filters, const Element* target) const;
132       void filterChildren(UndoCommand::Filter f, Element* target);
133       };
134 
135 //---------------------------------------------------------
136 //   UndoMacro
137 //    A root element for undo macro which is stored
138 //    directly in UndoStack
139 //---------------------------------------------------------
140 
141 class UndoMacro : public UndoCommand {
142       struct SelectionInfo {
143             std::vector<Element*> elements;
144             Fraction tickStart;
145             Fraction tickEnd;
146             int staffStart = -1;
147             int staffEnd = -1;
148 
isValidSelectionInfo149             bool isValid() const { return !elements.empty() || staffStart != -1; }
150             };
151 
152       InputState undoInputState;
153       InputState redoInputState;
154       SelectionInfo undoSelectionInfo;
155       SelectionInfo redoSelectionInfo;
156 
157       Score* score;
158 
159       static void fillSelectionInfo(SelectionInfo&, const Selection&);
160       static void applySelectionInfo(const SelectionInfo&, Selection&);
161 
162    public:
163       UndoMacro(Score* s);
164       virtual void undo(EditData*) override;
165       virtual void redo(EditData*) override;
empty()166       bool empty() const { return childCount() == 0; }
167       void append(UndoMacro&& other);
168 
169       static bool canRecordSelectedElement(const Element* e);
170 
171       UNDO_NAME("UndoMacro");
172       };
173 
174 //---------------------------------------------------------
175 //   UndoStack
176 //---------------------------------------------------------
177 
178 class UndoStack {
179       UndoMacro* curCmd;
180       QList<UndoMacro*> list;
181       std::vector<int> stateList;
182       int nextState;
183       int cleanState;
184       int curIdx;
185 
186       void remove(int idx);
187 
188    public:
189       UndoStack();
190       ~UndoStack();
191 
active()192       bool active() const           { return curCmd != 0; }
193       void beginMacro(Score*);
194       void endMacro(bool rollback);
195       void push(UndoCommand*, EditData*);      // push & execute
196       void push1(UndoCommand*);
197       void pop();
198       void setClean();
canUndo()199       bool canUndo() const          { return curIdx > 0;           }
canRedo()200       bool canRedo() const          { return curIdx < list.size(); }
state()201       int state() const             { return stateList[curIdx];    }
isClean()202       bool isClean() const          { return cleanState == state();     }
getCurIdx()203       int getCurIdx() const         { return curIdx; }
empty()204       bool empty() const            { return !canUndo() && !canRedo();  }
current()205       UndoMacro* current() const    { return curCmd;               }
last()206       UndoMacro* last() const       { return curIdx > 0 ? list[curIdx-1] : 0; }
prev()207       UndoMacro* prev() const       { return curIdx > 1 ? list[curIdx-2] : 0; }
208       void undo(EditData*);
209       void redo(EditData*);
210       void rollback();
211       void reopen();
212 
213       void mergeCommands(int startIdx);
cleanRedoStack()214       void cleanRedoStack() { remove(curIdx); }
215       };
216 
217 //---------------------------------------------------------
218 //   InsertPart
219 //---------------------------------------------------------
220 
221 class InsertPart : public UndoCommand {
222       Part* part;
223       int idx;
224 
225    public:
226       InsertPart(Part* p, int i);
227       virtual void undo(EditData*) override;
228       virtual void redo(EditData*) override;
229       UNDO_NAME("InsertPart")
230       };
231 
232 //---------------------------------------------------------
233 //   RemovePart
234 //---------------------------------------------------------
235 
236 class RemovePart : public UndoCommand {
237       Part* part;
238       int idx;
239 
240    public:
241       RemovePart(Part*, int idx);
242       virtual void undo(EditData*) override;
243       virtual void redo(EditData*) override;
244       UNDO_NAME("RemovePart")
245       };
246 
247 //---------------------------------------------------------
248 //   InsertStaff
249 //---------------------------------------------------------
250 
251 class InsertStaff : public UndoCommand {
252       Staff* staff;
253       int ridx;
254 
255    public:
256       InsertStaff(Staff*, int idx);
257       virtual void undo(EditData*) override;
258       virtual void redo(EditData*) override;
259       UNDO_NAME("InsertStaff")
260       };
261 
262 //---------------------------------------------------------
263 //   RemoveStaff
264 //---------------------------------------------------------
265 
266 class RemoveStaff : public UndoCommand {
267       Staff* staff;
268       int ridx;
269 
270    public:
271       RemoveStaff(Staff*);
272       virtual void undo(EditData*) override;
273       virtual void redo(EditData*) override;
274       UNDO_NAME("RemoveStaff")
275       };
276 
277 //---------------------------------------------------------
278 //   InsertMStaff
279 //---------------------------------------------------------
280 
281 class InsertMStaff : public UndoCommand {
282       Measure* measure;
283       MStaff* mstaff;
284       int idx;
285 
286    public:
287       InsertMStaff(Measure*, MStaff*, int);
288       virtual void undo(EditData*) override;
289       virtual void redo(EditData*) override;
290       UNDO_NAME("InsertMStaff")
291       };
292 
293 //---------------------------------------------------------
294 //   RemoveMStaff
295 //---------------------------------------------------------
296 
297 class RemoveMStaff : public UndoCommand {
298       Measure* measure;
299       MStaff* mstaff;
300       int idx;
301 
302    public:
303       RemoveMStaff(Measure*, MStaff*, int);
304       virtual void undo(EditData*) override;
305       virtual void redo(EditData*) override;
306       UNDO_NAME("RemoveMStaff")
307       };
308 
309 //---------------------------------------------------------
310 //   InsertStaves
311 //---------------------------------------------------------
312 
313 class InsertStaves : public UndoCommand {
314       Measure* measure;
315       int a;
316       int b;
317 
318    public:
319       InsertStaves(Measure*, int, int);
320       virtual void undo(EditData*) override;
321       virtual void redo(EditData*) override;
322       UNDO_NAME("InsertStaves")
323       };
324 
325 //---------------------------------------------------------
326 //   RemoveStaves
327 //---------------------------------------------------------
328 
329 class RemoveStaves : public UndoCommand {
330       Measure* measure;
331       int a;
332       int b;
333 
334    public:
335       RemoveStaves(Measure*, int, int);
336       virtual void undo(EditData*) override;
337       virtual void redo(EditData*) override;
338       UNDO_NAME("RemoveStaves")
339       };
340 
341 //---------------------------------------------------------
342 //   SortStaves
343 //---------------------------------------------------------
344 
345 class SortStaves : public UndoCommand {
346       Score* score;
347       QList<int> list;
348       QList<int> rlist;
349 
350    public:
351       SortStaves(Score*, QList<int>);
352       virtual void undo(EditData*) override;
353       virtual void redo(EditData*) override;
354       UNDO_NAME("SortStaves")
355       };
356 
357 //---------------------------------------------------------
358 //   MapExcerptTracks
359 //---------------------------------------------------------
360 
361 class MapExcerptTracks : public UndoCommand {
362       Score* score;
363       QList<int> list;
364       QList<int> rlist;
365 
366    public:
367       MapExcerptTracks(Score*, QList<int>);
368       virtual void undo(EditData*) override;
369       virtual void redo(EditData*) override;
370       UNDO_NAME("MapExcerptTracks")
371       };
372 
373 //---------------------------------------------------------
374 //   ChangePitch
375 //---------------------------------------------------------
376 
377 class ChangePitch : public UndoCommand {
378       Note* note;
379       int pitch;
380       int tpc1;
381       int tpc2;
382       void flip(EditData*) override;
383 
384    public:
385       ChangePitch(Note* note, int pitch, int tpc1, int tpc2);
386       UNDO_NAME("ChangePitch")
387       };
388 
389 //---------------------------------------------------------
390 //   ChangeFretting
391 //---------------------------------------------------------
392 
393 class ChangeFretting : public UndoCommand {
394       Note* note;
395       int pitch;
396       int string;
397       int fret;
398       int tpc1;
399       int tpc2;
400       void flip(EditData*) override;
401 
402    public:
403       ChangeFretting(Note* note, int pitch, int string, int fret, int tpc1, int tpc2);
404       UNDO_NAME("ChangeFretting")
405       };
406 
407 //---------------------------------------------------------
408 //   ChangeKeySig
409 //---------------------------------------------------------
410 
411 class ChangeKeySig : public UndoCommand {
412       KeySig* keysig;
413       KeySigEvent ks;
414       bool showCourtesy;
415       bool evtInStaff;
416 
417       void flip(EditData*) override;
418 
419    public:
420       ChangeKeySig(KeySig* k, KeySigEvent newKeySig, bool sc, bool addEvtToStaff = true);
421       UNDO_NAME("ChangeKeySig")
422       };
423 
424 //---------------------------------------------------------
425 //   ChangeMeasureLen
426 //---------------------------------------------------------
427 
428 class ChangeMeasureLen : public UndoCommand {
429       Measure* measure;
430       Fraction len;
431       void flip(EditData*) override;
432 
433    public:
434       ChangeMeasureLen(Measure*, Fraction);
435       UNDO_NAME("ChangeMeasureLen")
436       };
437 
438 //---------------------------------------------------------
439 //   ChangeElement
440 //---------------------------------------------------------
441 
442 class ChangeElement : public UndoCommand {
443       Element* oldElement;
444       Element* newElement;
445       void flip(EditData*) override;
446 
447    public:
448       ChangeElement(Element* oldElement, Element* newElement);
449       UNDO_NAME("ChangeElement")
450       };
451 
452 //---------------------------------------------------------
453 //   TransposeHarmony
454 //---------------------------------------------------------
455 
456 class TransposeHarmony : public UndoCommand {
457       Harmony* harmony;
458       int rootTpc, baseTpc;
459       void flip(EditData*) override;
460 
461    public:
462       TransposeHarmony(Harmony*, int rootTpc, int baseTpc);
463       UNDO_NAME("TransposeHarmony")
464       };
465 
466 //---------------------------------------------------------
467 //   ExchangeVoice
468 //---------------------------------------------------------
469 
470 class ExchangeVoice : public UndoCommand {
471       Measure* measure;
472       int val1, val2;
473       int staff;
474 
475    public:
476       ExchangeVoice(Measure* ,int val1, int val2, int staff);
477       virtual void undo(EditData*) override;
478       virtual void redo(EditData*) override;
479       UNDO_NAME("ExchangeVoice")
480       };
481 
482 //---------------------------------------------------------
483 //   CloneVoice
484 //---------------------------------------------------------
485 
486 class CloneVoice : public UndoCommand {
487       Segment* sf;
488       Fraction lTick;
489       Segment* d;             //Destination
490       int strack, dtrack;
491       int otrack;
492       bool linked;
493       bool first = true;      //first redo
494 
495    public:
496       CloneVoice(Segment* sf, const Fraction& lTick, Segment* d, int strack, int dtrack, int otrack, bool linked = true);
497       virtual void undo(EditData*) override;
498       virtual void redo(EditData*) override;
499       UNDO_NAME("CloneVoice")
500       };
501 
502 //---------------------------------------------------------
503 //   ChangeInstrumentShort
504 //---------------------------------------------------------
505 
506 class ChangeInstrumentShort : public UndoCommand {
507       Part* part;
508       Fraction tick;
509       QList<StaffName> text;
510       void flip(EditData*) override;
511 
512    public:
513       ChangeInstrumentShort(const Fraction&, Part*, QList<StaffName>);
514       UNDO_NAME("ChangeInstrumentShort")
515       };
516 
517 //---------------------------------------------------------
518 //   ChangeInstrumentLong
519 //---------------------------------------------------------
520 
521 class ChangeInstrumentLong : public UndoCommand {
522       Part* part;
523       Fraction tick;
524       QList<StaffName> text;
525       void flip(EditData*) override;
526 
527    public:
528       const QList<StaffName>& longNames() const;
529       ChangeInstrumentLong(const Fraction&, Part*, QList<StaffName>);
530       UNDO_NAME("ChangeInstrumentLong")
531       };
532 
533 //---------------------------------------------------------
534 //   ChangeBracketType
535 //---------------------------------------------------------
536 
537 class ChangeBracketType : public UndoCommand {
538       Bracket* bracket;
539       BracketType type;
540       void flip(EditData*) override;
541 
542    public:
543       ChangeBracketType(Bracket*, BracketType type);
544       UNDO_NAME("ChangeBracketType")
545       };
546 
547 //---------------------------------------------------------
548 //   AddElement
549 //---------------------------------------------------------
550 
551 class AddElement : public UndoCommand {
552       Element* element;
553 
554       void endUndoRedo(bool) const;
555       void undo(EditData*) override;
556       void redo(EditData*) override;
557 
558    public:
559       AddElement(Element*);
getElement()560       Element* getElement() const { return element; }
561       virtual void cleanup(bool);
562       virtual const char* name() const override;
563 
564       bool isFiltered(UndoCommand::Filter f, const Element* target) const override;
565       };
566 
567 //---------------------------------------------------------
568 //   RemoveElement
569 //---------------------------------------------------------
570 
571 class RemoveElement : public UndoCommand {
572       Element* element;
573 
574    public:
575       RemoveElement(Element*);
576       virtual void undo(EditData*) override;
577       virtual void redo(EditData*) override;
578       virtual void cleanup(bool);
579       virtual const char* name() const override;
580 
581       bool isFiltered(UndoCommand::Filter f, const Element* target) const override;
582       };
583 
584 //---------------------------------------------------------
585 //   EditText
586 //---------------------------------------------------------
587 
588 class EditText : public UndoCommand {
589       Text* text;
590       QString oldText;
591       //int undoLevel;
592 
593       void undoRedo();
594 
595    public:
EditText(Text * t,const QString & ot,int)596       EditText(Text* t, const QString& ot, int /*l*/) : text(t), oldText(ot)/*, undoLevel(l)*/ {}
597       virtual void undo(EditData*) override;
598       virtual void redo(EditData*) override;
599       UNDO_NAME("EditText")
600       };
601 
602 //---------------------------------------------------------
603 //   ChangePatch
604 //---------------------------------------------------------
605 
606 class ChangePatch : public UndoCommand {
607       Score* score;
608       Channel* channel;
609       MidiPatch patch;
610 
611       void flip(EditData*) override;
612 
613    public:
ChangePatch(Score * s,Channel * c,const MidiPatch * pt)614       ChangePatch(Score* s, Channel* c, const MidiPatch* pt)
615          : score(s), channel(c), patch(*pt) {}
616       UNDO_NAME("ChangePatch")
617       };
618 
619 //---------------------------------------------------------
620 //   SetUserBankController
621 //---------------------------------------------------------
622 
623 class SetUserBankController : public UndoCommand {
624       Channel* channel;
625       bool val;
626 
627       void flip(EditData*) override;
628 
629    public:
SetUserBankController(Channel * c,bool v)630       SetUserBankController(Channel* c, bool v)
631          : channel(c), val(v) {}
632       UNDO_NAME("SetUserBankController")
633       };
634 
635 //---------------------------------------------------------
636 //   ChangeStaff
637 //---------------------------------------------------------
638 
639 class ChangeStaff : public UndoCommand {
640       Staff*   staff;
641       bool     invisible;
642       ClefTypeList clefType;
643       qreal    userDist;
644       Staff::HideMode hideMode;
645       bool     showIfEmpty;
646       bool     cutaway;
647       bool     hideSystemBarLine;
648       bool     mergeMatchingRests;
649 
650       void flip(EditData*) override;
651 
652    public:
653       ChangeStaff(Staff*, bool invisible, ClefTypeList _clefType, qreal userDist, Staff::HideMode _hideMode,
654          bool _showIfEmpty, bool _cutaway, bool hide, bool mergeRests);
655       UNDO_NAME("ChangeStaff")
656       };
657 
658 //---------------------------------------------------------
659 //   ChangeStaffType
660 //---------------------------------------------------------
661 
662 class ChangeStaffType : public UndoCommand {
663       Staff*       staff;
664       StaffType    staffType;
665 
666       void flip(EditData*) override;
667 
668    public:
ChangeStaffType(Staff * s,const StaffType & t)669       ChangeStaffType(Staff* s, const StaffType& t) : staff(s), staffType(t) {}
670       UNDO_NAME("ChangeStaffType")
671       };
672 
673 //---------------------------------------------------------
674 //   ChangePart
675 //---------------------------------------------------------
676 
677 class ChangePart : public UndoCommand {
678       Part* part;
679       Instrument* instrument;
680       QString partName;
681 
682       void flip(EditData*) override;
683 
684    public:
685       ChangePart(Part*, Instrument*, const QString& name);
686       UNDO_NAME("ChangePart")
687       };
688 
689 //---------------------------------------------------------
690 //   ChangeStyle
691 //---------------------------------------------------------
692 
693 class ChangeStyle : public UndoCommand {
694       Score* score;
695       MStyle style;
696       bool overlap = false;
697       void flip(EditData*) override;
698       void undo(EditData*) override;
699 
700    public:
701       ChangeStyle(Score*, const MStyle&, const bool overlapOnly = false);
702       UNDO_NAME("ChangeStyle")
703       };
704 
705 //---------------------------------------------------------
706 //   ChangeStyleVal
707 //---------------------------------------------------------
708 
709 class ChangeStyleVal : public UndoCommand {
710       Score* score;
711       Sid idx;
712       QVariant value;
713 
714       void flip(EditData*) override;
715 
716    public:
ChangeStyleVal(Score * s,Sid i,const QVariant & v)717       ChangeStyleVal(Score* s, Sid i, const QVariant& v) : score(s), idx(i), value(v) {}
718       UNDO_NAME("ChangeStyleVal")
719       };
720 
721 //---------------------------------------------------------
722 //   ChangePageNumberOffset
723 //---------------------------------------------------------
724 
725 class ChangePageNumberOffset : public UndoCommand {
726       Score* score;
727       int pageOffset;
728 
729       void flip(EditData*) override;
730 
731    public:
ChangePageNumberOffset(Score * s,int po)732       ChangePageNumberOffset(Score* s, int po) : score(s), pageOffset(po) {}
733       UNDO_NAME("ChangePageNumberOffset")
734       };
735 
736 //---------------------------------------------------------
737 //   ChangeChordStaffMove
738 //---------------------------------------------------------
739 
740 class ChangeChordStaffMove : public UndoCommand {
741       ChordRest* chordRest;
742       int staffMove;
743       void flip(EditData*) override;
744 
745    public:
746       ChangeChordStaffMove(ChordRest* cr, int);
747       UNDO_NAME("ChangeChordStaffMove")
748       };
749 
750 //---------------------------------------------------------
751 //   ChangeVelocity
752 //---------------------------------------------------------
753 
754 class ChangeVelocity : public UndoCommand {
755       Note* note;
756       Note::ValueType veloType;
757       int veloOffset;
758       void flip(EditData*) override;
759 
760    public:
761       ChangeVelocity(Note*, Note::ValueType, int);
762       UNDO_NAME("ChangeVelocity")
763       };
764 
765 //---------------------------------------------------------
766 //   ChangeMStaffProperties
767 //---------------------------------------------------------
768 
769 class ChangeMStaffProperties : public UndoCommand {
770       Measure* measure;
771       int staffIdx;
772       bool visible;
773       bool stemless;
774       void flip(EditData*) override;
775 
776    public:
777       ChangeMStaffProperties(Measure*, int staffIdx, bool visible, bool stemless);
778       UNDO_NAME("ChangeMStaffProperties")
779       };
780 
781 //---------------------------------------------------------
782 //   InsertRemoveMeasures
783 //---------------------------------------------------------
784 
785 class InsertRemoveMeasures : public UndoCommand {
786       MeasureBase* fm;
787       MeasureBase* lm;
788 
789       static std::vector<Clef*> getCourtesyClefs(Measure* m);
790 
791    protected:
792       void removeMeasures();
793       void insertMeasures();
794 
795    public:
InsertRemoveMeasures(MeasureBase * _fm,MeasureBase * _lm)796       InsertRemoveMeasures(MeasureBase* _fm, MeasureBase* _lm) : fm(_fm), lm(_lm) {}
797       virtual void undo(EditData*) override = 0;
798       virtual void redo(EditData*) override = 0;
799       };
800 
801 //---------------------------------------------------------
802 //   RemoveMeasures
803 //---------------------------------------------------------
804 
805 class RemoveMeasures : public InsertRemoveMeasures {
806 
807    public:
RemoveMeasures(MeasureBase * m1,MeasureBase * m2)808       RemoveMeasures(MeasureBase* m1, MeasureBase* m2) : InsertRemoveMeasures(m1, m2) {}
undo(EditData *)809       virtual void undo(EditData*) override { insertMeasures(); }
redo(EditData *)810       virtual void redo(EditData*) override { removeMeasures(); }
811       UNDO_NAME("RemoveMeasures")
812       };
813 
814 //---------------------------------------------------------
815 //   InsertMeasures
816 //---------------------------------------------------------
817 
818 class InsertMeasures : public InsertRemoveMeasures {
819 
820    public:
InsertMeasures(MeasureBase * m1,MeasureBase * m2)821       InsertMeasures(MeasureBase* m1, MeasureBase* m2) : InsertRemoveMeasures(m1, m2) {}
redo(EditData *)822       virtual void redo(EditData*) override { insertMeasures(); }
undo(EditData *)823       virtual void undo(EditData*) override { removeMeasures(); }
824       UNDO_NAME("InsertMeasures")
825       };
826 
827 //---------------------------------------------------------
828 //   AddExcerpt
829 //---------------------------------------------------------
830 
831 class AddExcerpt : public UndoCommand {
832       Excerpt* excerpt;
833 
834    public:
AddExcerpt(Excerpt * ex)835       AddExcerpt(Excerpt* ex) : excerpt(ex) {}
836       virtual void undo(EditData*) override;
837       virtual void redo(EditData*) override;
838       UNDO_NAME("AddExcerpt")
839       };
840 
841 //---------------------------------------------------------
842 //   RemoveExcerpt
843 //---------------------------------------------------------
844 
845 class RemoveExcerpt : public UndoCommand {
846       Excerpt* excerpt;
847 
848    public:
RemoveExcerpt(Excerpt * ex)849       RemoveExcerpt(Excerpt* ex) : excerpt(ex) {}
850       virtual void undo(EditData*) override;
851       virtual void redo(EditData*) override;
852       UNDO_NAME("RemoveExcerpt")
853       };
854 
855 //---------------------------------------------------------
856 //   SwapExcerpt
857 //---------------------------------------------------------
858 
859 class SwapExcerpt : public UndoCommand {
860       MasterScore* score;
861       int pos1;
862       int pos2;
863 
864       void flip(EditData*) override;
865 
866    public:
SwapExcerpt(MasterScore * s,int p1,int p2)867       SwapExcerpt(MasterScore* s, int p1, int p2) : score(s), pos1(p1), pos2(p2) {}
868       UNDO_NAME("SwapExcerpt")
869       };
870 
871 //---------------------------------------------------------
872 //   ChangeExcerptTitle
873 //---------------------------------------------------------
874 
875 class ChangeExcerptTitle : public UndoCommand {
876       Excerpt* excerpt;
877       QString title;
878 
879       void flip(EditData*) override;
880 
881    public:
ChangeExcerptTitle(Excerpt * x,const QString & t)882       ChangeExcerptTitle(Excerpt* x, const QString& t) : excerpt(x), title(t) {}
883       UNDO_NAME("ChangeExcerptTitle")
884       };
885 
886 //---------------------------------------------------------
887 //   ChangeBend
888 //---------------------------------------------------------
889 
890 class ChangeBend : public UndoCommand {
891       Bend* bend;
892       QList<PitchValue> points;
893 
894       void flip(EditData*) override;
895 
896    public:
ChangeBend(Bend * b,QList<PitchValue> p)897       ChangeBend(Bend* b, QList<PitchValue> p) : bend(b), points(p) {}
898       UNDO_NAME("ChangeBend")
899       };
900 
901 //---------------------------------------------------------
902 //   ChangeTremoloBar
903 //---------------------------------------------------------
904 
905 class ChangeTremoloBar : public UndoCommand {
906       TremoloBar* bend;
907       QList<PitchValue> points;
908 
909       void flip(EditData*) override;
910 
911    public:
ChangeTremoloBar(TremoloBar * b,QList<PitchValue> p)912       ChangeTremoloBar(TremoloBar* b, QList<PitchValue> p) : bend(b), points(p) {}
913       UNDO_NAME("ChangeTremoloBar")
914       };
915 
916 //---------------------------------------------------------
917 //   ChangeNoteEvents
918 //---------------------------------------------------------
919 
920 class ChangeNoteEvents : public UndoCommand {
921       //Chord* chord;
922       QList<NoteEvent*> events;
923 
924       void flip(EditData*) override;
925 
926    public:
ChangeNoteEvents(Chord *,const QList<NoteEvent * > & l)927       ChangeNoteEvents(Chord* /*n*/, const QList<NoteEvent*>& l) : /*chord(n),*/ events(l) {}
928       UNDO_NAME("ChangeNoteEvents")
929       };
930 
931 //---------------------------------------------------------
932 //   ChangeNoteEventList
933 //---------------------------------------------------------
934 
935 class ChangeNoteEventList : public UndoCommand {
936       Ms::Note*      note;
937       NoteEventList  newEvents;
938       PlayEventType  newPetype;
939 
940       void flip(EditData*) override;
941 
942    public:
ChangeNoteEventList(Ms::Note * n,NoteEventList & ne)943       ChangeNoteEventList(Ms::Note* n, NoteEventList& ne) :
944          note(n), newEvents(ne), newPetype(PlayEventType::User) {}
945       UNDO_NAME("ChangeNoteEventList")
946       };
947 
948 //---------------------------------------------------------
949 //   ChangeChordPlayEventType
950 //---------------------------------------------------------
951 
952 class ChangeChordPlayEventType : public UndoCommand {
953       Ms::Chord* chord;
954       Ms::PlayEventType petype;
955       QList<NoteEventList> events;
956 
957       void flip(EditData*) override;
958 
959    public:
ChangeChordPlayEventType(Chord * c,Ms::PlayEventType pet)960       ChangeChordPlayEventType(Chord* c, Ms::PlayEventType pet) : chord(c), petype(pet) { events = c->getNoteEventLists(); }
961       UNDO_NAME("ChangeChordPlayEventType")
962       };
963 
964 //---------------------------------------------------------
965 //   ChangeInstrument
966 //    change instrument in an InstrumentChange element
967 //---------------------------------------------------------
968 
969 class ChangeInstrument : public UndoCommand {
970       InstrumentChange* is;
971       Instrument* instrument;
972 
973       void flip(EditData*) override;
974 
975    public:
ChangeInstrument(InstrumentChange * _is,Instrument * i)976       ChangeInstrument(InstrumentChange* _is, Instrument* i) : is(_is), instrument(i) {}
977       UNDO_NAME("ChangeInstrument")
978       };
979 
980 extern void updateNoteLines(Segment*, int track);
981 
982 //---------------------------------------------------------
983 //   SwapCR
984 //---------------------------------------------------------
985 
986 class SwapCR : public UndoCommand {
987       ChordRest* cr1;
988       ChordRest* cr2;
989 
990       void flip(EditData*) override;
991 
992    public:
SwapCR(ChordRest * a,ChordRest * b)993       SwapCR(ChordRest* a, ChordRest* b) : cr1(a), cr2(b) {}
994       UNDO_NAME("SwapCR")
995       };
996 
997 //---------------------------------------------------------
998 //   ChangeClefType
999 //---------------------------------------------------------
1000 
1001 class ChangeClefType : public UndoCommand {
1002       Clef* clef;
1003       ClefType concertClef;
1004       ClefType transposingClef;
1005       void flip(EditData*) override;
1006 
1007    public:
1008       ChangeClefType(Clef*, ClefType cl, ClefType tc);
1009       UNDO_NAME("ChangeClef")
1010       };
1011 
1012 //---------------------------------------------------------
1013 //   MoveStaff
1014 //---------------------------------------------------------
1015 #if 0 // commented out in mscore/instrwidget.cpp, not used anywhere else
1016 class MoveStaff : public UndoCommand {
1017       Staff* staff;
1018       Part* part;
1019       int rstaff;
1020 
1021       void flip(EditData*) override;
1022 
1023    public:
1024       MoveStaff(Staff* s, Part* p, int idx) : staff(s), part(p), rstaff(idx) {}
1025       UNDO_NAME("MoveStaff")
1026       };
1027 #endif
1028 
1029 //---------------------------------------------------------
1030 //   ChangeProperty
1031 //---------------------------------------------------------
1032 
1033 class ChangeProperty : public UndoCommand {
1034    protected:
1035       ScoreElement* element;
1036       Pid id;
1037       QVariant property;
1038       PropertyFlags flags;
1039 
1040       void flip(EditData*) override;
1041 
1042    public:
1043       ChangeProperty(ScoreElement* e, Pid i, const QVariant& v, PropertyFlags ps = PropertyFlags::NOSTYLE)
element(e)1044          : element(e), id(i), property(v), flags(ps) {}
getId()1045       Pid getId() const  { return id; }
getElement()1046       ScoreElement* getElement() const { return element; }
data()1047       QVariant data() const { return property; }
1048       UNDO_NAME("ChangeProperty")
1049 
isFiltered(UndoCommand::Filter f,const Element * target)1050       bool isFiltered(UndoCommand::Filter f, const Element* target) const override
1051             {
1052             return f == UndoCommand::Filter::ChangePropertyLinked && target->linkList().contains(element);
1053             }
1054       };
1055 
1056 //---------------------------------------------------------
1057 //   ChangeBracketProperty
1058 //---------------------------------------------------------
1059 
1060 class ChangeBracketProperty : public ChangeProperty {
1061       Staff* staff;
1062       int level;
1063 
1064       void flip(EditData*) override;
1065 
1066    public:
1067       ChangeBracketProperty(Staff* s, int l, Pid i, const QVariant& v, PropertyFlags ps = PropertyFlags::NOSTYLE)
ChangeProperty(nullptr,i,v,ps)1068          : ChangeProperty(nullptr, i, v, ps), staff(s), level(l) {}
1069       UNDO_NAME("ChangeBracketProperty")
1070       };
1071 
1072 //---------------------------------------------------------
1073 //   ChangeTextLineProperty
1074 //---------------------------------------------------------
1075 
1076 class ChangeTextLineProperty : public ChangeProperty {
1077 
1078       void flip(EditData*) override;
1079 
1080    public:
ChangeTextLineProperty(ScoreElement * e,QVariant v)1081       ChangeTextLineProperty(ScoreElement* e, QVariant v)
1082          : ChangeProperty(e, Pid::SYSTEM_FLAG, v, PropertyFlags::NOSTYLE) {}
1083       UNDO_NAME("ChangeTextLineProperty")
1084       };
1085 
1086 //---------------------------------------------------------
1087 //   ChangeMetaText
1088 //---------------------------------------------------------
1089 
1090 class ChangeMetaText : public UndoCommand {
1091       Score* score;
1092       QString id;
1093       QString text;
1094 
1095       void flip(EditData*) override;
1096 
1097    public:
ChangeMetaText(Score * s,const QString & i,const QString & t)1098       ChangeMetaText(Score* s, const QString& i, const QString& t) : score(s), id(i), text(t) {}
1099       UNDO_NAME("ChangeMetaText")
1100       };
1101 
1102 //---------------------------------------------------------
1103 //   ChangeSynthesizerState
1104 //---------------------------------------------------------
1105 
1106 class ChangeSynthesizerState : public UndoCommand {
1107       Score* score;
1108       SynthesizerState state;
1109 
1110       void flip(EditData*) override;
1111 
1112    public:
ChangeSynthesizerState(Score * s,const SynthesizerState & st)1113       ChangeSynthesizerState(Score* s, const SynthesizerState& st) : score(s), state(st) {}
1114       UNDO_NAME("ChangeSynthesizerState")
1115       };
1116 
1117 //---------------------------------------------------------
1118 //   RemoveBracket
1119 //---------------------------------------------------------
1120 
1121 class RemoveBracket : public UndoCommand {
1122       Staff* staff;
1123       int level;
1124       BracketType type;
1125       int span;
1126 
1127       virtual void undo(EditData*) override;
1128       virtual void redo(EditData*) override;
1129 
1130    public:
RemoveBracket(Staff * s,int l,BracketType t,int sp)1131       RemoveBracket(Staff* s, int l, BracketType t, int sp) : staff(s), level(l), type(t), span(sp) {}
1132       UNDO_NAME("RemoveBracket")
1133       };
1134 
1135 //---------------------------------------------------------
1136 //   AddBracket
1137 //---------------------------------------------------------
1138 
1139 class AddBracket : public UndoCommand {
1140       Staff* staff;
1141       int level;
1142       BracketType type;
1143       int span;
1144 
1145       virtual void undo(EditData*) override;
1146       virtual void redo(EditData*) override;
1147 
1148    public:
AddBracket(Staff * s,int l,BracketType t,int sp)1149       AddBracket(Staff* s, int l, BracketType t, int sp) : staff(s), level(l), type(t), span(sp) {}
1150       UNDO_NAME("AddBracket")
1151       };
1152 
1153 //---------------------------------------------------------
1154 //   ChangeSpannerElements
1155 //---------------------------------------------------------
1156 
1157 class ChangeSpannerElements : public UndoCommand {
1158       Spanner* spanner;
1159       Element* startElement;
1160       Element* endElement;
1161 
1162       void flip(EditData*) override;
1163 
1164    public:
ChangeSpannerElements(Spanner * s,Element * se,Element * ee)1165       ChangeSpannerElements(Spanner* s, Element* se, Element* ee)
1166          : spanner(s), startElement(se), endElement(ee) {}
1167       UNDO_NAME("ChangeSpannerElements")
1168       };
1169 
1170 //---------------------------------------------------------
1171 //   ChangeParent
1172 //---------------------------------------------------------
1173 
1174 class ChangeParent : public UndoCommand {
1175       Element* element;
1176       Element* parent;
1177       int staffIdx;
1178 
1179       void flip(EditData*) override;
1180 
1181    public:
ChangeParent(Element * e,Element * p,int si)1182       ChangeParent(Element* e, Element* p, int si) : element(e), parent(p), staffIdx(si) {}
1183       UNDO_NAME("ChangeParent")
1184       };
1185 
1186 //---------------------------------------------------------
1187 //   ChangeMMRest
1188 //---------------------------------------------------------
1189 
1190 class ChangeMMRest : public UndoCommand {
1191       Measure* m;
1192       Measure* mmrest;
1193 
1194       void flip(EditData*) override;
1195 
1196    public:
ChangeMMRest(Measure * _m,Measure * _mmr)1197       ChangeMMRest(Measure* _m, Measure* _mmr) : m(_m), mmrest(_mmr) {}
1198       UNDO_NAME("ChangeMMRest")
1199       };
1200 
1201 //---------------------------------------------------------
1202 //   InsertTime
1203 //---------------------------------------------------------
1204 
1205 class InsertTime : public UndoCommand {
1206       Score* score;
1207       Fraction tick;
1208       Fraction len;
1209 
1210       void redo(EditData*) override;
1211       void undo(EditData*) override;
1212 
1213    public:
InsertTime(Score * _score,const Fraction & _tick,const Fraction & _len)1214       InsertTime(Score* _score, const Fraction& _tick, const Fraction& _len)
1215          : score(_score), tick(_tick), len(_len) {}
1216       UNDO_NAME("InsertTime")
1217       };
1218 
1219 //---------------------------------------------------------
1220 //   InsertTimeUnmanagedSpanner
1221 //---------------------------------------------------------
1222 
1223 class InsertTimeUnmanagedSpanner : public UndoCommand {
1224       Score* score;
1225       Fraction tick;
1226       Fraction len;
1227 
1228       void flip(EditData*) override;
1229 
1230    public:
InsertTimeUnmanagedSpanner(Score * s,const Fraction & _tick,const Fraction & _len)1231       InsertTimeUnmanagedSpanner(Score* s, const Fraction& _tick, const Fraction& _len)
1232          : score(s), tick(_tick), len(_len) {}
1233       UNDO_NAME("InsertTimeUnmanagedSpanner")
1234       };
1235 
1236 //---------------------------------------------------------
1237 //   ChangeNoteEvent
1238 //---------------------------------------------------------
1239 
1240 class ChangeNoteEvent : public UndoCommand {
1241       Note* note;
1242       NoteEvent* oldEvent;
1243       NoteEvent newEvent;
1244       PlayEventType  newPetype;
1245 
1246       void flip(EditData*) override;
1247 
1248    public:
ChangeNoteEvent(Note * n,NoteEvent * oe,const NoteEvent & ne)1249       ChangeNoteEvent(Note* n, NoteEvent* oe, const NoteEvent& ne)
1250          : note(n), oldEvent(oe), newEvent(ne), newPetype(PlayEventType::User) {}
1251       UNDO_NAME("ChangeNoteEvent")
1252       };
1253 
1254 //---------------------------------------------------------
1255 //   LinkUnlink
1256 //---------------------------------------------------------
1257 
1258 class LinkUnlink : public UndoCommand {
1259       bool mustDelete  { false };
1260 
1261    protected:
1262       LinkedElements* le;
1263       ScoreElement* e;
1264 
1265       void link();
1266       void unlink();
1267 
1268    public:
LinkUnlink()1269       LinkUnlink() {}
1270       ~LinkUnlink();
1271       };
1272 
1273 //---------------------------------------------------------
1274 //   Unlink
1275 //---------------------------------------------------------
1276 
1277 class Unlink : public LinkUnlink {
1278    public:
1279       Unlink(ScoreElement*);
undo(EditData *)1280       virtual void undo(EditData*) override { link(); }
redo(EditData *)1281       virtual void redo(EditData*) override { unlink(); }
1282       UNDO_NAME("Unlink")
1283       };
1284 
1285 //---------------------------------------------------------
1286 //   Link
1287 //---------------------------------------------------------
1288 
1289 class Link : public LinkUnlink {
1290    public:
1291       Link(ScoreElement*, ScoreElement*);
undo(EditData *)1292       virtual void undo(EditData*) override { unlink(); }
redo(EditData *)1293       virtual void redo(EditData*) override { link();   }
1294       UNDO_NAME("Link")
1295 
1296       bool isFiltered(UndoCommand::Filter f, const Element* target) const override;
1297       };
1298 
1299 //---------------------------------------------------------
1300 //   ChangeStartEndSpanner
1301 //---------------------------------------------------------
1302 
1303 class ChangeStartEndSpanner : public UndoCommand {
1304       Spanner* spanner;
1305       Element* start;
1306       Element* end;
1307 
1308       void flip(EditData*) override;
1309 
1310    public:
ChangeStartEndSpanner(Spanner * sp,Element * s,Element * e)1311       ChangeStartEndSpanner(Spanner* sp, Element*s, Element*e) : spanner(sp), start(s), end(e) {}
1312       UNDO_NAME("ChangeStartEndSpanner")
1313       };
1314 
1315 //---------------------------------------------------------
1316 //   ChangeMetaTags
1317 //---------------------------------------------------------
1318 
1319 class ChangeMetaTags : public UndoCommand {
1320       Score* score;
1321       QMap<QString,QString> metaTags;
1322 
1323       void flip(EditData*) override;
1324 
1325    public:
ChangeMetaTags(Score * s,const QMap<QString,QString> & m)1326       ChangeMetaTags(Score* s, const QMap<QString,QString>& m) : score(s), metaTags(m) {}
1327       UNDO_NAME("ChangeMetaTags")
1328       };
1329 
1330 //---------------------------------------------------------
1331 //   ChangeDrumset
1332 //---------------------------------------------------------
1333 
1334 class ChangeDrumset : public UndoCommand {
1335       Instrument* instrument;
1336       Drumset drumset;
1337 
1338       void flip(EditData*) override;
1339 
1340    public:
ChangeDrumset(Instrument * i,const Drumset * d)1341       ChangeDrumset(Instrument* i, const Drumset* d) : instrument(i), drumset(*d) {}
1342       UNDO_NAME("ChangeDrumset")
1343       };
1344 
1345 //---------------------------------------------------------
1346 //   FretDot
1347 //---------------------------------------------------------
1348 
1349 class FretDot : public UndoCommand {
1350       FretDiagram* diagram;
1351       int string;
1352       int fret;
1353       bool add;
1354       FretDotType dtype;
1355       FretUndoData undoData;
1356 
1357       void redo(EditData*) override;
1358       void undo(EditData*) override;
1359 
1360    public:
1361       FretDot(FretDiagram* d, int _string, int _fret, bool _add = false, FretDotType _dtype = FretDotType::NORMAL)
diagram(d)1362          : diagram(d), string(_string), fret(_fret), add(_add), dtype(_dtype) {}
1363       UNDO_NAME("FretDot")
1364       };
1365 
1366 //---------------------------------------------------------
1367 //   FretMarker
1368 //---------------------------------------------------------
1369 
1370 class FretMarker : public UndoCommand {
1371       FretDiagram* diagram;
1372       int string;
1373       FretMarkerType mtype;
1374       FretUndoData undoData;
1375 
1376       void redo(EditData*) override;
1377       void undo(EditData*) override;
1378 
1379    public:
FretMarker(FretDiagram * d,int _string,FretMarkerType _mtype)1380       FretMarker(FretDiagram* d, int _string, FretMarkerType _mtype) : diagram(d), string(_string), mtype(_mtype) {}
1381       UNDO_NAME("FretMarker")
1382       };
1383 
1384 //---------------------------------------------------------
1385 //   FretBarre
1386 //---------------------------------------------------------
1387 
1388 class FretBarre : public UndoCommand {
1389       FretDiagram* diagram;
1390       int string;
1391       int fret;
1392       bool add;
1393       FretUndoData undoData;
1394 
1395       void redo(EditData*) override;
1396       void undo(EditData*) override;
1397 
1398    public:
diagram(d)1399       FretBarre(FretDiagram* d, int _string, int _fret, bool _add = false) : diagram(d), string(_string), fret(_fret), add(_add) {}
1400       UNDO_NAME("FretBarre")
1401       };
1402 
1403 //---------------------------------------------------------
1404 //   FretClear
1405 //---------------------------------------------------------
1406 
1407 class FretClear : public UndoCommand {
1408       FretDiagram* diagram;
1409       FretUndoData undoData;
1410 
1411       void redo(EditData*) override;
1412       void undo(EditData*) override;
1413 
1414    public:
FretClear(FretDiagram * d)1415       FretClear(FretDiagram* d) : diagram(d) {}
1416       UNDO_NAME("FretClear")
1417       };
1418 
1419 //---------------------------------------------------------
1420 //   MoveTremolo
1421 //---------------------------------------------------------
1422 
1423 class MoveTremolo : public UndoCommand {
1424       Score* score { nullptr };
1425       Fraction chord1Tick;
1426       Fraction chord2Tick;
1427       Tremolo* trem { nullptr };
1428       int track { 0 };
1429 
1430       Chord* oldC1 { nullptr };
1431       Chord* oldC2 { nullptr };
1432 
1433       void undo(EditData*) override;
1434       void redo(EditData*) override;
1435 
1436    public:
MoveTremolo(Score * s,Fraction c1,Fraction c2,Tremolo * tr,int t)1437       MoveTremolo(Score* s, Fraction c1, Fraction c2, Tremolo* tr, int t) : score(s), chord1Tick(c1), chord2Tick(c2), trem(tr), track(t) {}
1438       UNDO_NAME("MoveTremolo")
1439       };
1440 
1441 //---------------------------------------------------------
1442 //   ChangeScoreOrder
1443 //---------------------------------------------------------
1444 
1445 class ChangeScoreOrder : public UndoCommand {
1446       Score* score;
1447       ScoreOrder* order;
1448       void flip(EditData*) override;
1449 
1450    public:
ChangeScoreOrder(Score * sc,ScoreOrder * so)1451       ChangeScoreOrder(Score* sc, ScoreOrder* so) : score(sc), order(so) {};
1452       UNDO_NAME("ChangeScoreOrder")
1453       };
1454 
1455 }     // namespace Ms
1456 #endif
1457