common.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 __common__
#define __common__

#include "exports.h"
#include "TScoreVisitor.h"
#include "bimap.h"
#include "conversions.h"
#include "smartpointer.h"
#include <string>

using namespace std;

namespace MusicXML 
{

class TPartListElement : public virtual visitable, public virtual smartable {
     protected:
        TPartListElement () {}
        virtual ~TPartListElement() {}
};
typedef SMARTP<TPartListElement>    SPartListElement;

class TNotationElement : public virtual visitable, public virtual smartable {
     protected:
        TNotationElement () {}
        virtual ~TNotationElement() {}
};
typedef SMARTP<TNotationElement>    SNotationElement;

class TDirectionTypeElement : public virtual visitable, public virtual smartable {
     protected:
        TDirectionTypeElement () {}
        virtual ~TDirectionTypeElement() {}
};
typedef SMARTP<TDirectionTypeElement>   SDirectionTypeElement;

class TMusicData : public virtual visitable, public virtual smartable {
     protected:
        TMusicData () {}
        virtual ~TMusicData() {}
};
typedef SMARTP<TMusicData>  SMusicData;

typedef long    position[4];

class EXP TPosition {
    public:
        enum { undefined=0, defaultx=1, defaulty, relativex, relativey, last=relativey };
        
        TPosition() { fPosition[0]=fPosition[1]=fPosition[2]=fPosition[3]= undefined; }
        virtual ~TPosition() {}
                
        virtual void accept(TScoreVisitor& visitor);
        void set (int pos, long val)    { if ((pos>0) && (pos<=last)) fPosition[pos-1] = val; }
        long get (int pos) const    { return ((pos>0) && (pos<=last)) ? fPosition[pos-1] : undefined; }

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

    private:
        position fPosition;

    static bimap<string, int> fPos2String;
    static int      fPosTbl[];
    static string   fPosStrings[];
};

class EXP Positionable {
    public:
        Positionable() {}
        virtual ~Positionable() {}

        TPosition& position()                   { return fPosition; }
    
    private:
        TPosition fPosition;
};

class EXP TPlacement {
    public:
        enum type { undefined, above, below, last=below };

        TPlacement(int place=undefined) : fPlacement(place) {}
        virtual ~TPlacement() {}

        void accept(TScoreVisitor& visitor);
        void set (int place)        { fPlacement = place; }
        int  get () const           { return fPlacement; }

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

    private:
        int fPlacement;

    static bimap<string, int> fPlace2String;
    static int      fPlaceTbl[];
    static string   fPlaceStrings[];
};

class EXP Placementable {
    public:
        Placementable() {}
        virtual ~Placementable() {}
        TPlacement& placement()                 { return fPlacement; }
    
    private:
        TPlacement fPlacement;
};

class EXP TOrientation {
    public:
        enum type { undefined, over, under, last = under };

        TOrientation(int orient=undefined) : fOrientation(orient) {}
        virtual ~TOrientation() {}

        virtual void accept(TScoreVisitor& visitor);
        void set (int orient)   { fOrientation = orient; }
        int  get () const       { return fOrientation; }

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

    private:
        int fOrientation;

    static bimap<string, int> fOr2String;
    static int      fOrTbl[];
    static string   fOrStrings[];        
};

class EXP Orientable {
    public:
        Orientable() {}
        virtual ~Orientable() {}
        TOrientation& orientation()  { return fOrientation; }
    private:
        TOrientation fOrientation;
};


class EXP TFermata : public TNotationElement, public Positionable {

    public:
        enum { undefined, upright, inverted, last=inverted };

        EXP friend SMARTP<TFermata> newFermata();

        virtual void accept(TScoreVisitor& visitor);
        void setType (int type)     { fType = type; }
        int getType () const        { return fType; }

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

    protected:
        TFermata() : fType(undefined) {}
        virtual ~TFermata() {}

    private:
        int         fType;

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

class EXP TWavyLine : public visitable, public Positionable, public Placementable, public smartable {
    public:
        enum { undefined = -1 };
        EXP friend SMARTP<TWavyLine> newWavyLine(StartStop::type t);
        
        virtual void accept(TScoreVisitor& visitor);
        void setType (StartStop::type t)        { fType = t; }
        StartStop::type getType () const        { return fType; }
        void setNumber (int num)    { fNumber = num; }
        int getNumber () const      { return fNumber; }

    protected:
        TWavyLine(StartStop::type type) : fType(type), fNumber(undefined) {}
        virtual ~TWavyLine() {}
        
    private:
        StartStop::type fType;
        int         fNumber;
//      TTrill      fTrill;
};
typedef SMARTP<TWavyLine> SWavyLine;

class EXP TSegno : public TDirectionTypeElement, public Positionable {
    public:        
        EXP friend SMARTP<TSegno> newSegno();
        virtual void accept(TScoreVisitor& visitor);

    protected:
        TSegno() {}
        virtual ~TSegno() {}
};
typedef SMARTP<TSegno> SSegno;

class EXP TCoda : public TDirectionTypeElement, public Positionable {
    public:
        EXP friend SMARTP<TCoda> newCoda();
        virtual void accept(TScoreVisitor& visitor);

    protected:
        TCoda() {}
        virtual ~TCoda() {}
};
typedef SMARTP<TCoda> SCoda;

class EXP TDynamic : public TDirectionTypeElement, public TNotationElement, 
                 public Positionable, public Placementable { 
    public:
        enum dynamic {  pppppp=1, ppppp, pppp, ppp, pp, p,
                mp, mf,
                f, ff, fff, ffff, fffff, ffffff, 
                sf, sfp, sfpp, fp, rf, rfz, sfz, sffz, fz, 
                last=fz };

        EXP friend SMARTP<TDynamic> newDynamic();

        virtual void accept(TScoreVisitor& visitor);
        vector<dynamic>& dynamics() { return fDynamic; }
        long    add (dynamic d);

    static const string xmldynamic (dynamic d);
    static dynamic      xmldynamic (const string str);
    
    static const string* getDynamicStrings()   { return fDynamicStrings; }
        
    protected:
        TDynamic() {}
        virtual ~TDynamic() {}
        
    private:
        vector<dynamic> fDynamic;

    static bimap<string, dynamic> fDynamic2String;
    static dynamic      fDynamicTbl[];
    static string   fDynamicStrings[];
};
typedef SMARTP<TDynamic> SDynamic;

} // namespace MusicXML

#endif

---