def midi_info():
    """
    midi is an instance of pygame.midi

    Returns a dictionary containing info
        about the systems MIDI devices.
    The dictionary contains:
        'count' - number of devices.
        'def_in' - default input.
        'def_out' - default output.
        'devices' - a list of device info.
    """

    info = {}
    #Store info.
    info.keys().append('count')
    info['count'] = midi.get_count()

    info.keys().append('def_in')
    info['def_in'] = midi.get_default_input_id()

    info.keys().append('def_out')
    info['def_out'] = midi.get_default_output_id()

    devices = []
    for i in range(0, midi.get_count()):
        devices.append(midi.get_device_info(i))

    info.keys().append('devices')
    info['devices'] = devices

    return info

def main():
    """Initiates program and loop."""
    pygame.init()
    midi.init()

    print "Number of MIDI devices:", midi.get_count()
    if midi.get_count() == 0:
        print "No MIDI devices detected :P"
        return
    
    out_device = midi.get_default_output_id()
    if out_device == -1:
        print "No MIDI output device detected :P"
        return
    
    print "Uses device no:", out_device
    try:
        output = midi.Output( out_device )
        output.set_instrument( instrument )
        keyboard = init_keyboard(53)
        
        screen = pygame.display.set_mode([250,80])
        screen.fill((0,0,0))
        pygame.display.set_caption("MIDI Keyboard")
        pygame.display.flip()
        
        io_loop(keyboard, output, instrument)
        
    finally:
        del output
        midi.quit()

    def __init__(self):

        self.devIn = None
        self.devOut = None

        midi.init()

        # TODO: this sucks...
        try:
            midi.get_count()
        except:
            print("ERROR: MIDI not available...")

	def get_device(self, dev_name):
		for i in xrange(0, midi.get_count()):
			name = midi.get_device_info(i)[1]
			print midi.get_device_info(i)
			if name == dev_name:
				if midi.get_device_info(i)[3]: #Checking if output device
					return midi.Output(i)

def getInputDevices():
    for i in xrange(midi.get_count()):
        info = midi.get_device_info(i)
        (unusedInterface, name, isInput,
         unusedIsOutput, unusedOpened) = info
        if isInput:
            yield i, name

    def getMIDIDevices(self):
        midiOutputDevices = []
        midiInputDevices = []
        for index in xrange(0, midi.get_count()):
            device = midi.get_device_info(index)
            deviceName = device[1]
            if device[3] == 1 and device[4] == 0: #if the device is an output and not opened
                setattr(self, deviceName, QtGui.QAction(QtGui.QIcon(''), deviceName, self))
                deviceWidget = getattr(self, deviceName)
                deviceWidget.setCheckable(True)
                midiOutputDevices.append(deviceWidget)
                self.midiOutputDevicesDict[deviceWidget] = index
            elif device[2] == 1 and device[4] == 0: #if devices is an input and not opened
                deviceName = device[1]
                setattr(self, deviceName, QtGui.QAction(QtGui.QIcon(''), deviceName, self))
                deviceWidget = getattr(self, deviceName)
                deviceWidget.setCheckable(True)
                midiInputDevices.append(deviceWidget)
                self.midiInputDevicesDict[deviceWidget] = index
                
        if midiOutputDevices:
            self.ui.midiOutputDevicesMenu = self.ui.menubar.addMenu("&Midi Output Device")
            self.ui.midiOutputDevicesMenu.addActions(midiOutputDevices)
        if midiInputDevices:
            self.ui.midiInputDevicesMenu = self.ui.menubar.addMenu("&Midi Input Devices")
            self.ui.midiInputDevicesMenu.addActions(midiInputDevices)
        
        for device in midiOutputDevices:
            outputFunction = partial(self.windowHandler.midiOutputSelect, mainWindowInstance=self, device=device)
            device.triggered.connect(outputFunction)

        for device in midiInputDevices:
            inputFunction = partial(self.windowHandler.midiInputSelect, mainWindowInstance=self, device=device)
            device.triggered.connect(inputFunction)

 def __getDeviceId(self, midiport):
     n_device = pm.get_count()
     foundId = -1
     for id in range(n_device):
         if int(pm.get_device_info(id)[1] == midiport) & \
                 int(pm.get_device_info(id)[3] == 1):
             foundId = id
     return foundId

 def get_info(self):
     l = []
     for x in range(pm.get_count()):
         l.append(pm.get_device_info(x))
         #dev = DeviceInfo(Index=x, info=pm.get_device_info(x))
         #self.dev_info[dev.type].add_child(existing_object=dev)
         #dev.bind(active=self.on_dev_info_active_set)
     return l

	def createInterfaces(self):
		"""
		creates all midi interfaces available as devices
		@todo: sort in- and output of one hardware
		"""
		n = midi.get_count()
		for i in xrange(n/2):
			info = midi.get_device_info(i*2)
			newIf = Interface(info[1], i*2-1, i*2)

 def get_midi_output_id():
     for id in range(midi.get_count()):
         interface, name, input, output, open = midi.get_device_info(id)
         if not output:
             continue
         name = name.decode('utf-8').lower()
         if name.find('synth') != -1:
             return id
     return midi.get_default_output_id()

 def GetPorts(self):
     i = {}
     o = {}
     for j in range(pm.get_count()):
         s,name,ins,outs,throughs = pm.get_device_info(j)
         if ins > 0:
             i[name] = j
         if outs > 0:
             o[name] = j
     return (i,o)

 def list_devices(self):
     for i in range(pm.get_count()):
         r = pm.get_device_info(i)
         (interf, name, input, output, opened) = r
         in_out = ""
         if input:
             in_out = "(input)"
         if output:
             in_out = "(output)"
         print ("%2i: interface :%s:, name :%s:, opened :%s: %s" % (i, interf, name, opened, in_out))

def get_devices(name):
    id_in, id_out = None, None
    for i in range(midi.get_count()):
        info = midi.get_device_info(i)
        if info[1] == name:
            if info[2]:
                id_in = i
            elif info[3]:
                id_out = i
    return id_in, id_out

def create_initial_data(mox):
    pin = {}
    pout = {}
    for i in xrange(pym.get_count()):
        info = pym.get_device_info(i)
        name = info[1]
        if info[2]:
            pin[name] = i
        if info[3]:
            pout[name] = i
    
    return {"ports_in": pin, "ports_out": pout}

    def get_devices():
        """Get a list of all MIDI output devices connected to the system."""

        if _midi is None:
            return
        outdevices = []
        all_ids = _midi.get_count()
        for device_id in all_ids:
            info = _midi.get_device_info(device_id)
            if info[3] == 1:
                outdevices.add([device_id, info[1]])
        return outdevices

    def devices(self):

        devices = []

        for i in range(midi.get_count()):

            driver, name, inp, outp, opened = midi.get_device_info(i)

            if outp:
                devices.append((i, driver, name, inp, outp))

        return devices

def _open_device(name='SSCOM MIDI 1', device_index=1):
    '''Opens midi device with given name and port number'''
    # This code stinks. Is there any better way to find the device?
    
    for dn in range(midi.get_count()):
        md = midi.get_device_info(dn)
        if (md[1] == name) and (md[3] == 1): # md[3] == 1 <=> output device
            device_index -= 1
            if device_index == 0:
                return midi.Output(dn)
        
    raise RuntimeError("Could not find a SoftStep Controller")

 def __init__(self):
     self.pin = {}
     self.pout = {}
     for i in xrange(pym.get_count()):
         info = pym.get_device_info(i)
         if info[2]:
             self.pin[i] = pym.Input(i)
         if info[3]:
             self.pout[i] = pym.Output(i)
             
     self.thread = threading.Thread(target=self._run)
     self.thread.daemon = True
     self.thread.start()

def construct_input(type='MK-449C USB MIDI Keyboard'):
	pm.init()
	n_device = pm.get_count()
	in_id = -1
	for id in range(n_device):
		if int(pm.get_device_info(id)[1]==type) & int(pm.get_device_info(id)[2]==1):
			in_id = id
			print "input: "+type
#	if in_id == -1:
#		print "desired input: "+type+ " not available"

	eingang = pm.Input(in_id)
	return eingang

 def refresh(self):
     self.children = SafeList()
     for index in xrange(midi.get_count()):
         info = midi.get_device_info(index)
         interf, name, input, output, opened = info
         if output <= 0:
             continue
         btn = MTToggleButton(label=name, size=(200, 30))
         btn.size = btn.label_obj.content_width + 20, 30
         btn.push_handlers(on_press=curry(self.select, index))
         self.add_widget(btn)
         if self.selected == index and \
             self.selectedname == name:
             btn.state = 'down'