Route.h

gehe zur Dokumentation dieser Datei

// -*- C++ -*-

#ifndef MUTABOR_ROUTE_H
#define MUTABOR_ROUTE_H

#include "Defs.h"

#ifdef WX
#include "wx/config.h"
#endif

#include "treestorage.h"
// Route ------------------------------------------------------------


enum BoxType
{
        NewBox = -3,
        NoBox,
        GmnBox,
        Box0
};

enum RouteType
{
        RTall, RTelse, RTchannel, RTstaff
};

extern const mutString RTName[];

class OutDevice;
class InDevice;

class Route
{
        // private members: access only via access functions for debugging purposes
        /*
        void * userdata;
        Route *Next;
        OutDevice *Out;
         */
        WATCHEDPTR(void,routing,Route) userdata;
        WATCHEDPTR(Route,routing,Route) Next;
        WATCHEDPTR(OutDevice,routing,Route) Out;
        WATCHEDPTR(InDevice,routing,Route) In;
        WATCHEDPTR(Route,routing,Route) globalNext;
        static WATCHEDPTR(Route,routing,Route) routeList;
        int Id;
        int inputid;
        int outputid;
public:
        RouteType Type;
        int IFrom, ITo;
        int Box;
        bool Active;
        int OFrom, OTo;
        bool ONoDrum;
        static int maxRouteId;



        Route(
              InDevice * in = NULL,
              OutDevice *out = NULL,
              RouteType type = RTall,
              int iFrom = -1,
              int iTo = -1,
              int box = -1,
              bool active = false,
              int oFrom = -1,
              int oTo = -1,
              bool oNoDrum = true,
              Route *next = 0):userdata(this,_T("userdata")),
        Next(this,_T("Next"),next),
        Out(this,_T("Out"),out),
        In(this,_T("In"),in),
        globalNext(this,_T("Global Next"),NULL)
        {
                Type = type;
                IFrom = iFrom;
                ITo = iTo;
                Box = box;
                Active = active;
                OFrom = oFrom;
                OTo = oTo;
                ONoDrum = oNoDrum;
                Id = NextRouteId();
                AppendToRouteList(this);
        }

        virtual ~Route()
        {
                DEBUGLOG(routing,_T("deleting chain from %p"));
                if ( Next ) delete Next;
                DEBUGLOG(routing,_T("deleting %p"));
                RemoveFromRouteList(this);
        }


        virtual void Save(tree_storage & config);


        virtual void Load(tree_storage & config);
        
        static unsigned int NextRouteId() {
                return maxRouteId++;
        }


        char Check(int i)
        {
                return (IFrom <= i && i <= ITo);
        }
        
        void setUserData (void * data) 
        { 
                userdata = data; 
        }

        void * getUserData() const 
        { 
                return userdata; 
        }

        OutDevice  * GetOutDevice() const {
                return Out;
        }

        void SetOutDevice (OutDevice * out) 
        {
                Out = out;
        }
        
        InDevice  * GetInDevice() const {
                return In;
        }
        
        void SetInDevice (InDevice * in) 
        {
                In = in;
                for (Route * route = GetNext(); route; route=route->GetNext())
                        route -> In = in;
        }
        
        void SetInputId(int Id)
        {
                inputid = Id;
        }
        
        
        bool GetActive() const 
        {
                return Active;
        }
        
        void SetActive(bool active) 
        {
                Active = active;
        }
        
        int GetBox() const
        {
                return Box;
        }
        
        void SetBox(int box)
        {
                Box = box;
        }
        
        RouteType GetType() const
        {
                return Type;
        }
        
        void SetType(RouteType type)
        {
                Type = type;
        }
        
        const mutString & GetTypeName()
        {
                return RTName[Type];
        }
        
        int GetInputFrom() const
        {
                return IFrom;
        }
        
        void SetInputFrom(int i)
        {
                IFrom = i;
        }
        
        int GetOutputFrom() const
        {
                return OFrom;
        }
        
        void SetOutputFrom(int o)
        {
                OFrom = o;
        }
        
        int GetInputTo() const
        {
                return ITo;
        }
        
        void SetInputTo(int i)
        {
                ITo = i;
        }
        
        int GetOutputTo() const
        {
                return OTo;
        }
        
        void SetOutputTo(int o)
        {
                OTo = o;
        }
        
        
        bool OutputAvoidDrumChannel() const
        {
                return ONoDrum;
        }
        void OutputAvoidDrumChannel(bool avoid) 
        {
                ONoDrum = avoid;
        }
        
        Route * GetNext() const
        {
                return Next;
        }
        void SetNext(Route * route)
        {
                Next = route;
                for (Route * r = GetNext(); r; r=r->GetNext())
                        r -> In = In;
        }
        
        int GetId() const
        {
                return Id;
        }
        
        static Route * GetRouteList() 
        {
                return routeList;
        }
        
        Route * GetGlobalNext()
        {
                return globalNext;
        }
        

        static void InitializeIds();


        static void SaveRoutes(tree_storage & config);


        static void LoadRoutes(tree_storage & config);
protected:
        static void AppendToRouteList (Route * route);
        static void RemoveFromRouteList (Route * route);
};

extern const mutString DevTypeName[];


void LoadRoutes(tree_storage & config);


void SaveRoutes(tree_storage & config);


#endif

/*
 * \}
 */