Line data    Source code

       1              : #ifndef MU_IMPORTEXPORT_GPMASTERBAR_H
       2              : #define MU_IMPORTEXPORT_GPMASTERBAR_H
       3              : 
       4              : #include "gpbar.h"
       5              : 
       6              : namespace mu::iex::guitarpro {
       7              : class GPMasterBar
       8              : {
       9              : public:
      10              :     struct Repeat {
      11              :         enum class Type {
      12              :             None, Start, End, StartEnd
      13              :         };
      14              :         Type type{ Type::None };
      15              :         int count{ 1 };
      16              :     };
      17              :     struct KeySig {
      18              :         enum class Accidentals {
      19              :             C_B = -7,
      20              :             G_B, D_B, A_B, E_B, B_B, F, C,
      21              :             G, D, A, E, B, F_S, C_S,
      22              :         };
      23              :         enum class Mode {
      24              :             Major,
      25              :             Minor
      26              :         };
      27              :         Accidentals accidentalCount{ Accidentals::C };
      28              :         Mode mode{ Mode::Major };
      29              :     };
      30              :     enum class TripletFeelType {
      31              :         Triplet8th,
      32              :         Triplet16th,
      33              :         Dotted8th,
      34              :         Dotted16th,
      35              :         Scottish8th,
      36              :         Scottish16th,
      37              :         None
      38              :     };
      39              : 
      40              :     enum class BarlineType {
      41              :         NORMAL,
      42              :         DOUBLE
      43              :     };
      44              : 
      45              :     struct TimeSig {
      46              :         int numerator{ 0 };
      47              :         int denominator{ 0 };
      48              :     };
      49              : 
      50              :     struct Fermata {
      51              :         enum class Type {
      52              :             Short, Medium, Long
      53              :         };
      54              :         Type type{ Type::Medium };
      55              :         float length{ 0 };
      56              :         int offsetNum; //numerator of offset field in GP
      57              :         int offsetDenom; //denominator of offset field in GP
      58              :     };
      59              : 
      60              :     struct Direction {
      61              :         enum class Type {
      62              :             Repeat, Jump, Marker
      63              :         };
      64              : 
      65              :         Type type = Type::Repeat;
      66              :         muse::String name;
      67              :     };
      68              : 
      69          695 :     ~GPMasterBar() = default;
      70              : 
      71          778 :     void addGPBar(std::unique_ptr<GPBar>&& b) { _bars.push_back(std::move(b)); }
      72          695 :     void setTimeSig(const GPMasterBar::TimeSig& sig) { _timeSig = sig; }
      73         2085 :     TimeSig timeSig() const { return _timeSig; }
      74          302 :     bool useFlats() const { return _useFlats; }
      75              : 
      76          695 :     void setKeySig(GPMasterBar::KeySig sig, bool useFlats = false) { _keySig = sig; _useFlats = useFlats; }
      77         1442 :     KeySig keySig() const { return _keySig; }
      78              : 
      79            6 :     void setFermatas(std::vector<Fermata>&& f) { _fermatas.swap(f); }
      80          695 :     const std::vector<Fermata>& fermatas() const { return _fermatas; }
      81              : 
      82            8 :     void setRepeat(Repeat r) { _repeat = r; }
      83          727 :     Repeat repeat() const { return _repeat; }
      84              : 
      85            0 :     void setTripletFeel(TripletFeelType t) { _tripletFeel = t; }
      86          695 :     TripletFeelType tripletFeel() const { return _tripletFeel; }
      87              : 
      88            3 :     void setBarlineType(BarlineType t) { _barlineType = t; }
      89          954 :     BarlineType barlineType() const { return _barlineType; }
      90              : 
      91            8 :     void setFreeTime(bool freeTime) { _freeTime = freeTime; }
      92          940 :     bool freeTime() const { return _freeTime; }
      93              : 
      94            4 :     void setAlternativeEnding(std::vector<int>&& r) { _alternateEndings.swap(r); }
      95          701 :     const std::vector<int>& alternateEnding() const { return _alternateEndings; }
      96              : 
      97            3 :     void setSection(std::pair<muse::String, muse::String>&& s) { _section.swap(s); }
      98         1399 :     const std::pair<muse::String, muse::String>& section() const { return _section; }
      99              : 
     100           36 :     void setDirections(std::vector<Direction>&& d) { _directions.swap(d); }
     101          695 :     const std::vector<Direction>& directions() const { return _directions; }
     102              : 
     103          695 :     void setId(int id) { _id = id; }
     104              :     int id() const { return _id; } //debug helper
     105              : 
     106          695 :     const std::vector<std::unique_ptr<GPBar> >& bars() const { return _bars; }
     107              : 
     108              : private:
     109              : 
     110              :     int _id{ -1 };
     111              :     std::vector<std::unique_ptr<GPBar> > _bars;
     112              :     std::vector<Fermata> _fermatas;
     113              :     std::vector<Direction> _directions;
     114              :     TimeSig _timeSig;
     115              :     KeySig _keySig;
     116              :     bool _useFlats = false;
     117              :     Repeat _repeat;
     118              :     std::vector<int> _alternateEndings;
     119              :     TripletFeelType _tripletFeel = TripletFeelType::None;
     120              :     BarlineType _barlineType = BarlineType::NORMAL;
     121              :     bool _freeTime = false;
     122              :     std::pair<muse::String, muse::String> _section;
     123              :     Direction _direction;
     124              : };
     125              : } // namespace mu::iex::guitarpro
     126              : 
     127              : #endif // MU_IMPORTEXPORT_GPMASTERBAR_H