ARMusicalVoice.h

#ifndef ARMusicalVoice_H
#define ARMusicalVoice_H
 
/*
  GUIDO Library
  Copyright (C) 2002  Holger Hoos, Juergen Kilian, Kai Renz
  Copyright (C) 2002-2017 Grame
 
  This Source Code Form is subject to the terms of the Mozilla Public
  License, v. 2.0. If a copy of the MPL was not distributed with this
  file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
  Grame Research Laboratory, 11, cours de Verdun Gensoul 69002 Lyon - France
  research@grame.fr
 
*/
 
#include <map>
#include <vector>
 
#include "ObjectList.h"
#include "ARMusicalEvent.h"
#include "TagList.h"        // is a typedef
#include  "kf_ilist.h"      // for ObjectList
 
class ARMusicalVoiceState;
class ARPositionTag;
class ARVoiceManager;
class ARMeter;
class ARBeamState;
class ARDisplayDuration;
class ARBase;
class ARTuplet;
class ARMusic;
class ARMusicalTag;
class ARChordTag;
class ARShareLocation;
class ARShareStem;
class ARGrace;
class ARNote;
class ARClef;
class ARKey;
class ARCluster;
class ARRepeatBegin;
 
class GRVoiceManager;
class TimeUnwrap;
 
typedef KF_IPointerList<ARPositionTag> PositionTagList;
typedef KF_IPointerList<ARPositionTag> StartPositionTagList;
 
class ARChordGroup
{
    public:
 
        ARChordGroup() : dur( DURATION_0 ), startpos( 0 ), endpos( 0 ) { } 
 
        TYPE_DURATION dur;
        GuidoPos startpos;
        GuidoPos endpos;
};
 
typedef KF_IPointerList<ARChordGroup> ChordGroupList;
 
 
class ARMusicalVoice : public ObjectList, public ARMusicalEvent
{
    friend class GRVoiceManager;
    friend class ARMusic;
    
    public:
        typedef enum   CHORD_TYPE {UP_SIMPLE, DOWN_SIMPLE, UP, DOWN, UP_COMPLEX, DOWN_COMPLEX, CHORDERROR} CHORD_TYPE;
        typedef enum   CHORD_ACCIDENTAL {NATURAL, FLAT, SHARP, CAU_NATURAL, CAU_FLAT, CAU_SHARP, NONE} CHORD_ACCIDENTAL;
        // cau_natural, cau_flat, cau_sharp : cautionary accidentals
    
                        ARMusicalVoice();
        virtual        ~ARMusicalVoice();
 
        void            MarkVoice(float from,float length, unsigned char red, unsigned char green, unsigned char blue);
        void            MarkVoice(int fromnum,int fromdenom, int lengthnum, int lengthdenom, unsigned char red, unsigned char green, unsigned char blue);
 
        virtual void        initChordNote();
        virtual void        FinishChord(bool regular = true);
        virtual ARChordTag *BeginChord();
 
        ARNote        * setTrillChord(CHORD_TYPE & param_type, CHORD_ACCIDENTAL & param_accidental);
        void            finishTrilledChord();
        void            setClusterChord(ARCluster *inCurrentCluster);
        
        int             removeTag(ARMusicalObject * obj);
        void            SplitEventAtPos(ARMusicalVoiceState & vst, const TYPE_TIMEPOSITION & tp, int tieormerge);
        static void     DispdurToTupletdur(TYPE_DURATION & dur,const TYPE_DURATION & base);
        static void     TupletdurToDispdur(TYPE_DURATION & dur,const TYPE_DURATION & base);
        static bool     DurationIsDisplayable(TYPE_DURATION & dur,int & b_punkt);
        static bool     DurationFitsBase(const TYPE_DURATION & dur,const TYPE_DURATION & base, TYPE_DURATION & newbase);
        void            ConvertToNormalForm();
 
        virtual GuidoPos getLastEventPosition();
//      virtual void    FreezeState(ARMusicalVoiceState * in);
        virtual void    setPositionTagEndPos(int id, ARMusicalTag * tag, ARMusicalTag * start = NULL);
        virtual void    RemovePositionTag( ARPositionTag * ptag);
        virtual void    AddPositionTag(ARPositionTag *);
        virtual PositionTagList * createPositionTagList();
        virtual GuidoPos getPositionTagPos (const ARPositionTag *) const;
 
        // does Auto-Beaming ...
        virtual void    doAutoStuff1();
        virtual void    doAutoStuff2();
    
        virtual void doAutoCluster();
 
        // expensive Function!
        GuidoPos        getPosAtTimePosition( const TYPE_TIMEPOSITION & timeposition);
        // expensive Function!
        ObjectList *    getARMusicalObjectsAtTimePosition(const TYPE_TIMEPOSITION & timeposition);
 
        // This adds a Musical-Object to the voice at the current time-position
        // The musical-object gets a time (relativeTimePosition) and the duration of the voice is adjusted 
        // (+ duration of musical object).
        GuidoPos        AddTail(ARMusicalObject * newMusicalObject);
 
        // inserts a musical object at the tail without doing time-setting and other stuff. 
        // is called mainly from CopyChord-function.
        GuidoPos        InsertAtTail(ARMusicalObject * newMusicalObject);
        // adjust the duration of a voice by adding a rest-event
        void            adjustDuration(const TYPE_DURATION & newDuration);
 
        virtual void browse(TimeUnwrap& mapper) const;
        virtual void browse(TimeUnwrap& mapper, ARMusicalVoiceState& state) const;
        virtual void browse(TimeUnwrap& mapper, const ARMusicalObject * start, const ARMusicalObject * end=0) const;
 
//      virtual void    resetGRRepresentation();
 
        // functions for the voicestate...
        virtual         GuidoPos            GetHeadPosition(ARMusicalVoiceState & vst) const;
        virtual         GuidoPos            GetHeadPosition() const;
        virtual         void                GetPrevEvent(GuidoPos & pos, ARMusicalVoiceState & vst) const;
        virtual         ARMusicalObject *   GetNext(GuidoPos & pos, ARMusicalVoiceState & vst) const;
        virtual         ARMusicalObject *   GetNextObject(GuidoPos & pos) const;
        virtual const   ARMusicalVoiceState * getVoiceState() const     { return mCurVoiceState; }
 
        // for automatic-beaming ...
        enum bmstate { BEAMSAUTO, BEAMSOFF, BEAMSEXPLICIT, BEAMSFULL };
 
        // this enumeration deals with the readmode.
        // CHORDMODE means that when getting the next (or previous) event, we check whether we are
        // within a chord and then overread (and save) all other events within the chord.
        enum _readmode { CHORDMODE, EVENTMODE };
 
        void            setVoiceNum(int num)                { voicenum = num;   }
        int             getVoiceNum() const                 { return voicenum;  }
        void            removeAutoTags();
        void            setReadMode(_readmode newreadmode)  { readmode = newreadmode; }
        _readmode getReadMode() const                       { return readmode; }
 
        // C.D. 22/10/2014 Perf improvement : prevent CheckBreakPosition from searching a RepeatBegin tag in all voice list
        void addRepeatBegin(ARRepeatBegin *repeatBegin)     { repeatBeginList->push_back(repeatBegin); }
        std::vector<ARRepeatBegin *> * getRepeatBeginList() { return repeatBeginList; }
 
        void printName(std::ostream& os) const;
        void printParameters(std::ostream& os) const;
 
        /* Visitor design pattern */
//        void goThrough(ARVisitor *visitor);
//        void goThroughTagsList(ARVisitor *visitor, GuidoPos& posTag, GuidoPos prevPos, bool addTag) const;
 
        virtual void accept (ARVisitor& visitor);
 
    /**************************/
    protected:
        ARChordTag      *currentChord;
        ARShareLocation *currentShareLocation;
        ChordGroupList  *chordgrouplist;
        GuidoPos         posfirstinchord;
        int              numchordvoice;
        bool             isInChord;
        int              sum;
        int              pitchsum;
        int              voicenum;
        
        void doAutoKeys();
        void checkKeys(); // jfk
        void doAutoDispatchLyrics();
        void doAutoFermatas();
        void doAutoTies();
        void doAutoCheckStaffStateTags();
        void doAutoDisplayCheck();
        void doAutoBarlines();
        void doAutoMeasuresNumbering();
        void doAutoEndBar();
        void doAutoBeaming();
        void doAutoGlissando();
        void doAutoFeatheredBeam();
        void doAutoFixOctavaStaff();
 
        void doMicroTonal();
        void getOctava(int voice, std::map< int, std::vector<AROctava*> >& list);
 
        void CloseBase          ( ARBase * curbase, ARTuplet * autotuplet, GuidoPos lastevpos, GuidoPos FLA);
        void ReplacePositionTag ( const ARPositionTag * ptold, ARPositionTag * ptnew, ARMusicalVoiceState & vst, const char * endtagname = 0 );
        const ARDisplayDuration* InsertDisplayDurationTag (const TYPE_DURATION & dispdur, int b_punkt, const TYPE_TIMEPOSITION & tp,
                                        GuidoPos pos, ARMusicalVoiceState & vst, int setptagpos = 1);
 
        GuidoPos              lastevposition;
        ARMusicalVoiceState * mCurVoiceState;
        ARMusicalVoiceState * endState;                             // the musicalvoice state at the very end.
 
        // automatic beaming.
        int beamLookAhead(GuidoPos & pos, TYPE_DURATION & unit);
        bmstate beamstate;
 
        _readmode readmode;
 
        PositionTagList *       mPosTagList;
        StartPositionTagList *  mStartPosTagList;
    
    private:
        void        finishChordWithOneChordGroup     (TYPE_DURATION &chorddur, bool regular);
        void        finishChordWithSeveralChordGroups(TYPE_DURATION &chorddur, bool regular);
 
        GuidoPos    CopyChord( ARMusicalVoiceState & vst, TYPE_TIMEPOSITION tp, const TYPE_DURATION & newdur);
        ARClef*     newAutoClef(ARClef* oldclef, const TYPE_TIMEPOSITION& tp);
        ARKey *     newAutoKey(ARKey * oldkey, const TYPE_TIMEPOSITION& tp);
    
        // the methods below are all used by the doAutoBeaming method
        TYPE_DURATION   beamBeatUnit(const TYPE_DURATION curmeter) const;
        TYPE_DURATION   beamGetBeat(const ARMeter * curmeter, const TYPE_TIMEPOSITION& pos, TYPE_DURATION curbeat) const;
        int             beamTrackBeam(const ARMusicalVoiceState& vs) const;
        bool            beamStartPos(const TYPE_TIMEPOSITION pos, const TYPE_DURATION beat) const;
        bool            beamStartEv(const ARMusicalEvent* ev, const ARMusicalVoiceState& vs, const TYPE_DURATION beat, const TYPE_TIMEPOSITION lastbartp) const;
        void            beamCreate(ARMusicalVoiceState& vst, const GuidoPos posev1, const GuidoPos posevn, const GuidoPos FLA, const GuidoPos LRA_plus, const TYPE_TIMEPOSITION tpev1, bool full);
        bool            beamOnBeat(const TYPE_TIMEPOSITION t, const TYPE_DURATION meter, const std::vector<Fraction>& numvec) const;
        bool            beamCrossBeat(const TYPE_TIMEPOSITION beamstart, const TYPE_DURATION beamdur, const TYPE_DURATION meter, const std::vector<Fraction>& numvec) const;
        ARMusicalEvent* beamNextEv (const GuidoPos pos, const ARMusicalVoiceState) const;
        ARShareStem *   createSharedStem(ARChordGroup* group);
        
        // reorder tags before a possible break to put them after the break:
        // tags handled are: octava
        void            checkpbreak();
        
        
        std::vector<ARRepeatBegin *> *repeatBeginList;
        std::vector<ARNote *> getCurrentChordNotes () const;
};
 
#endif