input.h

Go to the documentation of this file.

//=============================================================================
//  MuseScore
//  Music Composition & Notation
//
//  Copyright (C) 2002-2011 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 __INPUT_H__
#define __INPUT_H__

#include "mscore.h"
#include "durationtype.h"
#include "beam.h"

namespace Ms {

class Element;
class Slur;
class ChordRest;
class Drumset;
class Segment;
class Score;
class Selection;

//---------------------------------------------------------
//   NoteEntryMethod
//---------------------------------------------------------

enum class NoteEntryMethod : char {
      STEPTIME, REPITCH, RHYTHM, REALTIME_AUTO, REALTIME_MANUAL, TIMEWISE
      };

//---------------------------------------------------------
//   InputState
//---------------------------------------------------------

class InputState {
      TDuration   _duration    { TDuration::DurationType::V_INVALID };  // currently duration
      int         _drumNote    { -1 };
      int         _track       { 0 };
      int         _prevTrack   { 0 };                       // used for navigation
      Segment*    _lastSegment { 0 };
      Segment*    _segment     { 0 };                       // current segment
      int         _string      { VISUAL_STRING_NONE };      // visual string selected for input (TAB staves only)
      bool _rest               { false };              // rest mode
      NoteType _noteType       { NoteType::NORMAL };
      Beam::Mode _beamMode       { Beam::Mode::AUTO };
      bool _noteEntryMode      { false };
      NoteEntryMethod _noteEntryMethod { NoteEntryMethod::STEPTIME };
      AccidentalType _accidentalType { AccidentalType::NONE };
      Slur* _slur              { 0     };
      bool _insertMode         { false };

      Segment* nextInputPos() const;

   public:
      ChordRest* cr() const;

      Fraction tick() const;

      void setDuration(const TDuration& d) { _duration = d;          }
      TDuration duration() const           { return _duration;       }
      void setDots(int n);
      Fraction ticks() const               { return _duration.ticks(); }

      Segment* segment() const            { return _segment;        }
      void setSegment(Segment* s);

      Segment* lastSegment() const        { return _lastSegment;        }
      void setLastSegment(Segment* s)     { _lastSegment = s;           }

      const Drumset* drumset() const;

      int drumNote() const                { return _drumNote;       }
      void setDrumNote(int v)             { _drumNote = v;          }

      int voice() const                   { return _track == -1 ? 0 : (_track % VOICES); }
      int track() const                   { return _track;          }
      void setTrack(int v)                { _prevTrack = _track; _track = v; }
      int prevTrack() const               { return _prevTrack;      }

      int string() const                  { return _string;             }
      void setString(int val)             { _string = val;              }

      StaffGroup staffGroup() const;

      bool rest() const                   { return _rest; }
      void setRest(bool v)                { _rest = v; }

      NoteType noteType() const           { return _noteType; }
      void setNoteType(NoteType t)        { _noteType = t; }

      Beam::Mode beamMode() const           { return _beamMode; }
      void setBeamMode(Beam::Mode m)        { _beamMode = m; }

      bool noteEntryMode() const          { return _noteEntryMode; }
      void setNoteEntryMode(bool v)       { _noteEntryMode = v; }

      NoteEntryMethod noteEntryMethod() const               { return _noteEntryMethod; }
      void setNoteEntryMethod(NoteEntryMethod m)            { _noteEntryMethod = m; }
      bool usingNoteEntryMethod(NoteEntryMethod m) const    { return m == noteEntryMethod(); }

      AccidentalType accidentalType() const                 { return _accidentalType; }
      void setAccidentalType(AccidentalType val)            { _accidentalType = val;  }

      Slur* slur() const                  { return _slur; }
      void setSlur(Slur* s)               { _slur = s; }

      bool insertMode() const             { return _insertMode; }
      void setInsertMode(bool val)        { _insertMode = val; }

      void update(Selection& selection);
      void moveInputPos(Element* e);
      void moveToNextInputPos();
      bool endOfScore() const;

      // TODO: unify with Selection::cr()?
      static Note* note(Element*);
      static ChordRest* chordRest(Element*);
      };


}     // namespace Ms
#endif