cursor.h

//=============================================================================
//  MuseScore
//  Music Composition & Notation
//
//  Copyright (C) 2012 Werner Schweer
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License version 2
//  as published by the Free Software Foundation and appearing in
//  the file LICENCE.GPL
//=============================================================================
 
#ifndef __CURSOR_H__
#define __CURSOR_H__
 
#include "fraction.h"
 
namespace Ms {
 
class Element;
class InputState;
class Score;
class Chord;
class Rest;
class Note;
class Segment;
class ChordRest;
class StaffText;
class Measure;
 
enum class SegmentType;
 
namespace PluginAPI {
 
class Element;
class Measure;
class Segment;
class Score;
 
//---------------------------------------------------------
//   @@ Cursor
//---------------------------------------------------------
 
class Cursor : public QObject {
      Q_OBJECT
      Q_PROPERTY(int track      READ track     WRITE setTrack)
      Q_PROPERTY(int staffIdx   READ staffIdx  WRITE setStaffIdx)
      Q_PROPERTY(int voice      READ voice     WRITE setVoice)
      Q_PROPERTY(int filter     READ filter    WRITE setFilter)

      Q_PROPERTY(int tick         READ tick) // FIXME: fraction transition
      Q_PROPERTY(double time      READ time)

      Q_PROPERTY(qreal tempo      READ tempo)

      Q_PROPERTY(int keySignature READ qmlKeySignature)
      Q_PROPERTY(Ms::PluginAPI::Score* score READ score    WRITE setScore)

      Q_PROPERTY(Ms::PluginAPI::Element* element READ element)
      Q_PROPERTY(Ms::PluginAPI::Segment*  segment READ qmlSegment)
      Q_PROPERTY(Ms::PluginAPI::Measure*  measure READ measure)
      Q_PROPERTY(int stringNumber READ inputStateString WRITE setInputStateString)
 
   public:
      enum RewindMode {
            SCORE_START = 0, 
            SELECTION_START = 1, 
            SELECTION_END = 2 
            };
      Q_ENUM(RewindMode);

      enum InputStateMode {
            INPUT_STATE_INDEPENDENT, 
            INPUT_STATE_SYNC_WITH_SCORE 
            };
      Q_ENUM(InputStateMode);
 
   private:
      Q_PROPERTY(InputStateMode inputStateMode READ inputStateMode WRITE setInputStateMode)
 
      Ms::Score* _score = nullptr;
//       bool _expandRepeats; // used?
      SegmentType _filter;
      std::unique_ptr<InputState> is;
      InputStateMode _inputStateMode = INPUT_STATE_INDEPENDENT;
 
      // utility methods
      void prevInTrack();
      void nextInTrack();
      void setScore(Ms::Score* s);
      Ms::Element* currentElement() const;
 
      InputState& inputState();
      const InputState& inputState() const { return const_cast<Cursor*>(this)->inputState(); }
 
      Ms::Segment* segment() const;
      void setSegment(Ms::Segment* seg);
 
      int inputStateString() const;
      void setInputStateString(int);
 
   public:
      Cursor(Ms::Score* s = nullptr);
//       Cursor(Score*, bool); // not implemented? what is bool?
 
      Score* score() const;
      void setScore(Score* s);
 
      int track() const;
      void setTrack(int v);
 
      int staffIdx() const;
      void setStaffIdx(int v);
 
      int voice() const;
      void setVoice(int v);
 
      int filter() const            { return int(_filter); }
      void setFilter(int f)         { _filter = SegmentType(f); }
 
      InputStateMode inputStateMode() const { return _inputStateMode; }
      void setInputStateMode(InputStateMode val);
 
      Element* element() const;
      Segment* qmlSegment() const;
      Measure* measure() const;
 
      int tick();
      double time();
      qreal tempo();
 
      int qmlKeySignature();
 
      Q_INVOKABLE void rewind(RewindMode mode);
      Q_INVOKABLE void rewindToTick(int tick);
 
      Q_INVOKABLE bool next();
      Q_INVOKABLE bool nextMeasure();
      Q_INVOKABLE bool prev();
      Q_INVOKABLE void add(Ms::PluginAPI::Element*);
 
      Q_INVOKABLE void addNote(int pitch, bool addToChord = false);
      Q_INVOKABLE void addRest();
      Q_INVOKABLE void addTuplet(Ms::PluginAPI::FractionWrapper* ratio, Ms::PluginAPI::FractionWrapper* duration);
 
      //@ set duration
      //@   z: numerator
      //@   n: denominator
      //@   Quarter, if n == 0
      Q_INVOKABLE void setDuration(int z, int n);
      };
 
}     // namespace PluginAPI
}     // namespace Ms
#endif