InputMidiFileDeviceShape.h

gehe zur Dokumentation dieser Datei

// -*- C++ -*-

#ifndef INPUTMIDIFILEDEVICESHAPE_H
#define INPUTMIDIFILEDEVICESHAPE_H

//#include <map>

//#include "wx/defs.h"
//#include "wx/icon.h"
//#include "wx/stattext.h"

#include "InputDeviceShape.h"
//#include "Device.h"

class MidiFileInputFilterPanel : public MidiFileInputFilterPanelBase {
public:
        MidiFileInputFilterPanel(wxWindow * parent):MidiFileInputFilterPanelBase(parent) {}
        void SetFromChannel(int current, int min, int max) {
                from_channel->SetRange(min,max);
                from_channel->SetValue(current);
        }
        int GetFromChannel() const { return from_channel->GetValue(); }
        
        void SetToChannel(int current, int min, int max) {
                to_channel->SetRange(min,max);
                to_channel->SetValue(current);
        }
        int GetToChannel() const { return to_channel->GetValue(); }
        
        void SetFromTrack(int current, int min, int max) {
                from_track->SetRange(min,max);
                from_track->SetValue(current);
        }
        int GetFromTrack() const 
        {
                return from_track->GetValue();
        }
        
        void SetToTrack(int current, int min, int max) {
                to_track->SetRange(min,max);
                to_track->SetValue(current);
        }
        int GetToTrack() const
        {
                return to_track->GetValue();
        }
        
        void SetRouteType(RouteType routetype) {
                wxPanel * panel;
                switch (routetype) {
                        case RTall: panel = all_panel; break;
                        case RTchannel: panel = channel_panel; break;
                        case RTstaff: panel = track_panel; break;
                        case RTelse: panel = else_panel; break;
                        default:
                                std::cerr << "MidiFileInputFilterPanel::SetRouteType: invaid route type " 
                                << routetype << std::endl;
                                abort();
                }
                for (size_t i = 0 ; i < type->GetPageCount(); i++) {
                        if (type -> GetPage(i) != panel) continue;
                        type->SetSelection(i);
                }
        }
        
        
        RouteType GetRouteType() const {
                wxWindow * window = type->GetCurrentPage();
                if (window == all_panel)
                        return RTall;
                else if (window == channel_panel)
                        return RTchannel;
                else if (window == track_panel)
                        return RTstaff;
                else if (window == else_panel)
                        return RTelse;
                else {
                        UNREACHABLEC;
                        return RTall;
                }
        }       
};


class MutInputMidiFileDeviceShape:public MutInputDeviceShape
{
public:
        MutInputMidiFileDeviceShape():MutInputDeviceShape() {}
        MutInputMidiFileDeviceShape (wxWindow * parent,
                                     wxWindowID id, 
                                     InDevice * d):
                MutInputDeviceShape() {
                Create (parent,id,d);
        }
        bool Create (wxWindow * parent, wxWindowID id, InDevice * d)
                {
                        DEBUGLOG (other,_T (""));
                        bool ret = MutInputDeviceShape::Create(parent,id,d);
                        DEBUGLOG (other,_T (""));
                        return ret;
                }

        virtual MutIcon & GetMutIcon () 
                {
                        DEBUGLOG (other, _T(""));
                        return MidiFileBitmap;
                }

        void SetLabel(const wxString & st ) {
                fileName = st;
                fileName.Normalize();
                MutInputDeviceShape::SetLabel (fileName.GetFullName());
        }

        virtual wxPanel * GetInputFilterPanel(wxWindow * parent, Route * route) const;
        virtual void ReadInputFilterPanel(wxWindow * panel, Route * route);


protected: 
        virtual void InitializeDialog(InputDevDlg * in) const;
        virtual bool readDialog (InputDevDlg * in);
        virtual bool CanHandleType (DevType  type) { return type == DTMidiFile; }

        wxFileName fileName;

private:
        DECLARE_DYNAMIC_CLASS(MutInputMidiFileDeviceShape);

};
#endif                          /* InputMidiFileDeviceShape_H */
/*
 * \}
 */