BoxDlg.h

gehe zur Dokumentation dieser Datei

// ---------------------------------------------------------------------------
// headers
// ---------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx/wx.h".
#include "Defs.h"
#include <wx/wxprec.h>

#ifdef __BORLANDC__
#pragma hdrstop
#endif




#ifndef _BOXDLG_H_
#define _BOXDLG_H_

typedef NoBoxSettingsBase NoBoxSettings;
typedef GuidoFileBoxSettingsBase GuidoFileBoxSettings;

class MutaborBoxSettings: public MutaborBoxSettingsBase {
public:
        MutaborBoxSettings(wxWindow * parent):MutaborBoxSettingsBase(parent) {}
        virtual ~MutaborBoxSettings() {}
        void SetBoxNumber(int nr);
        int GetBoxNumber() const 
        { 
                wxASSERT(boxNumber);
                if (!boxNumber) return -99;
                return boxNumber -> GetValue(); 
        }
};

class InputFilterPanel : public InputFilterPanelBase {
        class InputShapeData: public wxClientData {
                MutInputDeviceShape * device;
        public:
                InputShapeData(MutInputDeviceShape * b):wxClientData() { device = b; }
                MutInputDeviceShape * GetDevice() { return device; }
        };
        
public:
        InputFilterPanel(wxWindow * parent):InputFilterPanelBase(parent) {}
        wxChoicebook * GetInputDeviceBook() { return inputDevice; }
        void AddPage(wxPanel * panel, const wxString &label, bool selected, MutInputDeviceShape * shape);
        wxWindow * GetCurrentDevicePage() ;
        MutInputDeviceShape * GetCurrentSelection();
};

class OutputFilterPanel : public OutputFilterPanelBase {
        class OutputShapeData: public wxClientData {
                MutOutputDeviceShape * device;
        public:
                OutputShapeData(MutOutputDeviceShape * b):wxClientData() { device = b; }
                MutOutputDeviceShape * GetDevice() { return device; }
        };
public:
        OutputFilterPanel(wxWindow * parent):OutputFilterPanelBase(parent) {}
        wxChoicebook * GetOutputDeviceBook() { return outputDevice; }
        void AddPage(wxPanel * panel, const wxString &label, bool selected, MutOutputDeviceShape * shape);
        wxWindow * GetCurrentDevicePage() ;
        MutOutputDeviceShape * GetCurrentSelection();
};

class MutBoxShape;
class MutBoxChannelShape;

class RoutePanel:public RoutePanelBase {
        DECLARE_DYNAMIC_CLASS( RoutePanel )
                
protected:
        class BoxShapeData: public wxClientData {
                MutBoxShape * box;
        public:
                BoxShapeData(MutBoxShape * b):wxClientData() { box = b; }
                MutBoxShape * GetBox() { return box; }
        };
        InputFilterPanel * inPanel;
        OutputFilterPanel * outPanel;
        MutBoxChannelShape * channel;
public:
        RoutePanel():RoutePanelBase()
        {
                inPanel = NULL;
                outPanel = NULL;
                channel = NULL;
        }
        
        RoutePanel(wxWindow * parent):RoutePanelBase(parent) 
        {
                inPanel = NULL;
                outPanel = NULL;
                channel = NULL;
        }
        
        bool GetActive() {
                return active->GetValue();
        }
        void SetActive(bool val) {
                active->SetValue(val);
                passive->SetValue(!val);
        }
        bool GetPassive() {
                return passive->GetValue();
        }
        void SetPassive(bool val) {
                passive->SetValue(val);
                active->SetValue(!val);
        }
        
        void SetBox(MutBoxShape * box) { STUBC; }
        MutBoxShape * GetBox();
        void SetInput(InputFilterPanel * in) { inPanel = in; }
        InputFilterPanel * GetInput() const { return inPanel; }
        void SetOutput(OutputFilterPanel * out) { outPanel = out; }
        OutputFilterPanel * GetOutput() const { return outPanel; }
        void SetChannel(MutBoxChannelShape * ch) { channel = ch; }
        MutBoxChannelShape * GetChannel() const { return channel; }
        wxChoice * GetBoxChoice() { return box; }
        int AddBox(MutBoxShape * boxShape, bool selected = false);
        
        void EnableRoute(bool enable = true);
        
};

class RouteRemoveButton: public wxButton {
public:
        RouteRemoveButton():wxButton() { panel = NULL; }
        RouteRemoveButton(RoutePanel * route, wxWindow* parent, wxWindowID id = wxID_REMOVE, const wxString&  label = wxEmptyString, 
                 const wxPoint&  pos = wxDefaultPosition, const wxSize&  size = wxDefaultSize, 
                          long style = 0, const wxValidator&  validator = wxDefaultValidator, const wxString&  name = wxButtonNameStr):wxButton() {
                Create(route, parent, id, label, pos, size, style, validator, name);
        }

        bool Create(RoutePanel * route, wxWindow* parent, wxWindowID id = wxID_REMOVE, const wxString&  label = wxEmptyString, 
                          const wxPoint&  pos = wxDefaultPosition, const wxSize&  size = wxDefaultSize, 
                    long style = 0, const wxValidator&  validator = wxDefaultValidator, const wxString&  name = wxButtonNameStr);
        
        void EnableRoute(bool enable = true);
                
protected:
        RoutePanel * panel;
        void RemoveButtonPressed( wxCommandEvent& event );
        DECLARE_DYNAMIC_CLASS( RouteRemoveButton )
        DECLARE_EVENT_TABLE()
};

class BoxDlg:public BoxDlgBase {
        wxChoice * boxTypeChoice;
public:
        BoxDlg():BoxDlgBase(),noBoxPanel(NULL),mutaborBoxPanel(NULL),guidoFileBoxPanel(NULL) { }
        BoxDlg(wxWindow * parent);

        void InitializeBoxTypes();
        
        wxWindow * GetRouteWindow() 
        {
                return routeWindow;
        }

        virtual wxSize DoGetBestSize() const;
        
        int GetBoxType() const;
        bool SetBoxType(int type);
        
        void SetBoxNumber(int nr) 
        { 
                wxASSERT(mutaborBoxPanel);
                if (!mutaborBoxPanel) return;
                mutaborBoxPanel->SetBoxNumber(nr); 
        }

        int GetBoxNumber() const 
        { 
                wxASSERT(mutaborBoxPanel);
                if (!mutaborBoxPanel) return -99;
                return mutaborBoxPanel->GetBoxNumber(); 
        }
        
        void DisableRemove (bool disable=true) 
        {
                if (!wxID_REMOVE) UNREACHABLEC;
                wxID_REMOVE->Show(!disable);
                wxID_REMOVE->Enable(!disable);
        }
        
        
protected:
        void OnRemoveClick( wxCommandEvent& event );    
        void AddButtonPressed(wxCommandEvent &event);
        
        NoBoxSettings * noBoxPanel;
        MutaborBoxSettings * mutaborBoxPanel;
        GuidoFileBoxSettings * guidoFileBoxPanel;
        DECLARE_DYNAMIC_CLASS( BoxDlg )
        DECLARE_EVENT_TABLE()
};



#endif
// _BOXDLG_H_