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