--- linuxsampler/trunk/src/drivers/midi/MidiInputDevice.cpp	2004/08/18 12:11:26	220
+++ linuxsampler/trunk/src/drivers/midi/MidiInputDevice.cpp	2004/08/20 17:25:19	221
@@ -24,84 +24,122 @@
 
 namespace LinuxSampler {
 
-    MidiInputDevice::MidiInputDevice(std::map<String,DeviceCreationParameter*> DriverParameters) {
-	    this->Parameters = DriverParameters;
+// *************** ParameterActive ***************
+// *
+
+    MidiInputDevice::ParameterActive::ParameterActive() : DeviceCreationParameterBool() {
+        InitWithDefault();
     }
 
-    MidiInputDevice::~MidiInputDevice() {
-	    std::map<String,DeviceCreationParameter*>::iterator iter = Parameters.begin();
-	    while (iter != Parameters.end()) {
-		    Parameters.erase(iter);
-		    delete iter->second;
-		    iter++;
-	    }
+    MidiInputDevice::ParameterActive::ParameterActive(String active) : DeviceCreationParameterBool(active) {
     }
 
-    MidiInputDevice::MidiInputPort::~MidiInputPort() {
-	    std::map<String,DeviceCreationParameter*>::iterator iter = Parameters.begin();
-	    while (iter != Parameters.end()) {
-		    Parameters.erase(iter);
-		    delete iter->second;
-		    iter++;
-	    }
+    String MidiInputDevice::ParameterActive::Description() {
+        return "Enable / disable device";
     }
 
-    MidiInputDevice::MidiInputPort::MidiInputPort(MidiInputDevice* pDevice, int portNumber) {
-	    this->pDevice = pDevice;
-	    this->portNumber = portNumber;
-	    Parameters["name"] = new ParameterName(this);
+    bool MidiInputDevice::ParameterActive::Fix() {
+        return false;
     }
 
-    MidiInputDevice* MidiInputDevice::MidiInputPort::GetDevice() {
-	    return pDevice;
+    bool MidiInputDevice::ParameterActive::Mandatory() {
+        return false;
     }
 
-    uint MidiInputDevice::MidiInputPort::GetPortNumber() {
-	    return portNumber;
+    std::map<String,DeviceCreationParameter*> MidiInputDevice::ParameterActive::DependsAsParameters() {
+        return std::map<String,DeviceCreationParameter*>();
     }
 
-    std::map<String,DeviceCreationParameter*> MidiInputDevice::DeviceParameters() {
-	    return Parameters;
+    optional<bool> MidiInputDevice::ParameterActive::DefaultAsBool(std::map<String,String> Parameters) {
+        return true;
     }
 
-    std::map<String,DeviceCreationParameter*> MidiInputDevice::MidiInputPort::DeviceParameters() {
-	    return Parameters;
+    void MidiInputDevice::ParameterActive::OnSetValue(bool b) throw (LinuxSamplerException) {
+        if (b) ((MidiInputDevice*)pDevice)->Listen();
+        else ((MidiInputDevice*)pDevice)->StopListen();
+    }
+
+    String MidiInputDevice::ParameterActive::Name() {
+        return "ACTIVE";
+    }
+
+
+
+// *************** ParameterPorts ***************
+// *
+
+    MidiInputDevice::ParameterPorts::ParameterPorts() : DeviceCreationParameterInt() {
+        InitWithDefault();
+    }
+
+    MidiInputDevice::ParameterPorts::ParameterPorts(String val) : DeviceCreationParameterInt(val) {
+    }
+
+    String MidiInputDevice::ParameterPorts::Description() {
+        return "Number of ports";
+    }
+
+    bool MidiInputDevice::ParameterPorts::Fix() {
+        return false;
+    }
+
+    bool MidiInputDevice::ParameterPorts::Mandatory() {
+        return false;
+    }
+
+    std::map<String,DeviceCreationParameter*> MidiInputDevice::ParameterPorts::DependsAsParameters() {
+        return std::map<String,DeviceCreationParameter*>();
     }
 
-    void MidiInputDevice::MidiInputPort::DispatchNoteOn(uint8_t Key, uint8_t Velocity, uint MidiChannel) {
-        std::set<Engine*>::iterator engineiter = MidiChannelMap[MidiChannel].begin();
-        std::set<Engine*>::iterator end        = MidiChannelMap[MidiChannel].end();
-        for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOn(Key, Velocity);
+    optional<int> MidiInputDevice::ParameterPorts::DefaultAsInt(std::map<String,String> Parameters) {
+        return 0;
     }
 
-    void MidiInputDevice::MidiInputPort::DispatchNoteOff(uint8_t Key, uint8_t Velocity, uint MidiChannel) {
-        std::set<Engine*>::iterator engineiter = MidiChannelMap[MidiChannel].begin();
-        std::set<Engine*>::iterator end        = MidiChannelMap[MidiChannel].end();
-        for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOff(Key, Velocity);
+    optional<int> MidiInputDevice::ParameterPorts::RangeMinAsInt(std::map<String,String> Parameters) {
+        return optional<int>::nothing;
     }
 
-    void MidiInputDevice::MidiInputPort::DispatchPitchbend(int Pitch, uint MidiChannel) {
-        std::set<Engine*>::iterator engineiter = MidiChannelMap[MidiChannel].begin();
-        std::set<Engine*>::iterator end        = MidiChannelMap[MidiChannel].end();
-        for (; engineiter != end; engineiter++) (*engineiter)->SendPitchbend(Pitch);
+    optional<int> MidiInputDevice::ParameterPorts::RangeMaxAsInt(std::map<String,String> Parameters) {
+        return optional<int>::nothing;
     }
 
-    void MidiInputDevice::MidiInputPort::DispatchControlChange(uint8_t Controller, uint8_t Value, uint MidiChannel) {
-        std::set<Engine*>::iterator engineiter = MidiChannelMap[MidiChannel].begin();
-        std::set<Engine*>::iterator end        = MidiChannelMap[MidiChannel].end();
-        for (; engineiter != end; engineiter++) (*engineiter)->SendControlChange(Controller, Value);
+    std::vector<int> MidiInputDevice::ParameterPorts::PossibilitiesAsInt(std::map<String,String> Parameters) {
+        return std::vector<int>();
     }
 
-    void MidiInputDevice::MidiInputPort::Connect(Engine* pEngine, midi_chan_t MidiChannel) {
-        if (MidiChannel < 0 || MidiChannel > 16)
-            throw MidiInputException("MIDI channel index out of bounds");
-        Disconnect(pEngine);
-        MidiChannelMap[MidiChannel].insert(pEngine);
+    void MidiInputDevice::ParameterPorts::OnSetValue(int i) throw (LinuxSamplerException) {
+        ((MidiInputDevice*)pDevice)->AcquirePorts(i);
     }
 
-    void MidiInputDevice::MidiInputPort::Disconnect(Engine* pEngine) {
-        try { for (int i = 0; i <= 16; i++) MidiChannelMap[i].erase(pEngine); }
-        catch(...) { /* NOOP */ }
+    String MidiInputDevice::ParameterPorts::Name() {
+        return "PORTS";
+    }
+
+
+
+// *************** MidiInputDevice ***************
+// *
+
+    MidiInputDevice::MidiInputDevice(std::map<String,DeviceCreationParameter*> DriverParameters) {
+	    this->Parameters = DriverParameters;
+    }
+
+    MidiInputDevice::~MidiInputDevice() {
+	    std::map<String,DeviceCreationParameter*>::iterator iter = Parameters.begin();
+	    while (iter != Parameters.end()) {
+		    Parameters.erase(iter);
+		    delete iter->second;
+		    iter++;
+	    }
+    }
+
+    MidiInputPort* MidiInputDevice::GetPort(uint iPort) throw (MidiInputException) {
+        if (iPort >= Ports.size()) throw MidiInputException("There is no port " + ToString(iPort));
+        return Ports[iPort];
+    }
+
+    std::map<String,DeviceCreationParameter*> MidiInputDevice::DeviceParameters() {
+	    return Parameters;
     }
 
     void MidiInputDevice::AcquirePorts(uint newPorts) {