TNote.h

/*

  MusicXML Library
  Copyright (C) 2003  Grame

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  Grame Research Laboratory, 9 rue du Garet, 69001 Lyon - France
  grame@grame.fr

*/

#ifndef __TNote__
#define __TNote__

#include "exports.h"
#include "common.h"
#include "TPitch.h"
#include "TNotation.h"
#include "TScoreInstrument.h"
#include "TTimeModification.h"
#include "smartpointer.h"
#include "TScoreVisitor.h"

namespace MusicXML 
{

class EXP TExpression : public visitable, public smartable {

    public:
        enum { undefined = -1 };
        EXP friend SMARTP<TExpression> newExpression();

        virtual void accept(TScoreVisitor& visitor);

        void    setDynamic(long dyn);
        void    setEndDynamic(long dyn);
        void    setAttack(long attack);
        void    setRelease(long rel);
        void    setPizzicato(YesNo::type pizz);

        long    getDynamic() const      { return fDynamic; }
        long    getEndDynamic() const   { return fEndDynamic; }
        long    getAttack() const       { return fAttack; }
        long    getRelease() const      { return fRelease; }
        YesNo::type getPizzicato() const { return fPizzicato; }

    protected:
        TExpression() 
            :   fDynamic(undefined), fEndDynamic(undefined), fAttack(undefined), 
                fRelease(undefined), fPizzicato(YesNo::undefined) {}
        virtual ~TExpression() {}
    private:
        long    fDynamic;
        long    fEndDynamic;
        long    fAttack;
        long    fRelease;
        YesNo::type fPizzicato;
};
typedef SMARTP<TExpression> SExpression;

class EXP TAccidental : public visitable, public smartable {

    public:
        enum accident { undefined = -1, 
                sharp=1, natural, flat, double_sharp, sharp_sharp, flat_flat,
                natural_sharp, natural_flat, quarter_flat, quarter_sharp,
                three_quarters_flat, three_quarters_sharp, last=three_quarters_sharp };

        EXP friend SMARTP<TAccidental> newAccidental();

        virtual void accept(TScoreVisitor& visitor);

        accident    getAccident() const     { return fAccident; }
        YesNo::type getCautionary() const   { return fCautionary; }
        YesNo::type getEditorial() const    { return fEditorial; }
        FullCue::type getSize() const       { return fSize; }

        void setAccident(accident acc);
        void setCautionary(YesNo::type yn);
        void setEditorial(YesNo::type yn);
        void setSize(FullCue::type size);
 
    static const string xmlaccidental (accident d);
    static accident     xmlaccidental (const string str);

    protected:
        TAccidental() :
                fAccident(undefined), fCautionary(YesNo::undefined), 
                fEditorial(YesNo::undefined), fSize(FullCue::undefined) {}
        virtual ~TAccidental() {}
    private:
        accident    fAccident;
        YesNo::type fCautionary;
        YesNo::type fEditorial;
        FullCue::type fSize;

    static bimap<string, accident> fAccident2String;
    static accident fAccidentTbl[];
    static string   fAccidentStrings[];
};
typedef SMARTP<TAccidental> SAccidental;

class EXP TNoteHead : public visitable, public smartable {

    public:
        enum notehead { undefined = -1, 
                slash=1, triangle, diamond, square, cross, x, circle_x, normal, none, last=none };
        EXP friend SMARTP<TNoteHead> newNoteHead();

        virtual void accept(TScoreVisitor& visitor);

        void    setShape(notehead shape);
        void    setFilled(YesNo::type filled);
        void    setParentheses(YesNo::type par);

        notehead    getShape() const        { return fShape; }
        YesNo::type getFilled() const       { return fFilled; }
        YesNo::type getParentheses() const  { return fParentheses; }

    static const string xmlnotehead (notehead d);
    static notehead     xmlnotehead (const string str);

    protected:
        TNoteHead() : fShape(undefined), fFilled(YesNo::undefined), fParentheses(YesNo::undefined) {}
        virtual ~TNoteHead() {}
    private:
        notehead    fShape;
        YesNo::type fFilled;
        YesNo::type fParentheses;

    static bimap<string, notehead> fNoteHead2String;
    static notehead     fNoteHeadTbl[];
    static string       fNoteHeadStrings[];
};
typedef SMARTP<TNoteHead> SNoteHead;

class EXP TBeam : public visitable, public smartable {

    public:
        enum beamtype { undefined = -1, 
                beambegin=1, beamcontinue, beamend, beamforward, beambackward, last=beambackward };

        EXP friend SMARTP<TBeam> newBeam();

        beamtype        getType() const         { return fType; }
        int             getNumber() const       { return fNumber; }
        YesNo::type     getRepeater() const     { return fRepeater; }

        void        setType(beamtype type);
        void        setNumber(int num);
        void        setRepeater(YesNo::type r);

        virtual void accept(TScoreVisitor& visitor);

    static const string xmlbeamtype (beamtype d);
    static beamtype     xmlbeamtype (const string str);

    protected:
        TBeam() : fType(undefined), fNumber(undefined), fRepeater(YesNo::undefined) {}
        virtual ~TBeam() {}
    private:
        beamtype        fType;
        int             fNumber;
        YesNo::type     fRepeater;

    static bimap<string, beamtype> fBeam2String;
    static beamtype     fBeamTbl[];
    static string       fBeamStrings[];
};
typedef SMARTP<TBeam> SBeam;

class EXP TGraphNote : public visitable, public smartable {

    public:
        enum { undefined = -1, stemdown=1, stemup, stemnone, stemdouble, last=stemdouble  };
        
        EXP friend SMARTP<TGraphNote> newGraphNote();

        virtual void accept(TScoreVisitor& visitor);

        void    setVoice(long voice);
        void    setType(NoteType::type type);
        void    setSize(FullCue::type size);
        void    setDots(unsigned long dots);
        void    setStem(long stem);
        void    setStaff(long staff);

        long            getVoice() const    { return fVoice; }
        NoteType::type  getType() const     { return fType; }
        FullCue::type   getSize() const     { return fSize; }
        unsigned int    getDots() const     { return fDots; }
        int             getStem() const     { return fStem; }
        int             getStaff() const    { return fStaff; }
        
        long add(const SBeam& beam);
        long add(const SNotation& notation);

        SAccidental&    accidental()            { return fAccidental; }
        STimeModification& timemodification()   { return fTimeMod; }
        SNoteHead&      notehead()              { return fNoteHead; }
        vvector<SBeam>&     beamList()              { return fBeamList; }
        vvector<SNotation>&     notationList()      { return fNotationList; }

    static const string xmlstem (int d);
    static int              xmlstem (const string str);

    protected:
        TGraphNote()
            : fVoice(undefined), fType(NoteType::undefined), fSize(FullCue::undefined), fDots(0),
              fStem(undefined), fStaff(undefined) {}
        virtual ~TGraphNote() {}
    private:
        long            fVoice;
        NoteType::type  fType;
        FullCue::type   fSize;
        unsigned long   fDots;
        SAccidental     fAccidental;
        STimeModification fTimeMod;
        long            fStem;
        SNoteHead       fNoteHead;
        long                fStaff;
        vvector<SBeam>      fBeamList;
        vvector<SNotation>  fNotationList;

    static bimap<string, int> fStem2String;
    static int      fStemTbl[];
    static string   fStemStrings[];
};
typedef SMARTP<TGraphNote> SGraphNote;

class EXP TGraceNote : public visitable, public smartable {

    public:
        enum { undefined = -1 };
        EXP friend SMARTP<TGraceNote>   newGraceNote();

        virtual void accept(TScoreVisitor& visitor);

        int getStealPrevious() const    { return fStealPrevious; }
        int getStealFollowing() const   { return fStealFollowing; }
        int getMakeTime() const         { return fMakeTime; }
        YesNo::type getSlash() const    { return fSlash; }

        void setStealPrevious(int v);
        void setStealFollowing(int v);
        void setMakeTime(int v);
        void setSlash(YesNo::type v);

    protected:
        TGraceNote() :
            fStealPrevious(undefined), fStealFollowing(undefined), fMakeTime(undefined),
            fSlash(YesNo::undefined) {}
        virtual ~TGraceNote() {}
    private:
        int fStealPrevious;
        int fStealFollowing;
        int fMakeTime;
        YesNo::type fSlash;
};
typedef SMARTP<TGraceNote> SGraceNote;

class TNote;
typedef SMARTP<TNote> SNote;
class EXP TNote : public TMusicData, public Positionable {

    public:
        enum style { normal, cue, grace };
        enum type { pitched, rest, unpitched };
        EXP friend SMARTP<TNote>    newNote();

        virtual void accept(TScoreVisitor& visitor);

        void            setDuration (unsigned long dur);
        unsigned long   getDuration () const            { return fDuration; }
        unsigned long   getFullDuration();
        void            setInstrumentID(string id);
        const string    getInstrumentID() const         { return fInstrumentID; }

        void            setStyle(style t);
        style           getStyle() const                { return fStyle; }

        void            setType(type t);
        type            getType() const                 { return fType; }

        SPitch&             pitch()         { return fPitch; }
        SExpression&        expression()    { return fExpression; }
        SNote&              tiePrevious()   { return fTiePrev; }
        SNote&              tieNext()       { return fTieNext; }
        SGraphNote&         graphics()      { return fGraphNote; }
        SGraceNote&         graceNote()         { return fGraceNote; }
        
        bool isTie()    { return tieNext() && !tiePrevious();}
        
        bool isSingle() { return !tieNext() && !tiePrevious();}
        
        bool isNormal() { return fStyle == normal;}
        bool isGrace()  { return fStyle == grace;}
        bool isCue()    { return fStyle == cue;}
        
        bool isPitched() { return fType == pitched;}
        bool isRest()   { return fType == rest;}
        bool isUnpitched() { return fType == unpitched;}

        long getVoice() const;
    
    protected:
        TNote() : fStyle(normal), fType(pitched), fDuration(1), fTiePrev(NULL), fTieNext(NULL)  {}
        virtual ~TNote() {}

    private:
        style           fStyle;
        type            fType;
        SPitch          fPitch;
        unsigned long   fDuration;
        string          fInstrumentID;

        SExpression         fExpression;
        SNote               fTiePrev;
        SNote               fTieNext;
        SGraphNote          fGraphNote;
        SGraceNote          fGraceNote;
};

} // namespace MusicXML


#endif

---