OutputMidiDeviceShape.cpp

gehe zur Dokumentation dieser Datei

// -*-C++ -*-
#include "OutputMidiDeviceShape.h"
#include "DevMidi.h"
#include <limits>

class MidiOutputFilterPanel : public MidiOutputFilterPanelBase {
public:
        MidiOutputFilterPanel(wxWindow * parent):MidiOutputFilterPanelBase(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 SetAvoidDrumChannel(bool avoid) {
                avoid_drum_channel->SetValue(avoid);
        }
        bool GetAvoidDrumChannel() const
        {
                return avoid_drum_channel->GetValue();
        }
};


void MutOutputMidiDeviceShape::InitializeDialog(OutputDevDlg * out) const
{
        DEBUGLOG (other, _T("Type: %d"),DTMidiPort);
        wxASSERT(device);
        wxASSERT(device->GetType() == DTMidiPort);
        wxASSERT(out);
        OutMidiPort * dev = dynamic_cast<OutMidiPort *> (device);
        wxASSERT (dev);
        out -> SetType(DTMidiPort);
        out -> SetMidiDevice(dev->GetDevId());
        out -> SetMidiBendingRange (dev-> GetBendingRange());
}

bool MutOutputMidiDeviceShape::readDialog (OutputDevDlg * out)
{
        wxASSERT(device);
        wxASSERT(device->GetType() == DTMidiPort);
        wxASSERT(out);
        wxASSERT (out -> GetType() == DTMidiPort);
        OutMidiPort * dev = dynamic_cast<OutMidiPort *> (device);
        if (!dev) return false;
        wxASSERT (dev);
        DEBUGLOG(routing,_T("New midi device: %d"),out -> GetMidiDevice());
        dev->SetDevId (out -> GetMidiDevice());
        dev->SetBendingRange (out->GetMidiBendingRange());
        SetLabel (dev->GetName());
        return true;
}

wxPanel * MutOutputMidiDeviceShape::GetOutputFilterPanel(wxWindow * parent, 
                                                       Route * route) const
{
        const int maxint = std::numeric_limits<int>().max();
        MidiOutputFilterPanel * panel = new MidiOutputFilterPanel(parent);
        if (!panel) return NULL;
        OutMidiPort * dev = dynamic_cast<OutMidiPort *> (device);
        const int maxchannel = dev?dev->GetMaxChannel():maxint;
        const int minchannel = dev?dev->GetMinChannel():0;
        if (!route) {
                panel->SetFromChannel(minchannel, minchannel, maxchannel);
                panel->SetToChannel(maxchannel, minchannel, maxchannel);
                panel->SetAvoidDrumChannel(true);
                return panel;
        }
        panel->SetFromChannel(route->OFrom, minchannel, maxchannel);
        panel->SetToChannel(route->OTo, minchannel, maxchannel);
        panel->SetAvoidDrumChannel(route->ONoDrum);
        return panel;
}

void MutOutputMidiDeviceShape::ReadOutputFilterPanel(wxWindow * panel, Route * route)
{
        wxASSERT(route);
        MidiOutputFilterPanel * pan = dynamic_cast<MidiOutputFilterPanel *> (panel);
        if (!pan) {
                UNREACHABLEC;
                return;
        }
        
        route->SetOutputFrom(pan->GetFromChannel());
        route->SetOutputTo(pan->GetToChannel());
        route->OutputAvoidDrumChannel(pan->GetAvoidDrumChannel());
}


IMPLEMENT_DYNAMIC_CLASS(MutOutputMidiDeviceShape, MutOutputDeviceShape)

/*
 * \}
 */