TNotation.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 __TNotation__
#define __TNotation__

#include "exports.h"
#include "common.h"
#include "smartpointer.h"
#include "TScoreVisitor.h"

namespace MusicXML 
{

class EXP TNotation : public visitable, public smartable {

    public:
        EXP friend SMARTP<TNotation> newNotation();
        
        virtual void accept(TScoreVisitor& visitor);

        long add (const SNotationElement& elt);
        vvector<SNotationElement>& list()           { return fList; }

    protected:
        TNotation() {}
        virtual ~TNotation() {}
    private:
        vvector<SNotationElement>   fList;
};
typedef SMARTP<TNotation> SNotation;

class TTieSlur : public TNotationElement, public Positionable, public Placementable, public Orientable {

    public:
        enum { undefined=-1 };
        
        virtual void accept(TScoreVisitor& visitor) = 0;

        StartStop::type getType() const         { return fType; }
        int             getNumber() const       { return fNumber; }
        LineType::type  getLineType() const     { return fLine; }

        void    setType(StartStop::type type);
        void    setNumber(int num);
        void    setLineType(LineType::type type);

        const string& getElement() const            { return fElement; }

    protected:
        TTieSlur(string elt, StartStop::type type) 
            : fElement(elt), fType(type), fNumber(undefined), fLine(LineType::undefined) {}
        virtual ~TTieSlur() {}
    private:
        string          fElement;
        StartStop::type fType;
        int             fNumber;
        LineType::type  fLine;
 };
 typedef SMARTP<TTieSlur> STieSlur;
 
class EXP TTie : public TTieSlur {
    public:
        EXP friend SMARTP<TTie> newTie(StartStop::type type);
        virtual void accept(TScoreVisitor& visitor);
    protected:
        TTie(StartStop::type type) : TTieSlur("tied", type) {} 
        virtual ~TTie() {}
 };
 typedef SMARTP<TTie> STie;

class EXP TSlur : public TTieSlur {
    public:
        EXP friend SMARTP<TSlur> newSlur(StartStop::type type);
        virtual void accept(TScoreVisitor& visitor);
    protected:
        TSlur(StartStop::type type) : TTieSlur("slur", type) {} 
        virtual ~TSlur() {}
 };
 typedef SMARTP<TSlur> SSlur;

class EXP TTupletDesc : public visitable, public smartable {

    public:
        enum { undefined=-1 };

        virtual void accept(TScoreVisitor& visitor);

        void    setNumber (int num);
        void    setType(int type);
        void    setDots(int dots);

        int     getNumber() const       { return fNumber; }
        int     getType() const         { return fType; }
        int     getDots() const         { return fDots; }

        const string getName() const    { return fName; }

    protected:
        TTupletDesc(string suffix) 
            : fName(suffix), fNumber(undefined), fType(undefined), fDots(0) {}
        virtual ~TTupletDesc() {}

    private:
        string  fName;
        int     fNumber;
        int     fType;
        int     fDots;
};
typedef SMARTP<TTupletDesc> STupletDesc;

class EXP TTupletActual: public TTupletDesc {
    public:
        EXP friend STupletDesc newTupletActual();
    protected:
        TTupletActual() : TTupletDesc("actual") {}
        virtual ~TTupletActual() {}
};

class EXP TTupletNormal: public TTupletDesc {
    public:
        EXP friend STupletDesc newTupletNormal();
    protected:
        TTupletNormal() : TTupletDesc("normal") {}
        virtual ~TTupletNormal() {}
};

class EXP TTuplet : public TNotationElement, public Placementable, public Positionable {

    public:
        enum { undefined=-1, actual=1, both, none, last=none };
        
        EXP friend SMARTP<TTuplet> newTuplet(StartStop::type type);
        virtual void accept(TScoreVisitor& visitor);
        
        void    setType(StartStop::type type);
        void    setNumber(int num);
        void    setBracket(YesNo::type bracket);
        void    setShowNum(int sn);
        void    setShowType(int st);

        StartStop::type getType() const { return fType; }
        int     getNumber() const       { return fNumber; }
        YesNo::type getBracket() const      { return fBracket; }
        int     getShowNum() const      { return fShowNum; }
        int     getShowType() const     { return fShowType; }

        STupletDesc&    actualDesc()    { return fActual; }
        STupletDesc&    normalDesc()    { return fNormal; }

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

    protected:
        TTuplet(StartStop::type type) 
            : fType(type), fNumber(undefined), fBracket(YesNo::undefined),
              fShowNum(undefined), fShowType(undefined) {}
        virtual ~TTuplet() {}

    private:
        StartStop::type fType;
        int     fNumber;
        YesNo::type     fBracket;
        int     fShowNum;
        int     fShowType;

        STupletDesc fActual;
        STupletDesc fNormal;

    static bimap<string, int> fShow2String;
    static int      fShowTbl[];
    static string   fShowStrings[];
};
typedef SMARTP<TTuplet> STuplet;

class EXP TArticulationElement : public visitable, public Positionable, public Placementable, public smartable {

    public:
        enum articulation { first=1, accent=first, strong_accent, staccato, tenuto, detached_legato,
             staccatissimo, spiccato, scoop, plop, doit, falloff, breath_mark, caesura, last=caesura };

        EXP friend SMARTP<TArticulationElement> newArticulationElement(articulation type);
        virtual void accept(TScoreVisitor& visitor);

        articulation    getArtType() const          { return fArticulationType; }
        void            setArtType(articulation a);
        
    static const string xmlname (articulation d);
    static articulation xmlname (const string str);
    
    static const string* getArticulationStrings()   { return fArticulationStrings; }
        
    protected:
        TArticulationElement(articulation type) : fArticulationType(type) {}
        virtual ~TArticulationElement() {}

    private:
        articulation    fArticulationType;

    static bimap<string, articulation> fArticulation2String;
    static articulation         fArticulationTbl[];
    static string               fArticulationStrings[];
};
typedef SMARTP<TArticulationElement> SArticulationElement;

class EXP TArticulations : public TNotationElement {

      public:
        EXP friend SMARTP<TArticulations> newArticulations();
        virtual void accept(TScoreVisitor& visitor);

        long add (const SArticulationElement& art);
        vvector<SArticulationElement>& articulations()  { return fList; }

    protected:
        TArticulations() {}
        virtual ~TArticulations() {}
    private:
        vvector<SArticulationElement>   fList;
};
typedef SMARTP<TArticulations> SArticulations;

class EXP TStrongAccent : public TArticulationElement {

    public:
        enum { undefined, up=1, down, last=down };
        EXP friend SMARTP<TStrongAccent> newStrongAccent();
        virtual void accept(TScoreVisitor& visitor);

        int     getType() const     { return fType; }
        void    setType(int type);
        
    static const string xmltype (int d);
    static int          xmltype (const string str);

    protected:
        TStrongAccent() : TArticulationElement(strong_accent), fType(undefined) {}
        virtual ~TStrongAccent() {}
    private:
        int     fType;

    static bimap<string, int> fType2String;
    static int      fTypeTbl[];
    static string   fTypeStrings[];
};
typedef SMARTP<TStrongAccent> SStrongAccent;

} // namespace MusicXML


#endif

---