Merge lp:~mixxxdevelopers/mixxx/features_portmidi into lp:~mixxxdevelopers/mixxx/trunk

[Sean M. Pappalardo]

[Sean M. Pappalardo (pegasus-renegadetech)]

Mutliple MIDI device support has been working for a few weeks now with limited testing by myself and Phillip. The essential user-facing GUI changes are now complete, so this is ready to be considered for merging to trunk in time for v1.8.

[lp:~mixxxdevelopers/mixxx/features_portmidi]

2519. By Sean M. Pappalardo on 2009-11-07

Removed unneeded include

[RJ Skerry-Ryan (rryan)]

Pegasus wrote:
> Pegasus has proposed merging lp:~mixxxdevelopers/mixxx/features_portmidi into lp:mixxx with lp:mixxx/1.7 as a prerequisite.
>
> Requested reviews:
> Mixxx Development Team (mixxxdevelopers)
>
>
> Mutliple MIDI device support has been working for a few weeks now with limited testing by myself and Phillip. The essential user-facing GUI changes are now complete, so this is ready to be considered for merging to trunk in time for v1.8.
>
I think you didn't quite finish merging this or something because there
are some merge conflict markers scattered across this diff.

[Sean M. Pappalardo (pegasus-renegadetech)]

I was wondering about those. But they're not in the PM branch or 1.7. I guess they're a result of my specifying that merging the 1.7 branch to trunk is a prerequisite for merging this one?? (I guess that's not strictly true since this branch is based on 1.7 and the single merge would net both branches to trunk, effectively, no?)

[Phillip Whelan (pwhelan)]

You should probably rebase off trunk since no new features are being
merged into 1.7.

[RJ Skerry-Ryan (rryan)]

pwhelan wrote:
> You should probably rebase off trunk since no new features are being
> merged into 1.7.
>
Yea I agree -- you should rebase this branch to trunk so that the diff
we are looking at is exactly what will be added to trunk if the merge is
approved.

[lp:~mixxxdevelopers/mixxx/features_portmidi]

2520. By RJ Skerry-Ryan on 2009-11-08

Rebase merge of features_portmidi from the 1.7.x series to trunk.

2521. By Sean M. Pappalardo on 2009-11-08

Fixed a couple trunk merge issues

2522. By RJ Skerry-Ryan on 2009-11-08

Since the MidiMapping lock is now recursive, make buildDomElement() just relock it instead of asserting it is held.

2523. By Albert Santoni on 2009-11-10

* Select the autopaired output device in the MIDI bindings dialog's combobox, but grey it out.
* Removed some obsolete "correspondingOutputDevice" functions. We deprecated that in favour of the aggregating MidiDevice approach.
* Cleaned up some other obsolete stuff.

2524. By Albert Santoni on 2009-11-17

Only look for porttime header because it's symbols live inside the portmidi shared lib

2525. By Albert Santoni on 2009-11-17

Force user to apply settings before going into MIDI learn wizard.

2526. By Sean M. Pappalardo on 2009-11-25

- Removed unused PrimaryMidiDevice class variable
- White space fix

2527. By Albert Santoni on 2009-11-25

Fixed RJ's suggestions from merge review. One remaining race condition to solve...

2528. By Albert Santoni on 2009-11-25

* Add MIDI receive inhibit flag to MidiDevice. Should help us prevent a race condition...
* Removed old MIDI dialog

2529. By Albert Santoni on 2009-11-26

Fixed more deadlocks

2530. By Sean M. Pappalardo on 2009-11-30

Removed PM CPPDEFINE since its not used and messes up the SNDFILE one somehow

2531. By Sean M. Pappalardo on 2009-12-04

Merge with trunk

2532. By Sean M. Pappalardo on 2009-12-04

- Added preliminary mapping for SCS.3m (in default automatic mode...no direct feedback right now.)
- Added prelminiary single-deck mode for the SCS.3d (to avoid easy deck changes)

2533. By Sean M. Pappalardo on 2009-12-07

PortTime is needed on Windows and the Linux check works fine for me.

2534. By RJ Skerry-Ryan on 2010-01-05

Merging from trunk.

2535. By RJ Skerry-Ryan on 2010-01-05

Unhacking the SConscript

Unmerged revisions

=== added file 'mixxx-win64lib/portmidi.h'
--- mixxx-win64lib/portmidi.h	1970-01-01 00:00:00 +0000
+++ mixxx-win64lib/portmidi.h	2009-11-10 00:33:17 +0000
@@ -0,0 +1,604 @@
+#ifndef PORT_MIDI_H
+#define PORT_MIDI_H
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ * PortMidi Portable Real-Time MIDI Library
+ * PortMidi API Header File
+ * Latest version available at: http://sourceforge.net/projects/portmedia
+ *
+ * Copyright (c) 1999-2000 Ross Bencina and Phil Burk
+ * Copyright (c) 2001-2006 Roger B. Dannenberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * The text above constitutes the entire PortMidi license; however, 
+ * the PortMusic community also makes the following non-binding requests:
+ *
+ * Any person wishing to distribute modifications to the Software is
+ * requested to send the modifications to the original developer so that
+ * they can be incorporated into the canonical version. It is also
+ * requested that these non-binding requests be included along with the 
+ * license above.
+ */
+
+/* CHANGELOG FOR PORTMIDI
+ *     (see ../CHANGELOG.txt)
+ *
+ * NOTES ON HOST ERROR REPORTING: 
+ *
+ *    PortMidi errors (of type PmError) are generic, system-independent errors.
+ *    When an error does not map to one of the more specific PmErrors, the
+ *    catch-all code pmHostError is returned. This means that PortMidi has
+ *    retained a more specific system-dependent error code. The caller can
+ *    get more information by calling Pm_HasHostError() to test if there is
+ *    a pending host error, and Pm_GetHostErrorText() to get a text string
+ *    describing the error. Host errors are reported on a per-device basis 
+ *    because only after you open a device does PortMidi have a place to 
+ *    record the host error code. I.e. only 
+ *    those routines that receive a (PortMidiStream *) argument check and 
+ *    report errors. One exception to this is that Pm_OpenInput() and 
+ *    Pm_OpenOutput() can report errors even though when an error occurs,
+ *    there is no PortMidiStream* to hold the error. Fortunately, both
+ *    of these functions return any error immediately, so we do not really
+ *    need per-device error memory. Instead, any host error code is stored
+ *    in a global, pmHostError is returned, and the user can call 
+ *    Pm_GetHostErrorText() to get the error message (and the invalid stream
+ *    parameter will be ignored.) The functions 
+ *    pm_init and pm_term do not fail or raise
+ *    errors. The job of pm_init is to locate all available devices so that
+ *    the caller can get information via PmDeviceInfo(). If an error occurs,
+ *    the device is simply not listed as available.
+ *
+ *    Host errors come in two flavors:
+ *      a) host error 
+ *      b) host error during callback
+ *    These can occur w/midi input or output devices. (b) can only happen 
+ *    asynchronously (during callback routines), whereas (a) only occurs while
+ *    synchronously running PortMidi and any resulting system dependent calls.
+ *    Both (a) and (b) are reported by the next read or write call. You can
+ *    also query for asynchronous errors (b) at any time by calling
+ *    Pm_HasHostError().
+ *
+ * NOTES ON COMPILE-TIME SWITCHES
+ *
+ *    DEBUG assumes stdio and a console. Use this if you want automatic, simple
+ *        error reporting, e.g. for prototyping. If you are using MFC or some 
+ *        other graphical interface with no console, DEBUG probably should be
+ *        undefined.
+ *    PM_CHECK_ERRORS more-or-less takes over error checking for return values,
+ *        stopping your program and printing error messages when an error
+ *        occurs. This also uses stdio for console text I/O.
+ */ 
+
+#ifndef FALSE
+    #define FALSE 0
+#endif
+#ifndef TRUE
+    #define TRUE 1
+#endif
+
+/* default size of buffers for sysex transmission: */
+#define PM_DEFAULT_SYSEX_BUFFER_SIZE 1024
+
+/** List of portmidi errors.*/
+typedef enum {
+    pmNoError = 0,
+    pmNoData = 0, /**< A "no error" return that also indicates no data avail. */
+    pmGotData = 1, /**< A "no error" return that also indicates data available */
+    pmHostError = -10000,
+    pmInvalidDeviceId, /** out of range or 
+                        * output device when input is requested or 
+                        * input device when output is requested or
+                        * device is already opened 
+                        */
+    pmInsufficientMemory,
+    pmBufferTooSmall,
+    pmBufferOverflow,
+    pmBadPtr, /* PortMidiStream parameter is NULL or
+               * stream is not opened or
+               * stream is output when input is required or
+               * stream is input when output is required */
+    pmBadData, /** illegal midi data, e.g. missing EOX */
+    pmInternalError,
+    pmBufferMaxSize /** buffer is already as large as it can be */
+    /* NOTE: If you add a new error type, be sure to update Pm_GetErrorText() */
+} PmError;
+
+/**
+    Pm_Initialize() is the library initialisation function - call this before
+    using the library.
+*/
+PmError Pm_Initialize( void );
+
+/**
+    Pm_Terminate() is the library termination function - call this after
+    using the library.
+*/
+PmError Pm_Terminate( void );
+
+/**  A single PortMidiStream is a descriptor for an open MIDI device.
+*/
+typedef void PortMidiStream;
+#define PmStream PortMidiStream
+
+/**
+    Test whether stream has a pending host error. Normally, the client finds
+    out about errors through returned error codes, but some errors can occur
+    asynchronously where the client does not
+    explicitly call a function, and therefore cannot receive an error code.
+    The client can test for a pending error using Pm_HasHostError(). If true,
+    the error can be accessed and cleared by calling Pm_GetErrorText(). 
+    Errors are also cleared by calling other functions that can return
+    errors, e.g. Pm_OpenInput(), Pm_OpenOutput(), Pm_Read(), Pm_Write(). The
+    client does not need to call Pm_HasHostError(). Any pending error will be
+    reported the next time the client performs an explicit function call on 
+    the stream, e.g. an input or output operation. Until the error is cleared,
+    no new error codes will be obtained, even for a different stream.
+*/
+int Pm_HasHostError( PortMidiStream * stream );
+
+
+/**  Translate portmidi error number into human readable message.
+    These strings are constants (set at compile time) so client has 
+    no need to allocate storage
+*/
+const char *Pm_GetErrorText( PmError errnum );
+
+/**  Translate portmidi host error into human readable message.
+    These strings are computed at run time, so client has to allocate storage.
+    After this routine executes, the host error is cleared. 
+*/
+void Pm_GetHostErrorText(char * msg, unsigned int len);
+
+#define HDRLENGTH 50
+#define PM_HOST_ERROR_MSG_LEN 256u /* any host error msg will occupy less 
+                                      than this number of characters */
+
+/**
+    Device enumeration mechanism.
+
+    Device ids range from 0 to Pm_CountDevices()-1.
+
+*/
+typedef int PmDeviceID;
+#define pmNoDevice -1
+typedef struct {
+    int structVersion; /**< this internal structure version */ 
+    const char *interf; /**< underlying MIDI API, e.g. MMSystem or DirectX */
+    const char *name;   /**< device name, e.g. USB MidiSport 1x1 */
+    int input; /**< true iff input is available */
+    int output; /**< true iff output is available */
+    int opened; /**< used by generic PortMidi code to do error checking on arguments */
+
+} PmDeviceInfo;
+
+/**  Get devices count, ids range from 0 to Pm_CountDevices()-1. */
+int Pm_CountDevices( void );
+/**
+    Pm_GetDefaultInputDeviceID(), Pm_GetDefaultOutputDeviceID()
+
+    Return the default device ID or pmNoDevice if there are no devices.
+    The result (but not pmNoDevice) can be passed to Pm_OpenMidi().
+    
+    The default device can be specified using a small application
+    named pmdefaults that is part of the PortMidi distribution. This
+    program in turn uses the Java Preferences object created by
+    java.util.prefs.Preferences.userRoot().node("/PortMidi"); the
+    preference is set by calling 
+        prefs.put("PM_RECOMMENDED_OUTPUT_DEVICE", prefName);
+    or  prefs.put("PM_RECOMMENDED_INPUT_DEVICE", prefName);
+    
+    In the statements above, prefName is a string describing the
+    MIDI device in the form "interf, name" where interf identifies
+    the underlying software system or API used by PortMdi to access
+    devices and name is the name of the device. These correspond to 
+    the interf and name fields of a PmDeviceInfo. (Currently supported
+    interfaces are "MMSystem" for Win32, "ALSA" for Linux, and 
+    "CoreMIDI" for OS X, so in fact, there is no choice of interface.)
+    In "interf, name", the strings are actually substrings of 
+    the full interface and name strings. For example, the preference 
+    "Core, Sport" will match a device with interface "CoreMIDI"
+    and name "In USB MidiSport 1x1". It will also match "CoreMIDI"
+    and "In USB MidiSport 2x2". The devices are enumerated in device
+    ID order, so the lowest device ID that matches the pattern becomes
+    the default device. Finally, if the comma-space (", ") separator
+    between interface and name parts of the preference is not found,
+    the entire preference string is interpreted as a name, and the
+    interface part is the empty string, which matches anything.
+
+    On the MAC, preferences are stored in 
+      /Users/$NAME/Library/Preferences/com.apple.java.util.prefs.plist
+    which is a binary file. In addition to the pmdefaults program,
+    there are utilities that can read and edit this preference file.
+
+    On the PC, 
+
+    On Linux, 
+
+*/
+PmDeviceID Pm_GetDefaultInputDeviceID( void );
+/** see PmDeviceID Pm_GetDefaultInputDeviceID() */
+PmDeviceID Pm_GetDefaultOutputDeviceID( void );
+
+/**
+    PmTimestamp is used to represent a millisecond clock with arbitrary
+    start time. The type is used for all MIDI timestampes and clocks.
+*/
+typedef long PmTimestamp;
+typedef PmTimestamp (*PmTimeProcPtr)(void *time_info);
+
+/** TRUE if t1 before t2 */
+#define PmBefore(t1,t2) ((t1-t2) < 0)
+/** 
+    \defgroup grp_device Input/Output Devices Handling
+    @{
+*/
+/**
+    Pm_GetDeviceInfo() returns a pointer to a PmDeviceInfo structure
+    referring to the device specified by id.
+    If id is out of range the function returns NULL.
+
+    The returned structure is owned by the PortMidi implementation and must
+    not be manipulated or freed. The pointer is guaranteed to be valid
+    between calls to Pm_Initialize() and Pm_Terminate().
+*/
+const PmDeviceInfo* Pm_GetDeviceInfo( PmDeviceID id );
+
+/**
+    Pm_OpenInput() and Pm_OpenOutput() open devices.
+
+    stream is the address of a PortMidiStream pointer which will receive
+    a pointer to the newly opened stream.
+
+    inputDevice is the id of the device used for input (see PmDeviceID above).
+
+    inputDriverInfo is a pointer to an optional driver specific data structure
+    containing additional information for device setup or handle processing.
+    inputDriverInfo is never required for correct operation. If not used
+    inputDriverInfo should be NULL.
+
+    outputDevice is the id of the device used for output (see PmDeviceID above.)
+
+    outputDriverInfo is a pointer to an optional driver specific data structure
+    containing additional information for device setup or handle processing.
+    outputDriverInfo is never required for correct operation. If not used
+    outputDriverInfo should be NULL.
+
+    For input, the buffersize specifies the number of input events to be 
+    buffered waiting to be read using Pm_Read(). For output, buffersize 
+    specifies the number of output events to be buffered waiting for output. 
+    (In some cases -- see below -- PortMidi does not buffer output at all
+    and merely passes data to a lower-level API, in which case buffersize
+    is ignored.)
+    
+    latency is the delay in milliseconds applied to timestamps to determine 
+    when the output should actually occur. (If latency is < 0, 0 is assumed.) 
+    If latency is zero, timestamps are ignored and all output is delivered
+    immediately. If latency is greater than zero, output is delayed until the
+    message timestamp plus the latency. (NOTE: the time is measured relative 
+    to the time source indicated by time_proc. Timestamps are absolute,
+    not relative delays or offsets.) In some cases, PortMidi can obtain
+    better timing than your application by passing timestamps along to the
+    device driver or hardware. Latency may also help you to synchronize midi
+    data to audio data by matching midi latency to the audio buffer latency.
+
+    time_proc is a pointer to a procedure that returns time in milliseconds. It
+    may be NULL, in which case a default millisecond timebase (PortTime) is 
+    used. If the application wants to use PortTime, it should start the timer
+    (call Pt_Start) before calling Pm_OpenInput or Pm_OpenOutput. If the
+    application tries to start the timer *after* Pm_OpenInput or Pm_OpenOutput,
+    it may get a ptAlreadyStarted error from Pt_Start, and the application's
+    preferred time resolution and callback function will be ignored.
+    time_proc result values are appended to incoming MIDI data, and time_proc
+    times are used to schedule outgoing MIDI data (when latency is non-zero).
+
+    time_info is a pointer passed to time_proc.
+
+    Example: If I provide a timestamp of 5000, latency is 1, and time_proc
+    returns 4990, then the desired output time will be when time_proc returns
+    timestamp+latency = 5001. This will be 5001-4990 = 11ms from now.
+
+    return value:
+    Upon success Pm_Open() returns PmNoError and places a pointer to a
+    valid PortMidiStream in the stream argument.
+    If a call to Pm_Open() fails a nonzero error code is returned (see
+    PMError above) and the value of port is invalid.
+
+    Any stream that is successfully opened should eventually be closed
+    by calling Pm_Close().
+
+*/
+PmError Pm_OpenInput( PortMidiStream** stream,
+                PmDeviceID inputDevice,
+                void *inputDriverInfo,
+                long bufferSize,
+                PmTimeProcPtr time_proc,
+                void *time_info );
+
+PmError Pm_OpenOutput( PortMidiStream** stream,
+                PmDeviceID outputDevice,
+                void *outputDriverInfo,
+                long bufferSize,
+                PmTimeProcPtr time_proc,
+                void *time_info,
+                long latency );
+  /** @} */
+
+/**
+   \defgroup grp_events_filters Events and Filters Handling
+   @{
+*/
+
+/*  \function PmError Pm_SetFilter( PortMidiStream* stream, long filters )
+    Pm_SetFilter() sets filters on an open input stream to drop selected
+    input types. By default, only active sensing messages are filtered.
+    To prohibit, say, active sensing and sysex messages, call
+    Pm_SetFilter(stream, PM_FILT_ACTIVE | PM_FILT_SYSEX);
+
+    Filtering is useful when midi routing or midi thru functionality is being
+    provided by the user application.
+    For example, you may want to exclude timing messages (clock, MTC, start/stop/continue),
+    while allowing note-related messages to pass.
+    Or you may be using a sequencer or drum-machine for MIDI clock information but want to
+    exclude any notes it may play.
+ */
+    
+/* Filter bit-mask definitions */
+/** filter active sensing messages (0xFE): */
+#define PM_FILT_ACTIVE (1 << 0x0E)
+/** filter system exclusive messages (0xF0): */
+#define PM_FILT_SYSEX (1 << 0x00)
+/** filter MIDI clock message (0xF8) */
+#define PM_FILT_CLOCK (1 << 0x08)
+/** filter play messages (start 0xFA, stop 0xFC, continue 0xFB) */
+#define PM_FILT_PLAY ((1 << 0x0A) | (1 << 0x0C) | (1 << 0x0B))
+/** filter tick messages (0xF9) */
+#define PM_FILT_TICK (1 << 0x09)
+/** filter undefined FD messages */
+#define PM_FILT_FD (1 << 0x0D)
+/** filter undefined real-time messages */
+#define PM_FILT_UNDEFINED PM_FILT_FD
+/** filter reset messages (0xFF) */
+#define PM_FILT_RESET (1 << 0x0F)
+/** filter all real-time messages */
+#define PM_FILT_REALTIME (PM_FILT_ACTIVE | PM_FILT_SYSEX | PM_FILT_CLOCK | \
+    PM_FILT_PLAY | PM_FILT_UNDEFINED | PM_FILT_RESET | PM_FILT_TICK)
+/** filter note-on and note-off (0x90-0x9F and 0x80-0x8F */
+#define PM_FILT_NOTE ((1 << 0x19) | (1 << 0x18))
+/** filter channel aftertouch (most midi controllers use this) (0xD0-0xDF)*/
+#define PM_FILT_CHANNEL_AFTERTOUCH (1 << 0x1D)
+/** per-note aftertouch (0xA0-0xAF) */
+#define PM_FILT_POLY_AFTERTOUCH (1 << 0x1A)
+/** filter both channel and poly aftertouch */
+#define PM_FILT_AFTERTOUCH (PM_FILT_CHANNEL_AFTERTOUCH | PM_FILT_POLY_AFTERTOUCH)
+/** Program changes (0xC0-0xCF) */
+#define PM_FILT_PROGRAM (1 << 0x1C)
+/** Control Changes (CC's) (0xB0-0xBF)*/
+#define PM_FILT_CONTROL (1 << 0x1B)
+/** Pitch Bender (0xE0-0xEF*/
+#define PM_FILT_PITCHBEND (1 << 0x1E)
+/** MIDI Time Code (0xF1)*/
+#define PM_FILT_MTC (1 << 0x01)
+/** Song Position (0xF2) */
+#define PM_FILT_SONG_POSITION (1 << 0x02)
+/** Song Select (0xF3)*/
+#define PM_FILT_SONG_SELECT (1 << 0x03)
+/** Tuning request (0xF6)*/
+#define PM_FILT_TUNE (1 << 0x06)
+/** All System Common messages (mtc, song position, song select, tune request) */
+#define PM_FILT_SYSTEMCOMMON (PM_FILT_MTC | PM_FILT_SONG_POSITION | PM_FILT_SONG_SELECT | PM_FILT_TUNE)
+
+
+PmError Pm_SetFilter( PortMidiStream* stream, long filters );
+
+#define Pm_Channel(channel) (1<<(channel))
+/**
+    Pm_SetChannelMask() filters incoming messages based on channel.
+    The mask is a 16-bit bitfield corresponding to appropriate channels
+    The Pm_Channel macro can assist in calling this function.
+    i.e. to set receive only input on channel 1, call with
+    Pm_SetChannelMask(Pm_Channel(1));
+    Multiple channels should be OR'd together, like
+    Pm_SetChannelMask(Pm_Channel(10) | Pm_Channel(11))
+
+    All channels are allowed by default
+*/
+PmError Pm_SetChannelMask(PortMidiStream *stream, int mask);
+
+/**
+    Pm_Abort() terminates outgoing messages immediately
+    The caller should immediately close the output port;
+    this call may result in transmission of a partial midi message.
+    There is no abort for Midi input because the user can simply
+    ignore messages in the buffer and close an input device at
+    any time.
+ */
+PmError Pm_Abort( PortMidiStream* stream );
+     
+/**
+    Pm_Close() closes a midi stream, flushing any pending buffers.
+    (PortMidi attempts to close open streams when the application 
+    exits -- this is particularly difficult under Windows.)
+*/
+PmError Pm_Close( PortMidiStream* stream );
+
+/**
+    Pm_Message() encodes a short Midi message into a long word. If data1
+    and/or data2 are not present, use zero.
+
+    Pm_MessageStatus(), Pm_MessageData1(), and 
+    Pm_MessageData2() extract fields from a long-encoded midi message.
+*/
+#define Pm_Message(status, data1, data2) \
+         ((((data2) << 16) & 0xFF0000) | \
+          (((data1) << 8) & 0xFF00) | \
+          ((status) & 0xFF))
+#define Pm_MessageStatus(msg) ((msg) & 0xFF)
+#define Pm_MessageData1(msg) (((msg) >> 8) & 0xFF)
+#define Pm_MessageData2(msg) (((msg) >> 16) & 0xFF)
+
+typedef long PmMessage; /**< see PmEvent */
+/**
+   All midi data comes in the form of PmEvent structures. A sysex
+   message is encoded as a sequence of PmEvent structures, with each
+   structure carrying 4 bytes of the message, i.e. only the first
+   PmEvent carries the status byte.
+
+   Note that MIDI allows nested messages: the so-called "real-time" MIDI 
+   messages can be inserted into the MIDI byte stream at any location, 
+   including within a sysex message. MIDI real-time messages are one-byte
+   messages used mainly for timing (see the MIDI spec). PortMidi retains 
+   the order of non-real-time MIDI messages on both input and output, but 
+   it does not specify exactly how real-time messages are processed. This
+   is particulary problematic for MIDI input, because the input parser 
+   must either prepare to buffer an unlimited number of sysex message 
+   bytes or to buffer an unlimited number of real-time messages that 
+   arrive embedded in a long sysex message. To simplify things, the input
+   parser is allowed to pass real-time MIDI messages embedded within a 
+   sysex message, and it is up to the client to detect, process, and 
+   remove these messages as they arrive.
+
+   When receiving sysex messages, the sysex message is terminated
+   by either an EOX status byte (anywhere in the 4 byte messages) or
+   by a non-real-time status byte in the low order byte of the message.
+   If you get a non-real-time status byte but there was no EOX byte, it 
+   means the sysex message was somehow truncated. This is not
+   considered an error; e.g., a missing EOX can result from the user
+   disconnecting a MIDI cable during sysex transmission.
+
+   A real-time message can occur within a sysex message. A real-time 
+   message will always occupy a full PmEvent with the status byte in 
+   the low-order byte of the PmEvent message field. (This implies that
+   the byte-order of sysex bytes and real-time message bytes may not
+   be preserved -- for example, if a real-time message arrives after
+   3 bytes of a sysex message, the real-time message will be delivered
+   first. The first word of the sysex message will be delivered only
+   after the 4th byte arrives, filling the 4-byte PmEvent message field.
+   
+   The timestamp field is observed when the output port is opened with
+   a non-zero latency. A timestamp of zero means "use the current time",
+   which in turn means to deliver the message with a delay of
+   latency (the latency parameter used when opening the output port.)
+   Do not expect PortMidi to sort data according to timestamps -- 
+   messages should be sent in the correct order, and timestamps MUST 
+   be non-decreasing. See also "Example" for Pm_OpenOutput() above.
+
+   A sysex message will generally fill many PmEvent structures. On 
+   output to a PortMidiStream with non-zero latency, the first timestamp
+   on sysex message data will determine the time to begin sending the 
+   message. PortMidi implementations may ignore timestamps for the 
+   remainder of the sysex message. 
+   
+   On input, the timestamp ideally denotes the arrival time of the 
+   status byte of the message. The first timestamp on sysex message 
+   data will be valid. Subsequent timestamps may denote 
+   when message bytes were actually received, or they may be simply 
+   copies of the first timestamp.
+
+   Timestamps for nested messages: If a real-time message arrives in 
+   the middle of some other message, it is enqueued immediately with 
+   the timestamp corresponding to its arrival time. The interrupted 
+   non-real-time message or 4-byte packet of sysex data will be enqueued 
+   later. The timestamp of interrupted data will be equal to that of
+   the interrupting real-time message to insure that timestamps are
+   non-decreasing.
+ */
+typedef struct {
+    PmMessage      message;
+    PmTimestamp    timestamp;
+} PmEvent;
+
+/** 
+    @}
+*/
+/** \defgroup grp_io Reading and Writing Midi Messages
+    @{
+*/
+/**
+    Pm_Read() retrieves midi data into a buffer, and returns the number
+    of events read. Result is a non-negative number unless an error occurs, 
+    in which case a PmError value will be returned.
+
+    Buffer Overflow
+
+    The problem: if an input overflow occurs, data will be lost, ultimately 
+    because there is no flow control all the way back to the data source. 
+    When data is lost, the receiver should be notified and some sort of 
+    graceful recovery should take place, e.g. you shouldn't resume receiving 
+    in the middle of a long sysex message.
+
+    With a lock-free fifo, which is pretty much what we're stuck with to 
+    enable portability to the Mac, it's tricky for the producer and consumer 
+    to synchronously reset the buffer and resume normal operation.
+
+    Solution: the buffer managed by PortMidi will be flushed when an overflow
+    occurs. The consumer (Pm_Read()) gets an error message (pmBufferOverflow)
+    and ordinary processing resumes as soon as a new message arrives. The
+    remainder of a partial sysex message is not considered to be a "new
+    message" and will be flushed as well.
+
+*/
+int Pm_Read( PortMidiStream *stream, PmEvent *buffer, long length );
+
+/**
+    Pm_Poll() tests whether input is available, 
+    returning TRUE, FALSE, or an error value.
+*/
+PmError Pm_Poll( PortMidiStream *stream);
+
+/** 
+    Pm_Write() writes midi data from a buffer. This may contain:
+        - short messages 
+    or 
+        - sysex messages that are converted into a sequence of PmEvent
+          structures, e.g. sending data from a file or forwarding them
+          from midi input.
+
+    Use Pm_WriteSysEx() to write a sysex message stored as a contiguous 
+    array of bytes.
+
+    Sysex data may contain embedded real-time messages.
+*/
+PmError Pm_Write( PortMidiStream *stream, PmEvent *buffer, long length );
+
+/**
+    Pm_WriteShort() writes a timestamped non-system-exclusive midi message.
+    Messages are delivered in order as received, and timestamps must be 
+    non-decreasing. (But timestamps are ignored if the stream was opened
+    with latency = 0.)
+*/
+PmError Pm_WriteShort( PortMidiStream *stream, PmTimestamp when, long msg);
+
+/**
+    Pm_WriteSysEx() writes a timestamped system-exclusive midi message.
+*/
+PmError Pm_WriteSysEx( PortMidiStream *stream, PmTimestamp when, unsigned char *msg);
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* PORT_MIDI_H */

=== added file 'mixxx-win64lib/portmidi.lib'
Binary files mixxx-win64lib/portmidi.lib	1970-01-01 00:00:00 +0000 and mixxx-win64lib/portmidi.lib	2009-11-10 00:33:17 +0000 differ
=== added file 'mixxx-win64lib/porttime.h'
--- mixxx-win64lib/porttime.h	1970-01-01 00:00:00 +0000
+++ mixxx-win64lib/porttime.h	2009-11-10 00:33:17 +0000
@@ -0,0 +1,72 @@
+/* porttime.h -- portable interface to millisecond timer */
+
+/* CHANGE LOG FOR PORTTIME
+  10-Jun-03 Mark Nelson & RBD
+    boost priority of timer thread in ptlinux.c implementation
+ */
+
+/* Should there be a way to choose the source of time here? */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef enum {
+    ptNoError = 0,         /* success */
+    ptHostError = -10000,  /* a system-specific error occurred */
+    ptAlreadyStarted,      /* cannot start timer because it is already started */
+    ptAlreadyStopped,      /* cannot stop timer because it is already stopped */
+    ptInsufficientMemory   /* memory could not be allocated */
+} PtError;
+
+
+typedef long PtTimestamp;
+
+typedef void (PtCallback)( PtTimestamp timestamp, void *userData );
+
+/*
+    Pt_Start() starts a real-time service.
+
+    resolution is the timer resolution in ms. The time will advance every
+    resolution ms.
+
+    callback is a function pointer to be called every resolution ms.
+
+    userData is passed to callback as a parameter.
+
+    return value:
+    Upon success, returns ptNoError. See PtError for other values.
+*/
+PtError Pt_Start(int resolution, PtCallback *callback, void *userData);
+
+/*
+    Pt_Stop() stops the timer.
+
+    return value:
+    Upon success, returns ptNoError. See PtError for other values.
+*/
+PtError Pt_Stop();
+
+/*
+    Pt_Started() returns true iff the timer is running.
+*/
+int Pt_Started();
+
+/* 
+    Pt_Time() returns the current time in ms.
+*/
+PtTimestamp Pt_Time();
+
+/*
+    Pt_Sleep() pauses, allowing other threads to run.
+
+    duration is the length of the pause in ms. The true duration 
+    of the pause may be rounded to the nearest or next clock tick
+    as determined by resolution in Pt_Start().
+*/
+void Pt_Sleep(long duration);
+
+#ifdef __cplusplus
+}
+#endif

=== added file 'mixxx-win64lib/porttime.lib'
Binary files mixxx-win64lib/porttime.lib	1970-01-01 00:00:00 +0000 and mixxx-win64lib/porttime.lib	2009-11-10 00:33:17 +0000 differ
=== added file 'mixxx-winlib/portmidi.h'
--- mixxx-winlib/portmidi.h	1970-01-01 00:00:00 +0000
+++ mixxx-winlib/portmidi.h	2009-11-10 00:33:17 +0000
@@ -0,0 +1,604 @@
+#ifndef PORT_MIDI_H
+#define PORT_MIDI_H
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ * PortMidi Portable Real-Time MIDI Library
+ * PortMidi API Header File
+ * Latest version available at: http://sourceforge.net/projects/portmedia
+ *
+ * Copyright (c) 1999-2000 Ross Bencina and Phil Burk
+ * Copyright (c) 2001-2006 Roger B. Dannenberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * The text above constitutes the entire PortMidi license; however, 
+ * the PortMusic community also makes the following non-binding requests:
+ *
+ * Any person wishing to distribute modifications to the Software is
+ * requested to send the modifications to the original developer so that
+ * they can be incorporated into the canonical version. It is also
+ * requested that these non-binding requests be included along with the 
+ * license above.
+ */
+
+/* CHANGELOG FOR PORTMIDI
+ *     (see ../CHANGELOG.txt)
+ *
+ * NOTES ON HOST ERROR REPORTING: 
+ *
+ *    PortMidi errors (of type PmError) are generic, system-independent errors.
+ *    When an error does not map to one of the more specific PmErrors, the
+ *    catch-all code pmHostError is returned. This means that PortMidi has
+ *    retained a more specific system-dependent error code. The caller can
+ *    get more information by calling Pm_HasHostError() to test if there is
+ *    a pending host error, and Pm_GetHostErrorText() to get a text string
+ *    describing the error. Host errors are reported on a per-device basis 
+ *    because only after you open a device does PortMidi have a place to 
+ *    record the host error code. I.e. only 
+ *    those routines that receive a (PortMidiStream *) argument check and 
+ *    report errors. One exception to this is that Pm_OpenInput() and 
+ *    Pm_OpenOutput() can report errors even though when an error occurs,
+ *    there is no PortMidiStream* to hold the error. Fortunately, both
+ *    of these functions return any error immediately, so we do not really
+ *    need per-device error memory. Instead, any host error code is stored
+ *    in a global, pmHostError is returned, and the user can call 
+ *    Pm_GetHostErrorText() to get the error message (and the invalid stream
+ *    parameter will be ignored.) The functions 
+ *    pm_init and pm_term do not fail or raise
+ *    errors. The job of pm_init is to locate all available devices so that
+ *    the caller can get information via PmDeviceInfo(). If an error occurs,
+ *    the device is simply not listed as available.
+ *
+ *    Host errors come in two flavors:
+ *      a) host error 
+ *      b) host error during callback
+ *    These can occur w/midi input or output devices. (b) can only happen 
+ *    asynchronously (during callback routines), whereas (a) only occurs while
+ *    synchronously running PortMidi and any resulting system dependent calls.
+ *    Both (a) and (b) are reported by the next read or write call. You can
+ *    also query for asynchronous errors (b) at any time by calling
+ *    Pm_HasHostError().
+ *
+ * NOTES ON COMPILE-TIME SWITCHES
+ *
+ *    DEBUG assumes stdio and a console. Use this if you want automatic, simple
+ *        error reporting, e.g. for prototyping. If you are using MFC or some 
+ *        other graphical interface with no console, DEBUG probably should be
+ *        undefined.
+ *    PM_CHECK_ERRORS more-or-less takes over error checking for return values,
+ *        stopping your program and printing error messages when an error
+ *        occurs. This also uses stdio for console text I/O.
+ */ 
+
+#ifndef FALSE
+    #define FALSE 0
+#endif
+#ifndef TRUE
+    #define TRUE 1
+#endif
+
+/* default size of buffers for sysex transmission: */
+#define PM_DEFAULT_SYSEX_BUFFER_SIZE 1024
+
+/** List of portmidi errors.*/
+typedef enum {
+    pmNoError = 0,
+    pmNoData = 0, /**< A "no error" return that also indicates no data avail. */
+    pmGotData = 1, /**< A "no error" return that also indicates data available */
+    pmHostError = -10000,
+    pmInvalidDeviceId, /** out of range or 
+                        * output device when input is requested or 
+                        * input device when output is requested or
+                        * device is already opened 
+                        */
+    pmInsufficientMemory,
+    pmBufferTooSmall,
+    pmBufferOverflow,
+    pmBadPtr, /* PortMidiStream parameter is NULL or
+               * stream is not opened or
+               * stream is output when input is required or
+               * stream is input when output is required */
+    pmBadData, /** illegal midi data, e.g. missing EOX */
+    pmInternalError,
+    pmBufferMaxSize /** buffer is already as large as it can be */
+    /* NOTE: If you add a new error type, be sure to update Pm_GetErrorText() */
+} PmError;
+
+/**
+    Pm_Initialize() is the library initialisation function - call this before
+    using the library.
+*/
+PmError Pm_Initialize( void );
+
+/**
+    Pm_Terminate() is the library termination function - call this after
+    using the library.
+*/
+PmError Pm_Terminate( void );
+
+/**  A single PortMidiStream is a descriptor for an open MIDI device.
+*/
+typedef void PortMidiStream;
+#define PmStream PortMidiStream
+
+/**
+    Test whether stream has a pending host error. Normally, the client finds
+    out about errors through returned error codes, but some errors can occur
+    asynchronously where the client does not
+    explicitly call a function, and therefore cannot receive an error code.
+    The client can test for a pending error using Pm_HasHostError(). If true,
+    the error can be accessed and cleared by calling Pm_GetErrorText(). 
+    Errors are also cleared by calling other functions that can return
+    errors, e.g. Pm_OpenInput(), Pm_OpenOutput(), Pm_Read(), Pm_Write(). The
+    client does not need to call Pm_HasHostError(). Any pending error will be
+    reported the next time the client performs an explicit function call on 
+    the stream, e.g. an input or output operation. Until the error is cleared,
+    no new error codes will be obtained, even for a different stream.
+*/
+int Pm_HasHostError( PortMidiStream * stream );
+
+
+/**  Translate portmidi error number into human readable message.
+    These strings are constants (set at compile time) so client has 
+    no need to allocate storage
+*/
+const char *Pm_GetErrorText( PmError errnum );
+
+/**  Translate portmidi host error into human readable message.
+    These strings are computed at run time, so client has to allocate storage.
+    After this routine executes, the host error is cleared. 
+*/
+void Pm_GetHostErrorText(char * msg, unsigned int len);
+
+#define HDRLENGTH 50
+#define PM_HOST_ERROR_MSG_LEN 256u /* any host error msg will occupy less 
+                                      than this number of characters */
+
+/**
+    Device enumeration mechanism.
+
+    Device ids range from 0 to Pm_CountDevices()-1.
+
+*/
+typedef int PmDeviceID;
+#define pmNoDevice -1
+typedef struct {
+    int structVersion; /**< this internal structure version */ 
+    const char *interf; /**< underlying MIDI API, e.g. MMSystem or DirectX */
+    const char *name;   /**< device name, e.g. USB MidiSport 1x1 */
+    int input; /**< true iff input is available */
+    int output; /**< true iff output is available */
+    int opened; /**< used by generic PortMidi code to do error checking on arguments */
+
+} PmDeviceInfo;
+
+/**  Get devices count, ids range from 0 to Pm_CountDevices()-1. */
+int Pm_CountDevices( void );
+/**
+    Pm_GetDefaultInputDeviceID(), Pm_GetDefaultOutputDeviceID()
+
+    Return the default device ID or pmNoDevice if there are no devices.
+    The result (but not pmNoDevice) can be passed to Pm_OpenMidi().
+    
+    The default device can be specified using a small application
+    named pmdefaults that is part of the PortMidi distribution. This
+    program in turn uses the Java Preferences object created by
+    java.util.prefs.Preferences.userRoot().node("/PortMidi"); the
+    preference is set by calling 
+        prefs.put("PM_RECOMMENDED_OUTPUT_DEVICE", prefName);
+    or  prefs.put("PM_RECOMMENDED_INPUT_DEVICE", prefName);
+    
+    In the statements above, prefName is a string describing the
+    MIDI device in the form "interf, name" where interf identifies
+    the underlying software system or API used by PortMdi to access
+    devices and name is the name of the device. These correspond to 
+    the interf and name fields of a PmDeviceInfo. (Currently supported
+    interfaces are "MMSystem" for Win32, "ALSA" for Linux, and 
+    "CoreMIDI" for OS X, so in fact, there is no choice of interface.)
+    In "interf, name", the strings are actually substrings of 
+    the full interface and name strings. For example, the preference 
+    "Core, Sport" will match a device with interface "CoreMIDI"
+    and name "In USB MidiSport 1x1". It will also match "CoreMIDI"
+    and "In USB MidiSport 2x2". The devices are enumerated in device
+    ID order, so the lowest device ID that matches the pattern becomes
+    the default device. Finally, if the comma-space (", ") separator
+    between interface and name parts of the preference is not found,
+    the entire preference string is interpreted as a name, and the
+    interface part is the empty string, which matches anything.
+
+    On the MAC, preferences are stored in 
+      /Users/$NAME/Library/Preferences/com.apple.java.util.prefs.plist
+    which is a binary file. In addition to the pmdefaults program,
+    there are utilities that can read and edit this preference file.
+
+    On the PC, 
+
+    On Linux, 
+
+*/
+PmDeviceID Pm_GetDefaultInputDeviceID( void );
+/** see PmDeviceID Pm_GetDefaultInputDeviceID() */
+PmDeviceID Pm_GetDefaultOutputDeviceID( void );
+
+/**
+    PmTimestamp is used to represent a millisecond clock with arbitrary
+    start time. The type is used for all MIDI timestampes and clocks.
+*/
+typedef long PmTimestamp;
+typedef PmTimestamp (*PmTimeProcPtr)(void *time_info);
+
+/** TRUE if t1 before t2 */
+#define PmBefore(t1,t2) ((t1-t2) < 0)
+/** 
+    \defgroup grp_device Input/Output Devices Handling
+    @{
+*/
+/**
+    Pm_GetDeviceInfo() returns a pointer to a PmDeviceInfo structure
+    referring to the device specified by id.
+    If id is out of range the function returns NULL.
+
+    The returned structure is owned by the PortMidi implementation and must
+    not be manipulated or freed. The pointer is guaranteed to be valid
+    between calls to Pm_Initialize() and Pm_Terminate().
+*/
+const PmDeviceInfo* Pm_GetDeviceInfo( PmDeviceID id );
+
+/**
+    Pm_OpenInput() and Pm_OpenOutput() open devices.
+
+    stream is the address of a PortMidiStream pointer which will receive
+    a pointer to the newly opened stream.
+
+    inputDevice is the id of the device used for input (see PmDeviceID above).
+
+    inputDriverInfo is a pointer to an optional driver specific data structure
+    containing additional information for device setup or handle processing.
+    inputDriverInfo is never required for correct operation. If not used
+    inputDriverInfo should be NULL.
+
+    outputDevice is the id of the device used for output (see PmDeviceID above.)
+
+    outputDriverInfo is a pointer to an optional driver specific data structure
+    containing additional information for device setup or handle processing.
+    outputDriverInfo is never required for correct operation. If not used
+    outputDriverInfo should be NULL.
+
+    For input, the buffersize specifies the number of input events to be 
+    buffered waiting to be read using Pm_Read(). For output, buffersize 
+    specifies the number of output events to be buffered waiting for output. 
+    (In some cases -- see below -- PortMidi does not buffer output at all
+    and merely passes data to a lower-level API, in which case buffersize
+    is ignored.)
+    
+    latency is the delay in milliseconds applied to timestamps to determine 
+    when the output should actually occur. (If latency is < 0, 0 is assumed.) 
+    If latency is zero, timestamps are ignored and all output is delivered
+    immediately. If latency is greater than zero, output is delayed until the
+    message timestamp plus the latency. (NOTE: the time is measured relative 
+    to the time source indicated by time_proc. Timestamps are absolute,
+    not relative delays or offsets.) In some cases, PortMidi can obtain
+    better timing than your application by passing timestamps along to the
+    device driver or hardware. Latency may also help you to synchronize midi
+    data to audio data by matching midi latency to the audio buffer latency.
+
+    time_proc is a pointer to a procedure that returns time in milliseconds. It
+    may be NULL, in which case a default millisecond timebase (PortTime) is 
+    used. If the application wants to use PortTime, it should start the timer
+    (call Pt_Start) before calling Pm_OpenInput or Pm_OpenOutput. If the
+    application tries to start the timer *after* Pm_OpenInput or Pm_OpenOutput,
+    it may get a ptAlreadyStarted error from Pt_Start, and the application's
+    preferred time resolution and callback function will be ignored.
+    time_proc result values are appended to incoming MIDI data, and time_proc
+    times are used to schedule outgoing MIDI data (when latency is non-zero).
+
+    time_info is a pointer passed to time_proc.
+
+    Example: If I provide a timestamp of 5000, latency is 1, and time_proc
+    returns 4990, then the desired output time will be when time_proc returns
+    timestamp+latency = 5001. This will be 5001-4990 = 11ms from now.
+
+    return value:
+    Upon success Pm_Open() returns PmNoError and places a pointer to a
+    valid PortMidiStream in the stream argument.
+    If a call to Pm_Open() fails a nonzero error code is returned (see
+    PMError above) and the value of port is invalid.
+
+    Any stream that is successfully opened should eventually be closed
+    by calling Pm_Close().
+
+*/
+PmError Pm_OpenInput( PortMidiStream** stream,
+                PmDeviceID inputDevice,
+                void *inputDriverInfo,
+                long bufferSize,
+                PmTimeProcPtr time_proc,
+                void *time_info );
+
+PmError Pm_OpenOutput( PortMidiStream** stream,
+                PmDeviceID outputDevice,
+                void *outputDriverInfo,
+                long bufferSize,
+                PmTimeProcPtr time_proc,
+                void *time_info,
+                long latency );
+  /** @} */
+
+/**
+   \defgroup grp_events_filters Events and Filters Handling
+   @{
+*/
+
+/*  \function PmError Pm_SetFilter( PortMidiStream* stream, long filters )
+    Pm_SetFilter() sets filters on an open input stream to drop selected
+    input types. By default, only active sensing messages are filtered.
+    To prohibit, say, active sensing and sysex messages, call
+    Pm_SetFilter(stream, PM_FILT_ACTIVE | PM_FILT_SYSEX);
+
+    Filtering is useful when midi routing or midi thru functionality is being
+    provided by the user application.
+    For example, you may want to exclude timing messages (clock, MTC, start/stop/continue),
+    while allowing note-related messages to pass.
+    Or you may be using a sequencer or drum-machine for MIDI clock information but want to
+    exclude any notes it may play.
+ */
+    
+/* Filter bit-mask definitions */
+/** filter active sensing messages (0xFE): */
+#define PM_FILT_ACTIVE (1 << 0x0E)
+/** filter system exclusive messages (0xF0): */
+#define PM_FILT_SYSEX (1 << 0x00)
+/** filter MIDI clock message (0xF8) */
+#define PM_FILT_CLOCK (1 << 0x08)
+/** filter play messages (start 0xFA, stop 0xFC, continue 0xFB) */
+#define PM_FILT_PLAY ((1 << 0x0A) | (1 << 0x0C) | (1 << 0x0B))
+/** filter tick messages (0xF9) */
+#define PM_FILT_TICK (1 << 0x09)
+/** filter undefined FD messages */
+#define PM_FILT_FD (1 << 0x0D)
+/** filter undefined real-time messages */
+#define PM_FILT_UNDEFINED PM_FILT_FD
+/** filter reset messages (0xFF) */
+#define PM_FILT_RESET (1 << 0x0F)
+/** filter all real-time messages */
+#define PM_FILT_REALTIME (PM_FILT_ACTIVE | PM_FILT_SYSEX | PM_FILT_CLOCK | \
+    PM_FILT_PLAY | PM_FILT_UNDEFINED | PM_FILT_RESET | PM_FILT_TICK)
+/** filter note-on and note-off (0x90-0x9F and 0x80-0x8F */
+#define PM_FILT_NOTE ((1 << 0x19) | (1 << 0x18))
+/** filter channel aftertouch (most midi controllers use this) (0xD0-0xDF)*/
+#define PM_FILT_CHANNEL_AFTERTOUCH (1 << 0x1D)
+/** per-note aftertouch (0xA0-0xAF) */
+#define PM_FILT_POLY_AFTERTOUCH (1 << 0x1A)
+/** filter both channel and poly aftertouch */
+#define PM_FILT_AFTERTOUCH (PM_FILT_CHANNEL_AFTERTOUCH | PM_FILT_POLY_AFTERTOUCH)
+/** Program changes (0xC0-0xCF) */
+#define PM_FILT_PROGRAM (1 << 0x1C)
+/** Control Changes (CC's) (0xB0-0xBF)*/
+#define PM_FILT_CONTROL (1 << 0x1B)
+/** Pitch Bender (0xE0-0xEF*/
+#define PM_FILT_PITCHBEND (1 << 0x1E)
+/** MIDI Time Code (0xF1)*/
+#define PM_FILT_MTC (1 << 0x01)
+/** Song Position (0xF2) */
+#define PM_FILT_SONG_POSITION (1 << 0x02)
+/** Song Select (0xF3)*/
+#define PM_FILT_SONG_SELECT (1 << 0x03)
+/** Tuning request (0xF6)*/
+#define PM_FILT_TUNE (1 << 0x06)
+/** All System Common messages (mtc, song position, song select, tune request) */
+#define PM_FILT_SYSTEMCOMMON (PM_FILT_MTC | PM_FILT_SONG_POSITION | PM_FILT_SONG_SELECT | PM_FILT_TUNE)
+
+
+PmError Pm_SetFilter( PortMidiStream* stream, long filters );
+
+#define Pm_Channel(channel) (1<<(channel))
+/**
+    Pm_SetChannelMask() filters incoming messages based on channel.
+    The mask is a 16-bit bitfield corresponding to appropriate channels
+    The Pm_Channel macro can assist in calling this function.
+    i.e. to set receive only input on channel 1, call with
+    Pm_SetChannelMask(Pm_Channel(1));
+    Multiple channels should be OR'd together, like
+    Pm_SetChannelMask(Pm_Channel(10) | Pm_Channel(11))
+
+    All channels are allowed by default
+*/
+PmError Pm_SetChannelMask(PortMidiStream *stream, int mask);
+
+/**
+    Pm_Abort() terminates outgoing messages immediately
+    The caller should immediately close the output port;
+    this call may result in transmission of a partial midi message.
+    There is no abort for Midi input because the user can simply
+    ignore messages in the buffer and close an input device at
+    any time.
+ */
+PmError Pm_Abort( PortMidiStream* stream );
+     
+/**
+    Pm_Close() closes a midi stream, flushing any pending buffers.
+    (PortMidi attempts to close open streams when the application 
+    exits -- this is particularly difficult under Windows.)
+*/
+PmError Pm_Close( PortMidiStream* stream );
+
+/**
+    Pm_Message() encodes a short Midi message into a long word. If data1
+    and/or data2 are not present, use zero.
+
+    Pm_MessageStatus(), Pm_MessageData1(), and 
+    Pm_MessageData2() extract fields from a long-encoded midi message.
+*/
+#define Pm_Message(status, data1, data2) \
+         ((((data2) << 16) & 0xFF0000) | \
+          (((data1) << 8) & 0xFF00) | \
+          ((status) & 0xFF))
+#define Pm_MessageStatus(msg) ((msg) & 0xFF)
+#define Pm_MessageData1(msg) (((msg) >> 8) & 0xFF)
+#define Pm_MessageData2(msg) (((msg) >> 16) & 0xFF)
+
+typedef long PmMessage; /**< see PmEvent */
+/**
+   All midi data comes in the form of PmEvent structures. A sysex
+   message is encoded as a sequence of PmEvent structures, with each
+   structure carrying 4 bytes of the message, i.e. only the first
+   PmEvent carries the status byte.
+
+   Note that MIDI allows nested messages: the so-called "real-time" MIDI 
+   messages can be inserted into the MIDI byte stream at any location, 
+   including within a sysex message. MIDI real-time messages are one-byte
+   messages used mainly for timing (see the MIDI spec). PortMidi retains 
+   the order of non-real-time MIDI messages on both input and output, but 
+   it does not specify exactly how real-time messages are processed. This
+   is particulary problematic for MIDI input, because the input parser 
+   must either prepare to buffer an unlimited number of sysex message 
+   bytes or to buffer an unlimited number of real-time messages that 
+   arrive embedded in a long sysex message. To simplify things, the input
+   parser is allowed to pass real-time MIDI messages embedded within a 
+   sysex message, and it is up to the client to detect, process, and 
+   remove these messages as they arrive.
+
+   When receiving sysex messages, the sysex message is terminated
+   by either an EOX status byte (anywhere in the 4 byte messages) or
+   by a non-real-time status byte in the low order byte of the message.
+   If you get a non-real-time status byte but there was no EOX byte, it 
+   means the sysex message was somehow truncated. This is not
+   considered an error; e.g., a missing EOX can result from the user
+   disconnecting a MIDI cable during sysex transmission.
+
+   A real-time message can occur within a sysex message. A real-time 
+   message will always occupy a full PmEvent with the status byte in 
+   the low-order byte of the PmEvent message field. (This implies that
+   the byte-order of sysex bytes and real-time message bytes may not
+   be preserved -- for example, if a real-time message arrives after
+   3 bytes of a sysex message, the real-time message will be delivered
+   first. The first word of the sysex message will be delivered only
+   after the 4th byte arrives, filling the 4-byte PmEvent message field.
+   
+   The timestamp field is observed when the output port is opened with
+   a non-zero latency. A timestamp of zero means "use the current time",
+   which in turn means to deliver the message with a delay of
+   latency (the latency parameter used when opening the output port.)
+   Do not expect PortMidi to sort data according to timestamps -- 
+   messages should be sent in the correct order, and timestamps MUST 
+   be non-decreasing. See also "Example" for Pm_OpenOutput() above.
+
+   A sysex message will generally fill many PmEvent structures. On 
+   output to a PortMidiStream with non-zero latency, the first timestamp
+   on sysex message data will determine the time to begin sending the 
+   message. PortMidi implementations may ignore timestamps for the 
+   remainder of the sysex message. 
+   
+   On input, the timestamp ideally denotes the arrival time of the 
+   status byte of the message. The first timestamp on sysex message 
+   data will be valid. Subsequent timestamps may denote 
+   when message bytes were actually received, or they may be simply 
+   copies of the first timestamp.
+
+   Timestamps for nested messages: If a real-time message arrives in 
+   the middle of some other message, it is enqueued immediately with 
+   the timestamp corresponding to its arrival time. The interrupted 
+   non-real-time message or 4-byte packet of sysex data will be enqueued 
+   later. The timestamp of interrupted data will be equal to that of
+   the interrupting real-time message to insure that timestamps are
+   non-decreasing.
+ */
+typedef struct {
+    PmMessage      message;
+    PmTimestamp    timestamp;
+} PmEvent;
+
+/** 
+    @}
+*/
+/** \defgroup grp_io Reading and Writing Midi Messages
+    @{
+*/
+/**
+    Pm_Read() retrieves midi data into a buffer, and returns the number
+    of events read. Result is a non-negative number unless an error occurs, 
+    in which case a PmError value will be returned.
+
+    Buffer Overflow
+
+    The problem: if an input overflow occurs, data will be lost, ultimately 
+    because there is no flow control all the way back to the data source. 
+    When data is lost, the receiver should be notified and some sort of 
+    graceful recovery should take place, e.g. you shouldn't resume receiving 
+    in the middle of a long sysex message.
+
+    With a lock-free fifo, which is pretty much what we're stuck with to 
+    enable portability to the Mac, it's tricky for the producer and consumer 
+    to synchronously reset the buffer and resume normal operation.
+
+    Solution: the buffer managed by PortMidi will be flushed when an overflow
+    occurs. The consumer (Pm_Read()) gets an error message (pmBufferOverflow)
+    and ordinary processing resumes as soon as a new message arrives. The
+    remainder of a partial sysex message is not considered to be a "new
+    message" and will be flushed as well.
+
+*/
+int Pm_Read( PortMidiStream *stream, PmEvent *buffer, long length );
+
+/**
+    Pm_Poll() tests whether input is available, 
+    returning TRUE, FALSE, or an error value.
+*/
+PmError Pm_Poll( PortMidiStream *stream);
+
+/** 
+    Pm_Write() writes midi data from a buffer. This may contain:
+        - short messages 
+    or 
+        - sysex messages that are converted into a sequence of PmEvent
+          structures, e.g. sending data from a file or forwarding them
+          from midi input.
+
+    Use Pm_WriteSysEx() to write a sysex message stored as a contiguous 
+    array of bytes.
+
+    Sysex data may contain embedded real-time messages.
+*/
+PmError Pm_Write( PortMidiStream *stream, PmEvent *buffer, long length );
+
+/**
+    Pm_WriteShort() writes a timestamped non-system-exclusive midi message.
+    Messages are delivered in order as received, and timestamps must be 
+    non-decreasing. (But timestamps are ignored if the stream was opened
+    with latency = 0.)
+*/
+PmError Pm_WriteShort( PortMidiStream *stream, PmTimestamp when, long msg);
+
+/**
+    Pm_WriteSysEx() writes a timestamped system-exclusive midi message.
+*/
+PmError Pm_WriteSysEx( PortMidiStream *stream, PmTimestamp when, unsigned char *msg);
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* PORT_MIDI_H */

=== added file 'mixxx-winlib/portmidi.lib'
Binary files mixxx-winlib/portmidi.lib	1970-01-01 00:00:00 +0000 and mixxx-winlib/portmidi.lib	2009-11-10 00:33:17 +0000 differ
=== added file 'mixxx-winlib/porttime.h'
--- mixxx-winlib/porttime.h	1970-01-01 00:00:00 +0000
+++ mixxx-winlib/porttime.h	2009-11-10 00:33:17 +0000
@@ -0,0 +1,72 @@
+/* porttime.h -- portable interface to millisecond timer */
+
+/* CHANGE LOG FOR PORTTIME
+  10-Jun-03 Mark Nelson & RBD
+    boost priority of timer thread in ptlinux.c implementation
+ */
+
+/* Should there be a way to choose the source of time here? */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef enum {
+    ptNoError = 0,         /* success */
+    ptHostError = -10000,  /* a system-specific error occurred */
+    ptAlreadyStarted,      /* cannot start timer because it is already started */
+    ptAlreadyStopped,      /* cannot stop timer because it is already stopped */
+    ptInsufficientMemory   /* memory could not be allocated */
+} PtError;
+
+
+typedef long PtTimestamp;
+
+typedef void (PtCallback)( PtTimestamp timestamp, void *userData );
+
+/*
+    Pt_Start() starts a real-time service.
+
+    resolution is the timer resolution in ms. The time will advance every
+    resolution ms.
+
+    callback is a function pointer to be called every resolution ms.
+
+    userData is passed to callback as a parameter.
+
+    return value:
+    Upon success, returns ptNoError. See PtError for other values.
+*/
+PtError Pt_Start(int resolution, PtCallback *callback, void *userData);
+
+/*
+    Pt_Stop() stops the timer.
+
+    return value:
+    Upon success, returns ptNoError. See PtError for other values.
+*/
+PtError Pt_Stop();
+
+/*
+    Pt_Started() returns true iff the timer is running.
+*/
+int Pt_Started();
+
+/* 
+    Pt_Time() returns the current time in ms.
+*/
+PtTimestamp Pt_Time();
+
+/*
+    Pt_Sleep() pauses, allowing other threads to run.
+
+    duration is the length of the pause in ms. The true duration 
+    of the pause may be rounded to the nearest or next clock tick
+    as determined by resolution in Pt_Start().
+*/
+void Pt_Sleep(long duration);
+
+#ifdef __cplusplus
+}
+#endif

=== added file 'mixxx-winlib/porttime.lib'
Binary files mixxx-winlib/porttime.lib	1970-01-01 00:00:00 +0000 and mixxx-winlib/porttime.lib	2009-11-10 00:33:17 +0000 differ
=== added file 'mixxx/Mixxx.nsi'
--- mixxx/Mixxx.nsi	1970-01-01 00:00:00 +0000
+++ mixxx/Mixxx.nsi	2009-08-11 04:38:51 +0000
@@ -0,0 +1,255 @@
+; Mixxx.nsi
+;
+; Mixxx NSI install script. 
+; has uninstall support and (optionally) installs start menu shortcuts.
+;
+; By Tue Haste Andersen <[e-mail]>, June 2004.
+; Heavily modified since by Albert Santoni, Garth Dahlstrom and Sean Pappalardo.
+; 
+; Lots of bits lifted from http://www.improve.dk/downloads/InstallScript.txt
+;
+;Include Modern UI
+!include "MUI.nsh"
+
+; Definitions
+!define PRODUCT_NAME "Mixxx"
+;!define PRODUCT_VERSION ""  ; Specified by the SConscript
+!define PRODUCT_PUBLISHER "The Mixxx Team"
+!define PRODUCT_WEB_SITE "http://www.mixxx.org"
+!define PRODUCT_DIR_REGKEY "Software\Microsoft\Windows\CurrentVersion\App Paths\Mixxx.exe"
+!define PRODUCT_UNINST_KEY "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCT_NAME}"
+!define PRODUCT_UNINST_ROOT_KEY "HKLM"
+
+; The name of the installer
+Name "${PRODUCT_NAME} ${PRODUCT_VERSION}"
+
+; Disable the Nullsoft Installer branding text at the bottom.
+BrandingText " "
+
+; The file to write and default installation directory
+!ifdef x64
+    OutFile "${PRODUCT_NAME}-${PRODUCT_VERSION}-x64.exe"
+    InstallDir "$PROGRAMFILES64\${PRODUCT_NAME}"
+!else
+    OutFile "${PRODUCT_NAME}-${PRODUCT_VERSION}-x86.exe"
+    InstallDir "$PROGRAMFILES\${PRODUCT_NAME}"
+!endif
+
+; Use best compression
+SetCompressor /SOLID lzma
+
+; Registry key to check for directory (so if you install again, it will 
+; overwrite the old one automatically)
+;InstallDirRegKey HKLM "Software\NSIS_Mixxx" "Install_Dir"
+InstallDirRegKey HKLM "${PRODUCT_DIR_REGKEY}" ""
+
+;Interface Settings
+!define MUI_ABORTWARNING
+
+!define MUI_HEADERIMAGE
+;!define MUI_HEADERIMAGE_RIGHT
+!define MUI_HEADERIMAGE_BITMAP_NOSTRETCH
+!define MUI_HEADERIMAGE_BITMAP "res\images\mixxx_install_logo.bmp"
+!define MUI_ICON "res\images\icon.ico"
+
+; Pages
+!insertmacro MUI_PAGE_LICENSE "LICENSE"
+!insertmacro MUI_PAGE_COMPONENTS
+!insertmacro MUI_PAGE_DIRECTORY
+!insertmacro MUI_PAGE_INSTFILES
+  
+!insertmacro MUI_UNPAGE_CONFIRM
+!insertmacro MUI_UNPAGE_INSTFILES
+
+;Languages
+!insertmacro MUI_LANGUAGE "English"
+
+;--------------------------------
+; Install functions
+
+Function .onInit    ; Prevent multiple installer instances
+    System::Call 'kernel32::CreateMutexA(i 0, i 0, t "runningMixxxInstallerMutex") i .r1 ?e'
+    Pop $R0
+ 
+    StrCmp $R0 0 +3
+        MessageBox MB_OK|MB_ICONEXCLAMATION "The installer is already running."
+        Abort
+FunctionEnd
+
+;--------------------------------
+; The stuff to install
+Section "Mixxx (required)" SecMixxx
+
+  SectionIn RO
+  
+  ; Set output path to the installation directory.
+  SetOutPath $INSTDIR
+  
+  ; Put binary files there
+  File "dist\mixxx.exe"
+  File "dist\*.dll"
+  
+  ; NOTE: you need to check the mixxx.exe.manifest file in the win??_build directory
+  ; and place the appropriate versions of the listed DLL files and their manifest files
+  ; into the mixxx-win[64]lib directory for packaging before making the installer
+  ; (Visual C++ 2005 is msvc?80.dll and Microsoft.VC80.CRT.manifest, Visual C++ 2008 is msvc?90.dll and Microsoft.VC90.CRT.manifest)
+  ;
+  ; See http://mixxx.org/wiki/doku.php/build_windows_installer for full details.
+  
+  !ifdef x64    ; x64 versions
+    File ..\mixxx-win64lib\msvcr*.dll
+    File ..\mixxx-win64lib\msvcp*.dll
+    File /nonfatal ..\mixxx-win64lib\msvcm*.dll
+    File ..\mixxx-win64lib\Microsoft.VC*.CRT.manifest
+  !else         ; x86 versions
+    File ..\mixxx-winlib\msvcr*.dll
+    File ..\mixxx-winlib\msvcp*.dll
+    File /nonfatal ..\mixxx-winlib\msvcm*.dll
+    File ..\mixxx-winlib\Microsoft.VC*.CRT.manifest
+  !endif
+
+  ; And documentation, licence etc.
+  File "Mixxx-Manual.pdf"
+  File "LICENSE"
+  File "README"
+  File "COPYING"
+
+  SetOutPath $INSTDIR\midi
+  File /r /x ".svn" /x ".bzr" dist\midi\*.*
+
+  ;Disabled for initial 1.6.0 release
+  ;SetOutPath $INSTDIR\promo
+  ;File "dist\promo\*"
+
+  SetOutPath $INSTDIR\keyboard
+  File "dist\keyboard\Standard.kbd.cfg"
+  File "dist\keyboard\Old.kbd.cfg"
+
+  SetOutPath "$INSTDIR\skins"
+  File /r /x ".svn" /x ".bzr" dist\skins\*.*
+
+  ; Write the installation path into the registry
+  ;WriteRegStr HKLM SOFTWARE\NSIS_Mixxx "Install_Dir" "$INSTDIR"
+  WriteRegStr HKLM "${PRODUCT_DIR_REGKEY}" "" "$INSTDIR\Mixxx.exe"
+  
+  ; Write the uninstall keys for Windows
+  WriteUninstaller "$INSTDIR\uninst.exe"
+  WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "DisplayName" "$(^Name)"
+  WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "UninstallString" "$INSTDIR\uninst.exe"
+  WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "DisplayIcon" "$INSTDIR\Mixxx.exe"
+  WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "DisplayVersion" "${PRODUCT_VERSION}"
+  WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "URLInfoAbout" "${PRODUCT_WEB_SITE}"
+  WriteRegStr ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "Publisher" "${PRODUCT_PUBLISHER}"
+  WriteRegDWORD ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "NoModify" 1
+  WriteRegDWORD ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}" "NoRepair" 1
+  
+SectionEnd
+
+; Optional section (can be disabled by the user)
+Section "Start Menu Shortcuts" SecStartMenu
+
+  CreateDirectory "$SMPROGRAMS\Mixxx"
+  SetOutPath $INSTDIR
+  CreateShortCut "$SMPROGRAMS\Mixxx\Mixxx.lnk" "$INSTDIR\mixxx.exe" "" "$INSTDIR\mixxx.exe" 0
+  CreateShortCut "$SMPROGRAMS\Mixxx\Manual.lnk" "$INSTDIR\Mixxx-Manual.pdf" "" "$INSTDIR\Mixxx-Manual.pdf" 0
+  CreateShortCut "$SMPROGRAMS\Mixxx\Uninstall.lnk" "$INSTDIR\uninst.exe" "" "$INSTDIR\uninst.exe" 0
+  
+SectionEnd
+
+; Optional section (can be disabled by the user)
+Section "Desktop Shortcut" SecDesktop
+
+  SetOutPath $INSTDIR
+  CreateShortCut "$DESKTOP\Mixxx.lnk" "$INSTDIR\mixxx.exe" "" "$INSTDIR\mixxx.exe" 0
+  
+SectionEnd
+
+;--------------------------------
+;Descriptions
+
+  ;Language strings
+  LangString DESC_SecMixxx ${LANG_ENGLISH} "Mixxx software."
+  LangString DESC_SecStartMenu ${LANG_ENGLISH} "Start menu shortcuts."
+  LangString DESC_SecDesktop ${LANG_ENGLISH} "Desktop shortcut."
+
+  ;Assign language strings to sections
+  !insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN
+    !insertmacro MUI_DESCRIPTION_TEXT ${SecMixxx} $(DESC_SecMixxx)
+    !insertmacro MUI_DESCRIPTION_TEXT ${SecStartMenu} $(DESC_SecStartMenu)
+    !insertmacro MUI_DESCRIPTION_TEXT ${SecDesktop} $(DESC_SecDesktop)
+  !insertmacro MUI_FUNCTION_DESCRIPTION_END
+
+
+;--------------------------------
+
+; Uninstaller
+
+Function un.onUninstSuccess
+  HideWindow
+  MessageBox MB_ICONINFORMATION|MB_OK "$(^Name) was successfully removed from your computer."
+FunctionEnd
+
+Function un.onInit
+!insertmacro MUI_UNGETLANGUAGE
+  MessageBox MB_ICONQUESTION|MB_YESNO|MB_DEFBUTTON2 "Are you sure you want to completely remove $(^Name) and all of its components?" IDYES +2
+  Abort
+FunctionEnd
+
+Section "Uninstall"
+
+  ; Remove files and uninstaller
+  Delete $INSTDIR\mixxx.exe
+  Delete $INSTDIR\mixxx.log
+  Delete $INSTDIR\*.dll
+  Delete $INSTDIR\uninst.exe
+  Delete $INSTDIR\Mixxx-Manual.pdf
+  Delete $INSTDIR\LICENSE
+  Delete $INSTDIR\README
+  Delete $INSTDIR\COPYING
+
+  ; Remove skins, keyboard, midi defs
+  Delete $INSTDIR\skins\outline\*.*
+  Delete $INSTDIR\skins\outlineClose\*.*
+  Delete $INSTDIR\skins\outlineNetbook\*.*
+  Delete $INSTDIR\skins\outlineSmall\*.*
+  Delete $INSTDIR\skins\outlineMini\*.*
+  Delete "$INSTDIR\skins\Collusion (1280)\*.*"
+  Delete "$INSTDIR\skins\Collusion (1280-WS)\*.*"
+  Delete $INSTDIR\skins\hercules\*.*
+  Delete $INSTDIR\skins\nCut\*.*
+  Delete $INSTDIR\skins\traditional\*.*
+  Delete $INSTDIR\skins\*.*
+  Delete $INSTDIR\keyboard\*.*
+  Delete $INSTDIR\midi\*.*
+  ;Delete $INSTDIR\promo\*.*
+  RMDir "$INSTDIR\skins\outline"
+  RMDir "$INSTDIR\skins\outlineNetbook"
+  RMDir "$INSTDIR\skins\outlineClose"
+  RMDir "$INSTDIR\skins\outlineSmall"
+  RMDir "$INSTDIR\skins\outlineMini"
+  RMDir "$INSTDIR\skins\Collusion (1280)"
+  RMDir "$INSTDIR\skins\Collusion (1280-WS)"
+  RMDir "$INSTDIR\skins\hercules"
+  RMDir "$INSTDIR\skins\nCut"
+  RMDir "$INSTDIR\skins\traditional"
+  RMDir "$INSTDIR\skins"
+  RMDir "$INSTDIR\midi"
+  RMDir "$INSTDIR\keyboard"
+  ;RMDir "$INSTDIR\promo"
+
+
+  ; Remove shortcuts, if any
+  Delete "$SMPROGRAMS\Mixxx\*.*"
+  Delete "$DESKTOP\Mixxx.lnk"
+
+  ; Remove directories used
+  RMDir "$SMPROGRAMS\Mixxx"
+  RMDir "$INSTDIR"
+
+  ; Remove registry keys
+  DeleteRegKey ${PRODUCT_UNINST_ROOT_KEY} "${PRODUCT_UNINST_KEY}"
+  ;DeleteRegKey HKLM SOFTWARE\NSIS_Mixxx
+  DeleteRegKey HKLM "${PRODUCT_DIR_REGKEY}"
+  SetAutoClose true
+  
+SectionEnd

=== modified file 'mixxx/src/SConscript'
--- mixxx/src/SConscript	2009-11-10 00:33:12 +0000
+++ mixxx/src/SConscript	2009-11-10 00:33:16 +0000
@@ -1,4 +1,5 @@
 #!/usr/bin/env python
+# -*- coding: utf-8 -*-
 import os
 import sys
 import SCons
@@ -216,7 +217,6 @@
 vars.Add('script', 'Set to 1 to enable MixxxScript/QtScript Studio support.', 0)
 vars.Add('midiscript', 'Set to 1 to enable MIDI Scripting support.', 1)
 vars.Add('tonal', 'Set to 1 to enable tonal analysis', 0)
-vars.Add('portmidi', 'Set to 1 to enable PortMidi unified MIDI backend', 0)
 vars.Add('m4a','Set to 1 to enable support for M4A audio (Apple non-drm''d music format)', 1)
 vars.Add('qdebug', 'Set to 1 to enable verbose console debug output.', 1)
 vars.Add('test', 'Set to 1 to build Mixxx test fixtures.', 0)
@@ -326,20 +326,19 @@
 		analyserbpm.cpp
 		analyserwaveform.cpp
 
+                midi/midimapping.cpp
+                midi/midiinputmappingtablemodel.cpp
+                midi/midioutputmappingtablemodel.cpp
+                midi/midichanneldelegate.cpp
+                midi/midistatusdelegate.cpp
+                midi/midinodelegate.cpp
+                midi/midioptiondelegate.cpp
+                midi/midimessage.cpp
+                midi/midiledhandler.cpp
+
                 main.cpp
-                midiobject.cpp
-                midimapping.cpp
-                midiobjectnull.cpp
-                mididevicehandler.cpp
-                midiinputmappingtablemodel.cpp
-                midioutputmappingtablemodel.cpp
-                midichanneldelegate.cpp
-                midistatusdelegate.cpp
-                midinodelegate.cpp
-                midioptiondelegate.cpp
                 controlgroupdelegate.cpp
                 controlvaluedelegate.cpp
-                midimessage.cpp
                 mixxxcontrol.cpp
                 mixxx.cpp
                 mixxxview.cpp
@@ -411,7 +410,6 @@
                 imgcolor.cpp
 
                 trackinfoobject.cpp
-                midiledhandler.cpp
                 sounddevice.cpp
                 soundmanager.cpp
                 sounddeviceportaudio.cpp
@@ -433,17 +431,6 @@
 #elif 'win' in platform:
 #	sources += Split("""powermatewin.cpp mousewin.cpp """)
 
-#Compile platform specific MIDI support
-#   Linux moved to the flag parsing area since it depends on the rawmidi flag
-if 'win' in platform:
-	sources += Split("""midiobjectwin.cpp """)	  #Windows MIDI support
-	env.Append(CXXFLAGS = '-D__WINMIDI__')
-elif platform == 'osx':
-	sources += Split("""midiobjectcoremidi.cpp """) #CoreMidi support for OS X
-	env.Append(CXXFLAGS = '-D__COREMIDI__')
-elif platform == 'bsd':
-	print 'Warning: Mixxx has no support for BSD midi (yet).' #uuuuhhhh not a very good solution
-
 #Set up the library path on Windows:
 if platform == 'win64':
 	env.Append(CPPPATH='#/../mixxx-win64lib') #If you add more directories, separate them with a semicolon (;)
@@ -456,6 +443,7 @@
 if 'win' in platform:
 	env.Append(CPPPATH='../../lib/ladspa') #If you add more directories, separate them with a semicolon (;)
 	env.Append(LINKFLAGS = ['/nodefaultlib:libc.lib', '/nodefaultlib:libcd.lib',  '/entry:mainCRTStartup'])
+	env.Append(LIBS='advapi32') # needed for PortMIDI
 #'/subsystem:windows',
 
 if platform == 'bsd':
@@ -480,21 +468,6 @@
 #if not env.GetOption('clean') and not SCons.Util.containsAny(os.sys.argv, ['-h', '--help']):
 conf = Configure(env, custom_tests = { 'CheckForPKGConfig' : CheckForPKGConfig, 'CheckForPKG' : CheckForPKG })
 
-
-#PortMidi backend support
-flags_portmidi = getFlags(env, 'portmidi', 0)
-if int(flags_portmidi):
-	if not conf.CheckLib(['portmidi', 'libportmidi']):
-		print "Did not find portmidi or it\'s development headers, exiting!"
-		Exit(1)
-	#if not conf.CheckLib(['porttime', 'libporttime']):
-	#	print "Did not find porttime or it\'s development headers, exiting!"
-	#	Exit(1)
-	sources += Split("""midiobjectportmidi.cpp """);
-	env.Append(CPPDEFINES = '__PORTMIDI__')
-
-
-
 #TODO: Add all of the other configure checks as custom_tests properly.
 
 # On Posix default SCons.LIBPREFIX = 'lib', on Windows default SCons.LIBPREFIX = ''
@@ -566,6 +539,20 @@
 #Check if FFMPEG was enabled
 CheckFFMPEG(conf, sources)
 
+#Check for PortTime
+if not conf.CheckLib(['porttime', 'libporttime']):
+	print "Did not find PortTime or it\'s development headers, exiting!"
+	Exit(1)
+
+#Check for PortMIDI
+if not conf.CheckLib(['portmidi', 'libportmidi']):
+	print "Did not find PortMidi or it\'s development headers, exiting!"
+	Exit(1)
+
+sources += Split("""midi/mididevice.cpp """);
+sources += Split("""midi/mididevicemanager.cpp """);
+sources += Split("""midi/midideviceportmidi.cpp """);
+env.Append(CPPDEFINES = '__PORTMIDI__')
 
 #Platform-specific checks for Linux...
 if platform == 'linux':
@@ -611,7 +598,6 @@
 		debug=False,
 		)
 
-
 	#Check for libasound (libasound2?) (needed for ALSA seq MIDI support)
 	if not conf.CheckLib('asound') and not conf.CheckForPKG('alsa', '1.0.10'):
 		print "Did not find libasound (aka. libasound2), exiting!"
@@ -1092,7 +1078,7 @@
 	print "MIDI Scripting... enabled"
 
 	build_flags += 'midiscript '
-	sources += Split("""script/midiscriptengine.cpp""")
+	sources += Split("""midi/midiscriptengine.cpp""")
 	env.Append(CPPPATH = '$QTDIR/include/QtScript')
 	env.Append(CPPDEFINES = '__MIDISCRIPT__')
 else:
@@ -1215,18 +1201,6 @@
 	env.Append(CPPDEFINES = 'QT_NO_DEBUG_OUTPUT')
 	print "Debugging message output... disabled"
 
-#ALSA API selection
-if platform == 'linux':
-	flags_rawmidi = getFlags(env, 'rawmidi', 0)
-	if int(flags_rawmidi):
-		build_flags += 'rawmidi '
-		sources += Split("""midiobjectalsa.cpp """)  #ALSA RawMIDI support for Linux
-		env.Append(CXXFLAGS = '-D__ALSAMIDI__')
-		print "ALSA API... RawMIDI"
-	else:
-		sources += Split("""midiobjectalsaseq.cpp """)  #ALSA Sequencer MIDI support for Linux
-		env.Append(CXXFLAGS = '-D__ALSASEQMIDI__')
-		print "ALSA API... Sequencer"
 
 #Visual Studio 2005 hacks (MSVS Express Edition users shouldn't enable this)
 flags_msvshacks = getFlags(env, 'msvshacks', 0)

=== modified file 'mixxx/src/controlbeat.h'
--- mixxx/src/controlbeat.h	2005-03-02 14:02:29 +0000
+++ mixxx/src/controlbeat.h	2009-11-10 00:33:16 +0000
@@ -20,6 +20,8 @@
 
 #include "controlobject.h"
 #include "configobject.h"
+#include "defs.h"
+#include "midi/midimessage.h"
 #include <qdatetime.h>
 
 /**

=== modified file 'mixxx/src/controlgroupdelegate.cpp'
--- mixxx/src/controlgroupdelegate.cpp	2009-03-19 17:17:16 +0000
+++ mixxx/src/controlgroupdelegate.cpp	2009-11-10 00:33:16 +0000
@@ -8,7 +8,7 @@
 #include <QtCore>
 #include <QtGui>
 #include "configobject.h"
-#include "midiinputmappingtablemodel.h" //Need this to know MIDIINPUTTABLEINDEX_CONTROLOBJECTVALUE
+#include "midi/midiinputmappingtablemodel.h" //Need this to know MIDIINPUTTABLEINDEX_CONTROLOBJECTVALUE
 #include "controlvaluedelegate.h"
 #include "controlgroupdelegate.h"
 

=== modified file 'mixxx/src/controllogpotmeter.cpp'
--- mixxx/src/controllogpotmeter.cpp	2008-03-27 05:04:43 +0000
+++ mixxx/src/controllogpotmeter.cpp	2009-11-10 00:33:17 +0000
@@ -15,6 +15,7 @@
 *                                                                         *
 ***************************************************************************/
 
+#include <math.h>
 #include "controllogpotmeter.h"
 
 /* -------- ------------------------------------------------------

=== modified file 'mixxx/src/controlobject.h'
--- mixxx/src/controlobject.h	2009-07-17 05:06:48 +0000
+++ mixxx/src/controlobject.h	2009-11-10 00:33:17 +0000
@@ -24,8 +24,8 @@
 //#include <qaccel.h>
 #include <q3ptrqueue.h>
 #include <QMutex>
+#include "midi/midimessage.h"
 #include "configobject.h"
-#include "midiobject.h"
 #include "controlobjectthread.h"
 
 class QWidget;
@@ -73,8 +73,8 @@
     static ControlObject *getControl(ConfigKey key);
     /** Used to add a pointer to the corresponding ControlObjectThread of this ControlObject */
     void addProxy(ControlObjectThread *pControlObjectThread);
-	// To get rid of a proxy when the corresponding object is being deleted for example
-	void removeProxy(ControlObjectThread *pControlObjectThread);
+    // To get rid of a proxy when the corresponding object is being deleted for example
+    void removeProxy(ControlObjectThread *pControlObjectThread);
     /** Update proxies, execep the one given a pointer to. Returns true if all updates
       * happend, otherwise false. */
     bool updateProxies(ControlObjectThread *pProxyNoUpdate=0);

=== modified file 'mixxx/src/controlvaluedelegate.cpp'
--- mixxx/src/controlvaluedelegate.cpp	2009-04-30 12:54:20 +0000
+++ mixxx/src/controlvaluedelegate.cpp	2009-11-10 00:33:17 +0000
@@ -10,7 +10,7 @@
 #include "configobject.h"
 #include "controlgroupdelegate.h" //Need to get CONTROLGROUP_CHANNEL1_STRING, etc.
 #include "controlvaluedelegate.h"
-#include "midiinputmappingtablemodel.h" //Need this to know MIDIINPUTTABLEINDEX_CONTROLOBJECTGROUP
+#include "midi/midiinputmappingtablemodel.h" //Need this to know MIDIINPUTTABLEINDEX_CONTROLOBJECTGROUP
 
 //Static var declarations 
 QStringList ControlValueDelegate::m_channelControlValues;

=== modified file 'mixxx/src/defs.h'
--- mixxx/src/defs.h	2009-11-10 00:33:14 +0000
+++ mixxx/src/defs.h	2009-11-10 00:33:17 +0000
@@ -17,11 +17,8 @@
 #ifndef DEFS_H
 #define DEFS_H
 
-<<<<<<< TREE
-#define VERSION "Trunk"
-=======
 // Version number moved to defs_version.h to avoid lots of rebuilding
->>>>>>> MERGE-SOURCE
+
 #define MIXXX_PROMO_DIR "promo"
 
 #include <math.h>

=== modified file 'mixxx/src/dlgmidilearning.cpp'
--- mixxx/src/dlgmidilearning.cpp	2009-03-12 22:35:33 +0000
+++ mixxx/src/dlgmidilearning.cpp	2009-11-10 00:33:17 +0000
@@ -17,8 +17,8 @@
 
 #include "dlgmidilearning.h"
 #include "mixxxcontrol.h"
-#include "midimessage.h"
-#include "midimapping.h"
+#include "midi/midimessage.h"
+#include "midi/midimapping.h"
 
 DlgMidiLearning::DlgMidiLearning(QWidget * parent, MidiMapping* mapping) :  QDialog(parent), Ui::DlgMidiLearning()
 {

=== modified file 'mixxx/src/dlgmidilearning.h'
--- mixxx/src/dlgmidilearning.h	2009-03-12 22:35:33 +0000
+++ mixxx/src/dlgmidilearning.h	2009-11-10 00:33:17 +0000
@@ -23,7 +23,7 @@
 #include "ui_dlgmidilearning.h"
 #include "configobject.h"
 #include "mixxxcontrol.h"
-#include "midimessage.h"
+#include "midi/midimessage.h"
 
 class MidiMapping;
 

=== modified file 'mixxx/src/dlgpreferences.cpp'
--- mixxx/src/dlgpreferences.cpp	2009-04-12 19:17:15 +0000
+++ mixxx/src/dlgpreferences.cpp	2009-11-10 00:33:17 +0000
@@ -36,7 +36,8 @@
 #include "dlgprefrecord.h"
 #include "mixxx.h"
 #include "track.h"
-#include "midiobject.h"
+#include "midi/mididevicemanager.h"
+#include "midi/mididevice.h"
 #include <QTabWidget>
 
 #include <QTabBar>
@@ -46,10 +47,10 @@
 
 DlgPreferences::DlgPreferences(MixxxApp * mixxx, MixxxView * view,
                                SoundManager * soundman, Track *track,
-                               MidiObject * midi, ConfigObject<ConfigValue> * _config) :  QDialog(), Ui::DlgPreferencesDlg()
+                               MidiDeviceManager * midi, ConfigObject<ConfigValue> * _config) :  QDialog(), Ui::DlgPreferencesDlg()
 {
     m_pMixxx = mixxx;
-    m_pMidiObject = midi;
+    m_pMidiDeviceManager = midi;
 
     setupUi(this);
 #if QT_VERSION >= 0x040400 //setHeaderHidden is a qt4.4 addition so having it in the .ui file breaks the build on OpenBSD4.4 (FIXME: revisit this when OpenBSD4.5 comes out?)
@@ -108,7 +109,7 @@
     // Connections
     connect(this, SIGNAL(showDlg()), this,      SLOT(slotShow()));
     connect(this, SIGNAL(closeDlg()), this,      SLOT(slotHide()));
-    connect(m_pMidiObject, SIGNAL(devicesChanged()), this, SLOT(rescanMidi()));
+    connect(m_pMidiDeviceManager, SIGNAL(devicesChanged()), this, SLOT(rescanMidi()));
 
     connect(this, SIGNAL(showDlg()), wsound,    SLOT(slotUpdate()));
     connect(this, SIGNAL(showDlg()), wplaylist, SLOT(slotUpdate()));
@@ -158,7 +159,7 @@
 }
 
 void DlgPreferences::createIcons()
-{	
+{    
     m_pSoundButton = new QTreeWidgetItem(contentsTreeWidget, QTreeWidgetItem::Type);
     m_pSoundButton->setIcon(0, QIcon(":/images/preferences/soundhardware.png"));
     m_pSoundButton->setText(0, tr("Sound Hardware"));
@@ -191,7 +192,7 @@
     m_pPlaylistButton->setTextAlignment(0, Qt::AlignLeft | Qt::AlignVCenter);
     m_pPlaylistButton->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 
-   	m_pControlsButton = new QTreeWidgetItem(contentsTreeWidget, QTreeWidgetItem::Type);
+       m_pControlsButton = new QTreeWidgetItem(contentsTreeWidget, QTreeWidgetItem::Type);
     m_pControlsButton->setIcon(0, QIcon(":/images/preferences/interface.png"));
     m_pControlsButton->setText(0, tr("Interface"));
     m_pControlsButton->setTextAlignment(0, Qt::AlignLeft | Qt::AlignVCenter);
@@ -248,66 +249,66 @@
     if (!current)
         current = previous;
 
-	if (current == m_pSoundButton)
-   		pagesWidget->setCurrentWidget(wsound);
-   	else if (current == m_pPlaylistButton)
-   		pagesWidget->setCurrentWidget(wplaylist);
-   	else if (current == m_pControlsButton)
-   		pagesWidget->setCurrentWidget(wcontrols);
-   	else if (current == m_pEqButton)
-   		pagesWidget->setCurrentWidget(weq);
-   	else if (current == m_pCrossfaderButton)
-   		pagesWidget->setCurrentWidget(wcrossfader);
-   	else if (current == m_pRecordingButton)
-   		pagesWidget->setCurrentWidget(wrecord);
-   	else if (current == m_pBPMdetectButton)
-   		pagesWidget->setCurrentWidget(wbpm);
+    if (current == m_pSoundButton)
+           pagesWidget->setCurrentWidget(wsound);
+       else if (current == m_pPlaylistButton)
+           pagesWidget->setCurrentWidget(wplaylist);
+       else if (current == m_pControlsButton)
+           pagesWidget->setCurrentWidget(wcontrols);
+       else if (current == m_pEqButton)
+           pagesWidget->setCurrentWidget(weq);
+       else if (current == m_pCrossfaderButton)
+           pagesWidget->setCurrentWidget(wcrossfader);
+       else if (current == m_pRecordingButton)
+           pagesWidget->setCurrentWidget(wrecord);
+       else if (current == m_pBPMdetectButton)
+           pagesWidget->setCurrentWidget(wbpm);
 #ifdef __VINYLCONTROL__
-   	else if (current == m_pVinylControlButton)
-   		pagesWidget->setCurrentWidget(wvinylcontrol);
+       else if (current == m_pVinylControlButton)
+           pagesWidget->setCurrentWidget(wvinylcontrol);
 #endif
 #ifdef __SHOUTCAST__
-   	else if (current == m_pShoutcastButton)
-   		pagesWidget->setCurrentWidget(wshoutcast);
+       else if (current == m_pShoutcastButton)
+           pagesWidget->setCurrentWidget(wshoutcast);
 #endif
 
-   	//Handle selection of midi device items
-   	else if (m_midiBindingsButtons.indexOf(current) >= 0)
-   	{
-   		int index = m_midiBindingsButtons.indexOf(current);
-   		pagesWidget->setCurrentWidget(wmidiBindingsForDevice.value(index));
-   		//Manually fire this slot since it doesn't work right...
-   		wmidiBindingsForDevice.value(index)->slotUpdate();
-   	}
-   	
-   	//If the root "MIDI Device" item is clicked, select the first MIDI device instead.
-   	//If there is no first MIDI device, display a page that says so (just so we don't not change the page)
-   	else if (current == m_pMIDITreeItem)
-   	{
-   		if (wmidiBindingsForDevice.count() > 0)
-   		{
-   			//Expand the MIDI subtree
-   			contentsTreeWidget->setItemExpanded(m_pMIDITreeItem, true);
-   			
-   			/*
-   			* FIXME: None of the following works right, for some reason. - Albert Feb 9/09 
-   			*/
-   			
-   			//Select the first MIDI device
-   			//contentsTreeWidget->setItemSelected(m_pMIDITreeItem, false);
-   			/*
-   			foreach(QTreeWidgetItem* item, contentsTreeWidget->selectedItems())
-   			{
-   				contentsTreeWidget->setItemSelected(item, false);
-   			}*/
-   			//contentsTreeWidget->setItemSelected(m_midiBindingsButtons.value(0), true);
-   			
-   		}
-   		else
-   		{
-   			pagesWidget->setCurrentWidget(wNoMidi);
-   		}
-   	}
+       //Handle selection of midi device items
+       else if (m_midiBindingsButtons.indexOf(current) >= 0)
+       {
+           int index = m_midiBindingsButtons.indexOf(current);
+           pagesWidget->setCurrentWidget(wmidiBindingsForDevice.value(index));
+           //Manually fire this slot since it doesn't work right...
+           wmidiBindingsForDevice.value(index)->slotUpdate();
+       }
+       
+       //If the root "MIDI Device" item is clicked, select the first MIDI device instead.
+       //If there is no first MIDI device, display a page that says so (just so we don't not change the page)
+       else if (current == m_pMIDITreeItem)
+       {
+           if (wmidiBindingsForDevice.count() > 0)
+           {
+               //Expand the MIDI subtree
+               contentsTreeWidget->setItemExpanded(m_pMIDITreeItem, true);
+               
+               /*
+               * FIXME: None of the following works right, for some reason. - Albert Feb 9/09 
+               */
+               
+               //Select the first MIDI device
+               //contentsTreeWidget->setItemSelected(m_pMIDITreeItem, false);
+               /*
+               foreach(QTreeWidgetItem* item, contentsTreeWidget->selectedItems())
+               {
+                   contentsTreeWidget->setItemSelected(item, false);
+               }*/
+               //contentsTreeWidget->setItemSelected(m_midiBindingsButtons.value(0), true);
+               
+           }
+           else
+           {
+               pagesWidget->setCurrentWidget(wNoMidi);
+           }
+       }
    
 }
 
@@ -315,7 +316,7 @@
 {
 #ifdef __VINYLCONTROL__
     pagesWidget->setCurrentWidget(wvinylcontrol);
-	contentsTreeWidget->setCurrentItem(m_pVinylControlButton);
+    contentsTreeWidget->setCurrentItem(m_pVinylControlButton);
 #endif
 }
 
@@ -372,34 +373,50 @@
 
 void DlgPreferences::setupMidiWidgets()
 {
-
-	//TODO: For each MIDI device, create a MIDI dialog and put a little link to it in the treepane on the left
-	QList<QString>* deviceList = m_pMidiObject->getDeviceList();
-	QListIterator<QString> it(*deviceList);
-	
-	while (it.hasNext())
-	  {
-	    QString curDeviceName = QString(it.next()); //make a copy of it.next() so that the original list getting freed doesn't kill us
-	    //qDebug() << "curDeviceName: " << curDeviceName;
-	    DlgPrefMidiBindings* midiDlg = new DlgPrefMidiBindings(this, *m_pMidiObject, curDeviceName, config);
-	    wmidiBindingsForDevice.append(midiDlg);
-	    pagesWidget->addWidget(midiDlg);
-	    connect(this, SIGNAL(showDlg()), midiDlg, SLOT(slotUpdate()));
-	    connect(buttonBox, SIGNAL(accepted()), midiDlg, SLOT(slotApply()));
-	    
-	    QTreeWidgetItem * midiBindingsButton = new QTreeWidgetItem(QTreeWidgetItem::Type);
-	    //qDebug() << curDeviceName << " QTreeWidgetItem point is " << midiBindingsButton;
-	    midiBindingsButton->setIcon(0, QIcon(":/images/preferences/controllers.png"));
-	    midiBindingsButton->setText(0, curDeviceName);
-	    midiBindingsButton->setTextAlignment(0, Qt::AlignLeft | Qt::AlignVCenter);
-	    midiBindingsButton->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-	    m_pMIDITreeItem->addChild(midiBindingsButton);
-	    m_midiBindingsButtons.append(midiBindingsButton);	    
-	  }
+    //For each MIDI device, create a MIDI dialog and put a little link to it in the treepane on the left
+    QList<MidiDevice*> deviceList = m_pMidiDeviceManager->getDeviceList(false, true);
+    QListIterator<MidiDevice*> it(deviceList);
+    
+    while (it.hasNext())
+      {
+        MidiDevice* currentDevice = it.next();
+        QString curDeviceName = currentDevice->getName();
+        //qDebug() << "curDeviceName: " << curDeviceName;
+        DlgPrefMidiBindings* midiDlg = new DlgPrefMidiBindings(this, currentDevice, m_pMidiDeviceManager, config);
+        wmidiBindingsForDevice.append(midiDlg);
+        pagesWidget->addWidget(midiDlg);
+        connect(this, SIGNAL(showDlg()), midiDlg, SLOT(slotUpdate()));
+        connect(buttonBox, SIGNAL(accepted()), midiDlg, SLOT(slotApply()));
+        connect(midiDlg, SIGNAL(deviceStateChanged(DlgPrefMidiBindings*,bool)), this, SLOT(slotHighlightDevice(DlgPrefMidiBindings*,bool)));
+        
+        QTreeWidgetItem * midiBindingsButton = new QTreeWidgetItem(QTreeWidgetItem::Type);
+        //qDebug() << curDeviceName << " QTreeWidgetItem point is " << midiBindingsButton;
+        midiBindingsButton->setIcon(0, QIcon(":/images/preferences/controllers.png"));
+        midiBindingsButton->setText(0, curDeviceName);
+        midiBindingsButton->setTextAlignment(0, Qt::AlignLeft | Qt::AlignVCenter);
+        midiBindingsButton->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
+        m_pMIDITreeItem->addChild(midiBindingsButton);
+        m_midiBindingsButtons.append(midiBindingsButton);
+        
+        // Set the font correctly
+        QFont temp = midiBindingsButton->font(0);
+        if (currentDevice->isOpen()) temp.setBold(true);
+        else temp.setBold(false);
+        midiBindingsButton->setFont(0,temp);
+      }
 }
 
 void DlgPreferences::slotApply()
 {
+    m_pMidiDeviceManager->saveMappings();
 //    m_pMixxx->grabKeyboard();
 }
 
+void DlgPreferences::slotHighlightDevice(DlgPrefMidiBindings* dialog, bool enabled)
+{
+    QTreeWidgetItem * midiBindingsButton = m_midiBindingsButtons.at(wmidiBindingsForDevice.indexOf(dialog));
+    QFont temp = midiBindingsButton->font(0);
+    if (enabled) temp.setBold(true);
+    else temp.setBold(false);
+    midiBindingsButton->setFont(0,temp);
+}
\ No newline at end of file

=== modified file 'mixxx/src/dlgpreferences.h'
--- mixxx/src/dlgpreferences.h	2009-03-02 02:48:16 +0000
+++ mixxx/src/dlgpreferences.h	2009-11-10 00:33:17 +0000
@@ -46,7 +46,7 @@
 class DlgPrefVinyl;
 class DlgPrefShoutcast;
 class PowerMate;
-class MidiObject;
+class MidiDeviceManager;
 
 /**
   *@author Tue & Ken Haste Andersen
@@ -57,7 +57,7 @@
     Q_OBJECT
 public:
     DlgPreferences(MixxxApp *mixxx, MixxxView *view, SoundManager *soundman,
-    		Track *track, MidiObject * midi, ConfigObject<ConfigValue> *config);
+    		Track *track, MidiDeviceManager* midi, ConfigObject<ConfigValue> *config);
     ~DlgPreferences();
     void createIcons();
 public slots:
@@ -67,6 +67,7 @@
     void slotApply();
     void changePage(QTreeWidgetItem *current, QTreeWidgetItem *previous);
     void showVinylControlPage();
+    void slotHighlightDevice(DlgPrefMidiBindings* dialog, bool enabled);
 signals:
     void closeDlg();
     void showDlg();
@@ -102,7 +103,7 @@
     ConfigObject<ConfigValue> *config;
     MixxxApp *m_pMixxx;
     Track* m_pTrack;
-    MidiObject* m_pMidiObject;
+    MidiDeviceManager* m_pMidiDeviceManager;
 };
 
 #endif

=== modified file 'mixxx/src/dlgprefmidibindings.cpp'
--- mixxx/src/dlgprefmidibindings.cpp	2009-04-30 20:27:18 +0000
+++ mixxx/src/dlgprefmidibindings.cpp	2009-11-10 00:33:17 +0000
@@ -16,45 +16,44 @@
  ***************************************************************************/
 #include <QtGui>
 #include <QDebug>
-#include "midiinputmappingtablemodel.h"
-#include "midioutputmappingtablemodel.h"
-#include "midichanneldelegate.h"
-#include "midistatusdelegate.h"
-#include "midinodelegate.h"
-#include "midioptiondelegate.h"
+#include "midi/midiinputmappingtablemodel.h"
+#include "midi/midioutputmappingtablemodel.h"
+#include "midi/midichanneldelegate.h"
+#include "midi/midistatusdelegate.h"
+#include "midi/midinodelegate.h"
+#include "midi/midioptiondelegate.h"
 #include "controlgroupdelegate.h"
 #include "controlvaluedelegate.h"
 #include "dlgprefmidibindings.h"
+#include "midi/mididevice.h"
+#include "midi/mididevicemanager.h"
 #include "widget/wwidget.h"
 #include "configobject.h"
-#include "midimapping.h"
+#include "midi/midimapping.h"
 
 #ifdef __MIDISCRIPT__
-#include "script/midiscriptengine.h"
+#include "midi/midiscriptengine.h"
 #endif
 
-const QStringList options = (QStringList() << "Normal" << "Script-Binding" << "Invert" << "Rot64" << "Rot64Inv"
-        << "Rot64Fast" << "Diff" << "Button" << "Switch" << "HercJog"
-        << "Spread64" << "SelectKnob");
-
-QStringList controKeyOptionChoices;
-
-const QStringList outputTypeChoices = (QStringList() << "light");
-
-DlgPrefMidiBindings::DlgPrefMidiBindings(QWidget *parent, MidiObject &midi, QString deviceName,
-										 ConfigObject<ConfigValue> *pConfig) :
-							QWidget(parent), Ui::DlgPrefMidiBindingsDlg(), m_rMidi(midi) {
+
+#define MIXXX_TEXT_NO_OUTPUT_DEVICE tr("None")
+
+DlgPrefMidiBindings::DlgPrefMidiBindings(QWidget *parent, MidiDevice* midiDevice, 
+                                         MidiDeviceManager* midiDeviceManager,
+                                         ConfigObject<ConfigValue> *pConfig) :
+                            QWidget(parent), Ui::DlgPrefMidiBindingsDlg() {
     setupUi(this);
     m_pConfig = pConfig;
-    m_deviceName = deviceName;
+    m_pMidiDevice = midiDevice;
+    m_pMidiDeviceManager = midiDeviceManager;
 
     m_pDlgMidiLearning = NULL;
 
-    labelDeviceName->setText(m_deviceName);
+    labelDeviceName->setText(m_pMidiDevice->getName());
 
     //Tell the input mapping table widget which data model it should be viewing
     //(note that m_pInputMappingTableView is defined in the .ui file!)
-    m_pInputMappingTableView->setModel((QAbstractItemModel*)m_rMidi.getMidiMapping()->getMidiInputMappingTableModel());
+    m_pInputMappingTableView->setModel((QAbstractItemModel*)m_pMidiDevice->getMidiMapping()->getMidiInputMappingTableModel());
 
     m_pInputMappingTableView->setSelectionBehavior(QAbstractItemView::SelectRows);
     m_pInputMappingTableView->setSelectionMode(QAbstractItemView::ContiguousSelection); //The model won't like ExtendedSelection, probably.
@@ -84,7 +83,7 @@
     
     //Tell the output mapping table widget which data model it should be viewing 
     //(note that m_pOutputMappingTableView is defined in the .ui file!)
-    m_pOutputMappingTableView->setModel((QAbstractItemModel*)m_rMidi.getMidiMapping()->getMidiOutputMappingTableModel());
+    m_pOutputMappingTableView->setModel((QAbstractItemModel*)m_pMidiDevice->getMidiMapping()->getMidiOutputMappingTableModel());
     m_pOutputMappingTableView->setSelectionBehavior(QAbstractItemView::SelectRows);
     m_pOutputMappingTableView->setSelectionMode(QAbstractItemView::ContiguousSelection);
     m_pOutputMappingTableView->verticalHeader()->hide();
@@ -111,14 +110,15 @@
     connect(btnClearAllOutputBindings, SIGNAL(clicked()), this, SLOT(slotClearAllOutputBindings()));
     connect(btnRemoveOutputBinding, SIGNAL(clicked()), this, SLOT(slotRemoveOutputBinding()));
     connect(btnAddOutputBinding, SIGNAL(clicked()), this, SLOT(slotAddOutputBinding()));
-
-    //Connect the activate button. One day this will be replaced with an "Enabled" checkbox.
-    connect(btnActivateDevice, SIGNAL(clicked()), this, SLOT(slotEnableDevice()));
     
     connect(comboBoxPreset, SIGNAL(activated(const QString&)), this, SLOT(slotLoadMidiMapping(const QString&)));
     
     //Load the list of presets into the presets combobox.
     enumeratePresets();
+
+    //Initialize the output device combobox
+    enumerateOutputDevices();
+    
 }
 
 DlgPrefMidiBindings::~DlgPrefMidiBindings() {
@@ -130,6 +130,31 @@
     delete m_deleteMIDIInputRowAction;
 }
 
+void DlgPrefMidiBindings::enumerateOutputDevices()
+{
+    comboBoxOutputDevice->clear();
+    
+    comboBoxOutputDevice->addItem(MIXXX_TEXT_NO_OUTPUT_DEVICE);
+
+    //For each MIDI output device, insert an item into the output device combobox.
+    QList<MidiDevice*> deviceList = m_pMidiDeviceManager->getDeviceList(true, false);
+    QListIterator<MidiDevice*> it(deviceList);
+    
+    while (it.hasNext())
+      {
+        MidiDevice* currentDevice = it.next();
+        QString curDeviceName = currentDevice->getName();
+        //qDebug() << "curDeviceName: " << curDeviceName;
+        comboBoxOutputDevice->addItem(curDeviceName);
+      }    
+    
+    //Assume autopairing was done and let's just show the output device combobox with the name
+    //of the input device selected for now...
+    QString currentOutputMidiDeviceName = m_pMidiDevice->getName();
+    comboBoxOutputDevice->setCurrentIndex(comboBoxOutputDevice->findText(currentOutputMidiDeviceName));
+
+}
+
 void DlgPrefMidiBindings::enumeratePresets()
 {
     QList<QString> presetsList;
@@ -157,12 +182,6 @@
     comboBoxPreset->addItems(presetsList);
 }
 
-/* loadPreset(QString)
- * Asks MidiMapping to load a set of MIDI bindings from an XML file
- */
-void DlgPrefMidiBindings::loadPreset(QString path) {
-    m_rMidi.getMidiMapping()->loadPreset(path);
-}
 
 
 /* slotUpdate()
@@ -171,34 +190,47 @@
 void DlgPrefMidiBindings::slotUpdate() {
 
     //Check if the device that this dialog is for is already enabled...
-    if (m_rMidi.getOpenDevice() == m_deviceName)
+    if (m_pMidiDevice->isOpen())
     {
-        btnActivateDevice->setEnabled(false); //Disable activate button
+        chkEnabledDevice->setCheckState(Qt::Checked); //Check the "Enabled" box
         toolBox->setEnabled(true); //Enable MIDI in/out toolbox.
         groupBoxPresets->setEnabled(true); //Enable presets group box.
     }
     else {
-        btnActivateDevice->setEnabled(true); //Enable activate button
+        chkEnabledDevice->setCheckState(Qt::Unchecked); //Uncheck the "Enabled" box
         toolBox->setEnabled(false); //Disable MIDI in/out toolbox.
         groupBoxPresets->setEnabled(false); //Disable presets group box.
     }
+    
+    //Connect the "Enabled" checkbox after the checkbox state is set
+    connect(chkEnabledDevice, SIGNAL(stateChanged(int)), this, SLOT(slotDeviceState(int)));
 }
 
 /* slotApply()
  * Called when the OK button is pressed.
  */
 void DlgPrefMidiBindings::slotApply() {
-    /* User has pressed OK, so write the controls to the DOM, reload the MIDI
-     * bindings, and save the default XML file. */
-    m_rMidi.getMidiMapping()->savePreset();   // use default bindings path
-    m_rMidi.getMidiMapping()->applyPreset();
-    m_rMidi.disableMidiLearn();
+    /* User has pressed OK, so enable or disable the device, write the controls to the DOM, and reload the MIDI
+     * bindings. */
+    m_pMidiDevice->disableMidiLearn();
+    if (chkEnabledDevice->isChecked()) {
+        enableDevice();
+        m_pMidiDevice->getMidiMapping()->applyPreset();
+    
+        //FIXME: We need some logic like this to make changing the output device work. 
+        //       See MidiDeviceManager::associateInputAndOutputDevices() for more info...
+        /*
+        if (comboBoxOutputDevice->currentText() != MIXXX_TEXT_NO_OUTPUT_DEVICE)
+            m_pMidiDeviceManager->associateInputAndOutputDevices(m_pMidiDevice, comboBoxOutputDevice->currentText());
+        */
+    }
+    else disableDevice();
 }
 
 void DlgPrefMidiBindings::slotShowMidiLearnDialog() {
     //Note that DlgMidiLearning is set to delete itself on
     //close using the Qt::WA_DeleteOnClose attribute (so this "new" doesn't leak memory)
-    m_pDlgMidiLearning = new DlgMidiLearning(this, m_rMidi.getMidiMapping());
+    m_pDlgMidiLearning = new DlgMidiLearning(this, m_pMidiDevice->getMidiMapping());
     m_pDlgMidiLearning->show();
 }
 
@@ -211,7 +243,7 @@
         return;
     
     //Ask for confirmation if the MIDI tables aren't empty...
-    MidiMapping* mapping = m_rMidi.getMidiMapping();
+    MidiMapping* mapping = m_pMidiDevice->getMidiMapping();
     if (mapping->numInputMidiMessages() > 0 ||
         mapping->numOutputMixxxControls() > 0)
     {
@@ -220,19 +252,16 @@
                 tr("Are you sure you'd like to load the " + name + " mapping?\n"
                    "This will overwrite your existing MIDI mapping."),  
                    QMessageBox::Yes | QMessageBox::No);
-                              
+
          if (result == QMessageBox::No) {
             //Select the "..." item again in the combobox.
             comboBoxPreset->setCurrentIndex(0);
-            return;                     
+            return;
          }
     }
     
     QString filename = m_pConfig->getConfigPath().append("midi/") + name + MIDI_MAPPING_EXTENSION;
-    if (!filename.isNull()) {
-        loadPreset(filename);
-        m_rMidi.getMidiMapping()->applyPreset();
-    }
+    if (!filename.isNull()) m_pMidiDevice->getMidiMapping()->loadPreset(filename, true);    // It's applied on prefs close
     m_pInputMappingTableView->update();
     
     //Select the "..." item again in the combobox.
@@ -246,20 +275,37 @@
     QString fileName = QFileDialog::getSaveFileName(this,
             "Export Mixxx MIDI Bindings", m_pConfig->getConfigPath().append("midi/"),
             "Preset Files (*.midi.xml)");
-    if (!fileName.isNull()) m_rMidi.getMidiMapping()->savePreset(fileName);
-}
-
-void DlgPrefMidiBindings::slotEnableDevice()
-{
-	//Just tell MidiObject to close the old device and open this device
-	m_rMidi.devClose();
-	m_rMidi.devOpen(m_deviceName);
-	m_pConfig->set(ConfigKey("[Midi]","Device"), m_deviceName);
-	btnActivateDevice->setEnabled(false);
-	toolBox->setEnabled(true); //Enable MIDI in/out toolbox.
-	groupBoxPresets->setEnabled(true); //Enable presets group box.
-	
-	//TODO: Should probably check if devOpen() actually succeeded.
+    if (!fileName.isNull()) m_pMidiDevice->getMidiMapping()->savePreset(fileName);
+}
+
+void DlgPrefMidiBindings::slotDeviceState(int state) {
+  if (state == Qt::Checked) {
+      toolBox->setEnabled(true);    //Enable MIDI in/out toolbox.
+      groupBoxPresets->setEnabled(true);    //Enable presets group box.
+      emit deviceStateChanged(this,true);  // Set tree item text to bold
+  }
+  else {
+      toolBox->setEnabled(false);   //Disable MIDI in/out toolbox.
+      groupBoxPresets->setEnabled(false);   //Disable presets group box.
+      emit deviceStateChanged(this,false);  // Set tree item text to not bold
+  }
+}
+
+void DlgPrefMidiBindings::enableDevice()
+{
+    m_pMidiDevice->close();
+    m_pMidiDevice->open();
+    m_pConfig->set(ConfigKey("[Midi]", m_pMidiDevice->getName().replace(" ", "_")), 1);
+ 
+    //TODO: Should probably check if open() actually succeeded.
+}
+
+void DlgPrefMidiBindings::disableDevice()
+{
+    m_pMidiDevice->close();
+    m_pConfig->set(ConfigKey("[Midi]", m_pMidiDevice->getName().replace(" ", "_")), 0);
+    
+    //TODO: Should probably check if close() actually succeeded.
 }
 
 void DlgPrefMidiBindings::slotAddInputBinding() 
@@ -296,40 +342,40 @@
     MixxxControl mixxxControl(controlGroup, controlValue);
     MidiMessage message;
 
-    while (m_rMidi.getMidiMapping()->isMidiMessageMapped(message))
+    while (m_pMidiDevice->getMidiMapping()->isMidiMessageMapped(message))
     {
         message.setMidiNo(message.getMidiNo() + 1);
         if (message.getMidiNo() >= 127) //If the table is full, then overwrite something... 
             break;
     }
-    m_rMidi.getMidiMapping()->setInputMidiMapping(message, mixxxControl);
+    m_pMidiDevice->getMidiMapping()->setInputMidiMapping(message, mixxxControl);
 }
 
 void DlgPrefMidiBindings::slotRemoveInputBinding()
 {
-	QModelIndexList selectedIndices = m_pInputMappingTableView->selectionModel()->selectedRows();
-	if (selectedIndices.size() > 0)
-	{
-		MidiInputMappingTableModel* tableModel = dynamic_cast<MidiInputMappingTableModel*>(m_pInputMappingTableView->model());
-		if (tableModel) {
-		
-			QModelIndex curIndex;
-			//The model indices are sorted so that we remove the rows from the table
+    QModelIndexList selectedIndices = m_pInputMappingTableView->selectionModel()->selectedRows();
+    if (selectedIndices.size() > 0)
+    {
+        MidiInputMappingTableModel* tableModel = dynamic_cast<MidiInputMappingTableModel*>(m_pInputMappingTableView->model());
+        if (tableModel) {
+        
+            QModelIndex curIndex;
+            //The model indices are sorted so that we remove the rows from the table
             //in ascending order. This is necessary because if row A is above row B in
             //the table, and you remove row A, the model index for row B will change.
             //Sorting the indices first means we don't have to worry about this.
             qSort(selectedIndices);
 
             //Going through the model indices in descending order (see above comment for explanation).
-			QListIterator<QModelIndex> it(selectedIndices);
-			it.toBack();
-			while (it.hasPrevious())
-			{
-				curIndex = it.previous();
-				tableModel->removeRow(curIndex.row());
-			}
-		}
-	}
+            QListIterator<QModelIndex> it(selectedIndices);
+            it.toBack();
+            while (it.hasPrevious())
+            {
+                curIndex = it.previous();
+                tableModel->removeRow(curIndex.row());
+            }
+        }
+    }
 }
 
 void DlgPrefMidiBindings::slotClearAllInputBindings() {
@@ -349,35 +395,35 @@
 void DlgPrefMidiBindings::slotAddOutputBinding() {
     qDebug() << "STUB: DlgPrefMidiBindings::slotAddOutputBinding()";
 
-    m_rMidi.getMidiMapping()->setOutputMidiMapping(MixxxControl(), MidiMessage());
+    m_pMidiDevice->getMidiMapping()->setOutputMidiMapping(MixxxControl(), MidiMessage());
 }
 
 void DlgPrefMidiBindings::slotRemoveOutputBinding()
 {
-	QModelIndexList selectedIndices = m_pOutputMappingTableView->selectionModel()->selectedRows();
-	if (selectedIndices.size() > 0)
-	{
-		MidiOutputMappingTableModel* tableModel =
-		                    dynamic_cast<MidiOutputMappingTableModel*>(m_pOutputMappingTableView->model());
-		if (tableModel) {
-			QModelIndex curIndex;
-			//The model indices are sorted so that we remove the rows from the table
+    QModelIndexList selectedIndices = m_pOutputMappingTableView->selectionModel()->selectedRows();
+    if (selectedIndices.size() > 0)
+    {
+        MidiOutputMappingTableModel* tableModel =
+                            dynamic_cast<MidiOutputMappingTableModel*>(m_pOutputMappingTableView->model());
+        if (tableModel) {
+            QModelIndex curIndex;
+            //The model indices are sorted so that we remove the rows from the table
             //in ascending order. This is necessary because if row A is above row B in
             //the table, and you remove row A, the model index for row B will change.
             //Sorting the indices first means we don't have to worry about this.
             //qSort(selectedIndices);
 
             //Going through the model indices in descending order (see above comment for explanation).
-			QListIterator<QModelIndex> it(selectedIndices);
-			it.toBack();
-			while (it.hasPrevious())
-			{
-				curIndex = it.previous();
-				qDebug() << "Dlg: removing row" << curIndex.row();
-				tableModel->removeRow(curIndex.row());
-			}
-		}
-	}
+            QListIterator<QModelIndex> it(selectedIndices);
+            it.toBack();
+            while (it.hasPrevious())
+            {
+                curIndex = it.previous();
+                qDebug() << "Dlg: removing row" << curIndex.row();
+                tableModel->removeRow(curIndex.row());
+            }
+        }
+    }
 }
 
 void DlgPrefMidiBindings::slotClearAllOutputBindings() {

=== modified file 'mixxx/src/dlgprefmidibindings.h'
--- mixxx/src/dlgprefmidibindings.h	2009-04-11 20:16:51 +0000
+++ mixxx/src/dlgprefmidibindings.h	2009-11-10 00:33:17 +0000
@@ -21,7 +21,6 @@
 #include "ui_dlgprefmidibindingsdlg.h"
 #include "dlgmidilearning.h"
 #include "configobject.h"
-#include "midiobject.h"
 
 //Forward declarations
 class MidiChannelDelegate;
@@ -30,11 +29,14 @@
 class MidiOptionDelegate;
 class ControlGroupDelegate;
 class ControlValueDelegate;
+class MidiDevice;
+class MidiDeviceManager;
 
 class DlgPrefMidiBindings : public QWidget, public Ui::DlgPrefMidiBindingsDlg  {
     Q_OBJECT
 public:
-    DlgPrefMidiBindings(QWidget *parent, MidiObject &midi, QString deviceName,
+    DlgPrefMidiBindings(QWidget *parent, MidiDevice* midiDevice,
+                        MidiDeviceManager* midiDeviceManager,
     					ConfigObject<ConfigValue> *pConfig);
     ~DlgPrefMidiBindings();
 
@@ -45,7 +47,7 @@
     void slotShowMidiLearnDialog();
     void slotLoadMidiMapping(const QString &name);
     void slotExportXML();
-    void slotEnableDevice();
+    void slotDeviceState(int state);
 
     //Input bindings
     void slotClearAllInputBindings();
@@ -56,15 +58,20 @@
     void slotAddOutputBinding();
     void slotClearAllOutputBindings();
     void slotRemoveOutputBinding();
+    
+signals:
+    void deviceStateChanged(DlgPrefMidiBindings*, bool);
 
 private:
     void setRowBackground(int row, QColor color);
-    void loadPreset(QString path);
     void savePreset(QString path);
     void enumeratePresets();
+    void enumerateOutputDevices();
 
+    void enableDevice();
+    void disableDevice();
+    
     int currentGroupRow;
-    MidiObject &m_rMidi;
     MidiChannelDelegate* m_pMidiChannelDelegate;
     MidiStatusDelegate* m_pMidiStatusDelegate;
     MidiNoDelegate* m_pMidiNoDelegate;
@@ -73,7 +80,8 @@
     ControlValueDelegate* m_pControlValueDelegate;
     QAction* m_deleteMIDIInputRowAction; /** Used for setting up the shortcut for delete button */
     ConfigObject<ConfigValue> *m_pConfig;
-    QString m_deviceName;
+    MidiDevice* m_pMidiDevice;
+    MidiDeviceManager* m_pMidiDeviceManager;
     DlgMidiLearning* m_pDlgMidiLearning;
 };
 

=== modified file 'mixxx/src/dlgprefmidibindingsdlg.ui'
--- mixxx/src/dlgprefmidibindingsdlg.ui	2009-04-11 21:29:07 +0000
+++ mixxx/src/dlgprefmidibindingsdlg.ui	2009-11-10 00:33:17 +0000
@@ -1,7 +1,8 @@
-<ui version="4.0" >
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
  <class>DlgPrefMidiBindingsDlg</class>
- <widget class="QWidget" name="DlgPrefMidiBindingsDlg" >
-  <property name="geometry" >
+ <widget class="QWidget" name="DlgPrefMidiBindingsDlg">
+  <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
@@ -9,30 +10,30 @@
     <height>436</height>
    </rect>
   </property>
-  <property name="windowTitle" >
+  <property name="windowTitle">
    <string>Dialog</string>
   </property>
-  <layout class="QGridLayout" name="gridLayout_4" >
-   <item row="0" column="0" >
-    <widget class="QLabel" name="labelDeviceName" >
-     <property name="font" >
+  <layout class="QGridLayout" name="gridLayout_4">
+   <item row="0" column="0">
+    <widget class="QLabel" name="labelDeviceName">
+     <property name="font">
       <font>
        <pointsize>14</pointsize>
        <weight>75</weight>
        <bold>true</bold>
       </font>
      </property>
-     <property name="text" >
+     <property name="text">
       <string>Your Device Name</string>
      </property>
     </widget>
    </item>
-   <item rowspan="2" row="0" column="1" >
-    <spacer name="horizontalSpacer" >
-     <property name="orientation" >
+   <item row="0" column="2" rowspan="2">
+    <spacer name="horizontalSpacer">
+     <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
-     <property name="sizeHint" stdset="0" >
+     <property name="sizeHint" stdset="0">
       <size>
        <width>115</width>
        <height>20</height>
@@ -40,136 +41,150 @@
      </property>
     </spacer>
    </item>
-   <item rowspan="2" row="0" column="2" >
-    <widget class="QGroupBox" name="groupBoxPresets" >
-     <property name="title" >
+   <item row="0" column="3" rowspan="2">
+    <widget class="QGroupBox" name="groupBoxPresets">
+     <property name="title">
       <string/>
      </property>
-     <property name="flat" >
+     <property name="flat">
       <bool>true</bool>
      </property>
-     <property name="checkable" >
+     <property name="checkable">
       <bool>false</bool>
      </property>
-     <layout class="QGridLayout" name="gridLayout" >
-      <item row="0" column="0" >
-       <widget class="QLabel" name="label" >
-        <property name="text" >
+     <layout class="QGridLayout" name="gridLayout">
+      <item row="1" column="1">
+       <widget class="QLabel" name="label">
+        <property name="text">
          <string>Load Preset:</string>
         </property>
-        <property name="alignment" >
+        <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
-      <item row="0" column="1" >
-       <widget class="QComboBox" name="comboBoxPreset" >
-        <property name="sizePolicy" >
-         <sizepolicy vsizetype="Fixed" hsizetype="Fixed" >
+      <item row="1" column="2">
+       <widget class="QComboBox" name="comboBoxPreset">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
        </widget>
       </item>
-      <item row="0" column="2" >
-       <widget class="QPushButton" name="btnExportXML" >
-        <property name="styleSheet" >
-         <string notr="true" />
+      <item row="1" column="3">
+       <widget class="QPushButton" name="btnExportXML">
+        <property name="styleSheet">
+         <string notr="true"/>
         </property>
-        <property name="text" >
+        <property name="text">
          <string>Export</string>
         </property>
        </widget>
       </item>
+      <item row="2" column="2">
+       <widget class="QComboBox" name="comboBoxOutputDevice">
+        <property name="enabled">
+         <bool>false</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QLabel" name="label_2">
+        <property name="text">
+         <string>Output:</string>
+        </property>
+       </widget>
+      </item>
      </layout>
     </widget>
    </item>
-   <item row="1" column="0" >
-    <widget class="QPushButton" name="btnActivateDevice" >
-     <property name="text" >
-      <string>Activate</string>
+   <item row="1" column="0">
+    <widget class="QCheckBox" name="chkEnabledDevice">
+     <property name="text">
+      <string>Enabled</string>
      </property>
     </widget>
    </item>
-   <item row="2" column="0" colspan="3" >
-    <widget class="QToolBox" name="toolBox" >
-     <property name="frameShape" >
+   <item row="2" column="0" colspan="4">
+    <widget class="QToolBox" name="toolBox">
+     <property name="frameShape">
       <enum>QFrame::NoFrame</enum>
      </property>
-     <property name="currentIndex" >
+     <property name="currentIndex">
       <number>0</number>
      </property>
-     <widget class="QWidget" name="page" >
-      <property name="geometry" >
+     <widget class="QWidget" name="page">
+      <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>580</width>
-        <height>287</height>
+        <height>252</height>
        </rect>
       </property>
-      <attribute name="label" >
+      <attribute name="label">
        <string>MIDI Input</string>
       </attribute>
-      <layout class="QGridLayout" name="gridLayout_2" >
-       <item row="1" column="0" colspan="2" >
-        <widget class="QTableView" name="m_pInputMappingTableView" />
+      <layout class="QGridLayout" name="gridLayout_2">
+       <item row="1" column="0" colspan="2">
+        <widget class="QTableView" name="m_pInputMappingTableView"/>
        </item>
-       <item row="2" column="0" colspan="2" >
-        <widget class="QGroupBox" name="groupBoxInputManagement" >
-         <property name="minimumSize" >
+       <item row="2" column="0" colspan="2">
+        <widget class="QGroupBox" name="groupBoxInputManagement">
+         <property name="minimumSize">
           <size>
            <width>300</width>
            <height>0</height>
           </size>
          </property>
-         <property name="title" >
+         <property name="title">
           <string>Controls</string>
          </property>
-         <layout class="QHBoxLayout" name="horizontalLayout_2" >
+         <layout class="QHBoxLayout" name="horizontalLayout_2">
           <item>
-           <widget class="QPushButton" name="btnAddInputBinding" >
-            <property name="styleSheet" >
-             <string notr="true" />
+           <widget class="QPushButton" name="btnAddInputBinding">
+            <property name="styleSheet">
+             <string notr="true"/>
             </property>
-            <property name="text" >
+            <property name="text">
              <string>Add</string>
             </property>
            </widget>
           </item>
           <item>
-           <widget class="QPushButton" name="btnRemoveInputBinding" >
-            <property name="styleSheet" >
-             <string notr="true" />
+           <widget class="QPushButton" name="btnRemoveInputBinding">
+            <property name="styleSheet">
+             <string notr="true"/>
             </property>
-            <property name="text" >
+            <property name="text">
              <string>Remove</string>
             </property>
            </widget>
           </item>
           <item>
-           <widget class="QPushButton" name="btnMidiLearnWizard" >
-            <property name="styleSheet" >
-             <string notr="true" />
+           <widget class="QPushButton" name="btnMidiLearnWizard">
+            <property name="styleSheet">
+             <string notr="true"/>
             </property>
-            <property name="text" >
+            <property name="text">
              <string>MIDI Learning Wizard</string>
             </property>
-            <property name="checkable" >
+            <property name="checkable">
              <bool>false</bool>
             </property>
-            <property name="checked" >
+            <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item>
-           <spacer name="horizontalSpacer_3" >
-            <property name="orientation" >
+           <spacer name="horizontalSpacer_3">
+            <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
-            <property name="sizeHint" stdset="0" >
+            <property name="sizeHint" stdset="0">
              <size>
               <width>219</width>
               <height>20</height>
@@ -178,14 +193,14 @@
            </spacer>
           </item>
           <item>
-           <widget class="QPushButton" name="btnClearAllInputBindings" >
-            <property name="autoFillBackground" >
+           <widget class="QPushButton" name="btnClearAllInputBindings">
+            <property name="autoFillBackground">
              <bool>false</bool>
             </property>
-            <property name="styleSheet" >
-             <string notr="true" />
+            <property name="styleSheet">
+             <string notr="true"/>
             </property>
-            <property name="text" >
+            <property name="text">
              <string>Clear All</string>
             </property>
            </widget>
@@ -195,55 +210,55 @@
        </item>
       </layout>
      </widget>
-     <widget class="QWidget" name="page_2" >
-      <property name="geometry" >
+     <widget class="QWidget" name="page_2">
+      <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
-        <width>580</width>
-        <height>287</height>
+        <width>317</width>
+        <height>174</height>
        </rect>
       </property>
-      <attribute name="label" >
+      <attribute name="label">
        <string>MIDI Output</string>
       </attribute>
-      <layout class="QGridLayout" name="gridLayout_3" >
-       <item row="0" column="0" >
-        <widget class="QTableView" name="m_pOutputMappingTableView" >
-         <property name="enabled" >
+      <layout class="QGridLayout" name="gridLayout_3">
+       <item row="0" column="0">
+        <widget class="QTableView" name="m_pOutputMappingTableView">
+         <property name="enabled">
           <bool>true</bool>
          </property>
         </widget>
        </item>
-       <item row="1" column="0" >
-        <widget class="QGroupBox" name="groupBoxOutputs" >
-         <property name="title" >
+       <item row="1" column="0">
+        <widget class="QGroupBox" name="groupBoxOutputs">
+         <property name="title">
           <string>Outputs</string>
          </property>
-         <layout class="QHBoxLayout" name="horizontalLayout" >
+         <layout class="QHBoxLayout" name="horizontalLayout">
           <item>
-           <widget class="QPushButton" name="btnAddOutputBinding" >
-            <property name="enabled" >
+           <widget class="QPushButton" name="btnAddOutputBinding">
+            <property name="enabled">
              <bool>false</bool>
             </property>
-            <property name="text" >
+            <property name="text">
              <string>Add</string>
             </property>
            </widget>
           </item>
           <item>
-           <widget class="QPushButton" name="btnRemoveOutputBinding" >
-            <property name="text" >
+           <widget class="QPushButton" name="btnRemoveOutputBinding">
+            <property name="text">
              <string>Remove</string>
             </property>
            </widget>
           </item>
           <item>
-           <spacer name="horizontalSpacer_2" >
-            <property name="orientation" >
+           <spacer name="horizontalSpacer_2">
+            <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
-            <property name="sizeHint" stdset="0" >
+            <property name="sizeHint" stdset="0">
              <size>
               <width>219</width>
               <height>20</height>
@@ -252,8 +267,8 @@
            </spacer>
           </item>
           <item>
-           <widget class="QPushButton" name="btnClearAllOutputBindings" >
-            <property name="text" >
+           <widget class="QPushButton" name="btnClearAllOutputBindings">
+            <property name="text">
              <string>Clear All</string>
             </property>
            </widget>

=== modified file 'mixxx/src/engine/enginesidechain.h'
--- mixxx/src/engine/enginesidechain.h	2009-01-24 04:39:32 +0000
+++ mixxx/src/engine/enginesidechain.h	2009-11-10 00:33:17 +0000
@@ -17,6 +17,7 @@
 #ifndef ENGINESIDECHAIN_H
 #define ENGINESIDECHAIN_H
 
+#include <QtCore>
 #include "defs.h"
 #include "configobject.h"
 #include "controlobject.h"

=== modified file 'mixxx/src/input.cpp'
--- mixxx/src/input.cpp	2009-02-10 23:42:19 +0000
+++ mixxx/src/input.cpp	2009-11-10 00:33:17 +0000
@@ -20,7 +20,6 @@
 #include "controlobject.h"
 #include "controlobjectthreadmain.h"
 #include "controlobjectthread.h"
-#include "midiobject.h"
 #include "mathstuff.h"
 
 // TODO: Investigate the use of ControlObjectThread vs. ControlObjectThreadMain

=== added directory 'mixxx/src/midi'
=== renamed file 'mixxx/src/midichanneldelegate.cpp' => 'mixxx/src/midi/midichanneldelegate.cpp'
=== renamed file 'mixxx/src/midichanneldelegate.h' => 'mixxx/src/midi/midichanneldelegate.h'
=== added file 'mixxx/src/midi/mididevice.cpp'
--- mixxx/src/midi/mididevice.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/midi/mididevice.cpp	2009-11-10 00:33:17 +0000
@@ -0,0 +1,201 @@
+/***************************************************************************
+                             mididevice.cpp
+                           MIDI Device Class
+                           -------------------
+    begin                : Thu Dec 18 2008
+    copyright            : (C) 2008 Albert Santoni
+    email                : [e-mail]
+
+***************************************************************************/
+
+/***************************************************************************
+*                                                                         *
+*   This program is free software; you can redistribute it and/or modify  *
+*   it under the terms of the GNU General Public License as published by  *
+*   the Free Software Foundation; either version 2 of the License, or     *
+*   (at your option) any later version.                                   *
+*                                                                         *
+***************************************************************************/
+
+#include <qapplication.h>   // For command line arguments
+#include "mididevice.h"
+#include "midimapping.h"
+#include "midimessage.h"
+#include "mixxxcontrol.h"
+#include "controlobject.h"
+
+#ifdef __MIDISCRIPT__
+#include "midiscriptengine.h"
+#endif
+
+static QString toHex(QString numberStr) {
+    return "0x" + QString("0" + QString::number(numberStr.toUShort(), 16).toUpper()).right(2);
+}
+
+MidiDevice::MidiDevice(MidiMapping* mapping) : QObject()
+{
+    m_bIsOutputDevice = false;
+    m_bIsInputDevice = false;
+    m_pMidiMapping = mapping;
+    m_pCorrespondingOutputDevice = NULL;
+    m_bIsOpen = false;
+    m_bMidiLearn = false;
+
+    if (m_pMidiMapping == NULL) {
+        m_pMidiMapping = new MidiMapping(this);
+        m_pMidiMapping->setName(m_strDeviceName);
+    }
+        
+    // Get --midiDebug command line option
+    QStringList commandLineArgs = QApplication::arguments();
+    m_midiDebug = commandLineArgs.indexOf("--midiDebug");
+    
+    connect(m_pMidiMapping, SIGNAL(midiLearningStarted()), this, SLOT(enableMidiLearn()));
+    connect(m_pMidiMapping, SIGNAL(midiLearningFinished()), this, SLOT(disableMidiLearn()));
+    
+}
+
+MidiDevice::~MidiDevice()
+{
+    qDebug() << "MidiDevice: Deleting MidiMapping...";
+    delete m_pMidiMapping;
+
+}
+
+void MidiDevice::startup()
+{
+#ifdef __MIDISCRIPT__
+    m_pMidiMapping->startupScriptEngine();
+#endif
+}
+
+void MidiDevice::shutdown()
+{
+#ifdef __MIDISCRIPT__
+    m_pMidiMapping->shutdownScriptEngine();
+#endif
+}
+
+void MidiDevice::setMidiMapping(MidiMapping* mapping)
+{
+    m_pMidiMapping = mapping;
+    
+    if (m_pCorrespondingOutputDevice)
+    {
+        m_pCorrespondingOutputDevice->setMidiMapping(m_pMidiMapping);
+    }
+}
+
+void MidiDevice::sendShortMsg(unsigned char status, unsigned char byte1, unsigned char byte2) {
+    unsigned int word = (((unsigned int)byte2) << 16) |
+                        (((unsigned int)byte1) << 8) | status;
+    sendShortMsg(word);
+}
+
+void MidiDevice::sendShortMsg(unsigned int word) {
+    qDebug() << "MIDI short message sending not yet implemented for this API or platform";
+}
+
+void MidiDevice::sendSysexMsg(QList<int> data, unsigned int length) {
+    unsigned char * sysexMsg;
+    sysexMsg = new unsigned char [length];
+
+    for (unsigned int i=0; i<length; i++) {
+        sysexMsg[i] = data.at(i);
+//         qDebug() << "sysexMsg" << i << "=" << sysexMsg[i] << ", data=" << data.at(i);
+    }
+
+    sendSysexMsg(sysexMsg,length);
+    delete[] sysexMsg;
+}
+
+void MidiDevice::sendSysexMsg(unsigned char data[], unsigned int length) {
+    qDebug() << "MIDI system exclusive message sending not yet implemented for this API or platform";
+}
+
+bool MidiDevice::getMidiLearnStatus() {
+    return m_bMidiLearn;
+}
+
+void MidiDevice::enableMidiLearn() {
+    m_bMidiLearn = true;
+    connect(this, SIGNAL(midiEvent(MidiMessage)), m_pMidiMapping, SLOT(finishMidiLearn(MidiMessage)));
+
+}
+
+void MidiDevice::disableMidiLearn() {
+    m_bMidiLearn = false;
+    disconnect(this, SIGNAL(midiEvent(MidiMessage)), m_pMidiMapping, SLOT(finishMidiLearn(MidiMessage)));
+}
+
+void MidiDevice::receive(MidiStatusByte status, char channel, char control, char value)
+{
+    if (midiDebugging()) qDebug() << QString("MIDI ch %1: status: %2, ctrl: %3, val: %4")
+        .arg(QString::number(channel+1, 16).toUpper())
+        .arg(QString::number(status & 255, 16).toUpper())
+        .arg(QString::number(control, 16).toUpper())
+        .arg(QString::number(value, 16).toUpper());
+
+    MidiMessage inputCommand(status, control, channel);
+
+    if (m_bMidiLearn) {
+        emit(midiEvent(inputCommand));
+        return; // Don't process midi messages further when MIDI learning
+    }
+
+    // Only check for a mapping if the status byte is one we know how to handle
+    if (status == MIDI_STATUS_NOTE_ON 
+         || status == MIDI_STATUS_NOTE_OFF
+         || status == MIDI_STATUS_PITCH_BEND 
+         || status == MIDI_STATUS_CC) {
+        // If there was no control bound to that MIDI command, return;
+        if (!m_pMidiMapping->isMidiMessageMapped(inputCommand)) {
+            return;
+        }
+    }
+
+    MixxxControl mixxxControl = m_pMidiMapping->getInputMixxxControl(inputCommand);
+    //qDebug() << "MidiDevice: " << mixxxControl.getControlObjectGroup() << mixxxControl.getControlObjectValue();
+
+    ConfigKey configKey(mixxxControl.getControlObjectGroup(), mixxxControl.getControlObjectValue());
+
+#ifdef __MIDISCRIPT__
+    // Custom MixxxScript (QtScript) handler
+    //FIXME: SEAN - The script engine will live inside the MidiMapping! Update this code accordingly.
+    
+    if (mixxxControl.getMidiOption() == MIDI_OPT_SCRIPT) {
+        // qDebug() << "MidiDevice: Calling script function" << configKey.item << "with" << (int)channel << (int)control <<  (int)value << (int)status;
+
+        if (!m_pMidiMapping->getMidiScriptEngine()->execute(configKey.item, channel, control, value, status, mixxxControl.getControlObjectGroup())) {
+            qDebug() << "MidiDevice: Invalid script function" << configKey.item;
+        }
+        return;
+    }
+#endif
+
+    ControlObject * p = ControlObject::getControl(configKey);
+
+    if (p) //Only pass values on to valid ControlObjects.
+    {
+      double newValue = m_pMidiMapping->ComputeValue(mixxxControl.getMidiOption(), p->GetMidiValue(), value);
+
+      // ControlPushButton ControlObjects only accept NOTE_ON, so if the midi mapping is <button> we override the Midi 'status' appropriately.
+      switch (mixxxControl.getMidiOption()) {
+              case MIDI_OPT_BUTTON:
+              case MIDI_OPT_SWITCH: status = MIDI_STATUS_NOTE_ON; break; // Buttons and Switches are treated the same, except that their values are computed differently.
+              default: break;
+      }
+
+      ControlObject::sync();
+    
+        //Super dangerous cast here... Should be fine once MidiCategory is replaced with MidiStatusByte permanently.
+      p->queueFromMidi((MidiCategory)status, newValue);
+    }
+
+    return;
+}
+
+bool MidiDevice::midiDebugging() {
+    if (m_midiDebug != -1) return true;
+    else return false;
+}

=== added file 'mixxx/src/midi/mididevice.h'
--- mixxx/src/midi/mididevice.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/midi/mididevice.h	2009-11-10 00:33:17 +0000
@@ -0,0 +1,82 @@
+/***************************************************************************
+                             mididevice.h
+                           MIDI Device Class
+                           -------------------
+    begin                : Thu Dec 18 2008
+    copyright            : (C) 2008 Albert Santoni
+    email                : [e-mail]
+
+***************************************************************************/
+
+/***************************************************************************
+*                                                                         *
+*   This program is free software; you can redistribute it and/or modify  *
+*   it under the terms of the GNU General Public License as published by  *
+*   the Free Software Foundation; either version 2 of the License, or     *
+*   (at your option) any later version.                                   *
+*                                                                         *
+***************************************************************************/
+
+#ifndef MIDIDEVICE_H
+#define MIDIDEVICE_H
+
+#include <QtCore>
+#include "midimessage.h"
+
+//Forward declarations
+class MidiMapping;
+#ifdef __MIDISCRIPT__
+class MidiScriptEngine;
+#endif
+
+class MidiDevice : public QObject
+{
+Q_OBJECT
+    public:
+        MidiDevice(MidiMapping* mapping);
+        virtual ~MidiDevice();
+        virtual int open() = 0;
+        virtual int close() = 0;
+        void startup();
+        void shutdown();
+        bool isOpen() { return m_bIsOpen; };
+        bool isOutputDevice() { return m_bIsOutputDevice; };
+        bool isInputDevice() { return m_bIsInputDevice; };
+        QString getName() { return m_strDeviceName; };
+        void setMidiMapping(MidiMapping* mapping);
+        MidiMapping* getMidiMapping() { return m_pMidiMapping; };
+        Q_INVOKABLE void sendShortMsg(unsigned char status, unsigned char byte1, unsigned char byte2);
+        virtual void sendShortMsg(unsigned int word);
+        virtual void sendSysexMsg(unsigned char data[], unsigned int length);
+        Q_INVOKABLE void sendSysexMsg(QList<int> data, unsigned int length);
+        bool getMidiLearnStatus();
+        void receive(MidiStatusByte status, char channel, char control, char value);
+        bool midiDebugging();
+
+    public slots:
+        void disableMidiLearn();
+        void enableMidiLearn();
+
+    signals:
+        void midiEvent(MidiMessage message);
+    protected:
+        /** Verbose device name, in format "[index]. [device name]". Suitable for display in GUI. */
+        QString m_strDeviceName;
+        /** Flag indicating if this device supports MIDI output */
+        bool m_bIsOutputDevice;
+        /** Flag indicating if this device supports MIDI input */
+        bool m_bIsInputDevice;
+        /** MIDI Mapping for this MIDI device, maps MIDI messages onto Mixxx controls */
+        MidiMapping* m_pMidiMapping;
+        /** Indicates whether or not the MIDI device has been opened for input/output. */
+        bool m_bIsOpen;
+        /** Indicates whether MIDI learning is currently enabled or not */
+        bool m_bMidiLearn;
+        /** Pointer to the output device that corresponds to this physical input device. MIDI is a half-duplex
+            protocol that treats input and output ports on a single device as complete separate entities. This
+            helps us group those back together for sanity/usability. */
+        MidiDevice* m_pCorrespondingOutputDevice;
+        int m_midiDebug;
+};
+
+#endif

=== added file 'mixxx/src/midi/mididevicedummy.h'
--- mixxx/src/midi/mididevicedummy.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/midi/mididevicedummy.h	2009-11-10 00:33:17 +0000
@@ -0,0 +1,41 @@
+/**
+  * @file mididevicedummy.h
+  * @author Albert Santoni [e-mail]
+  * @date Sun Aug 9 2009
+  * @brief Dummy MIDI backend
+  *
+  */
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef MIDIDEVICEDUMMY_H
+#define MIDIDEVICEDUMMY_H
+
+#include <QtCore>
+#include "mididevice.h"
+
+/**
+  *@author Albert Santoni
+  */
+
+/** A dummy implementation of MidiDevice */
+class MidiDeviceDummy : public MidiDevice {
+public:
+    MidiDeviceDummy(MidiMapping* mapping=NULL) : MidiDevice(mapping) { setObjectName("Dummy MIDI Device");};
+    ~MidiDeviceDummy() {};
+    int open() { return 0; };
+    int close() { return 0; };
+    void sendShortMsg(unsigned int word) {};
+    void sendSysexMsg(unsigned char data[], unsigned int length) {};
+protected:
+
+};
+
+#endif

=== added file 'mixxx/src/midi/mididevicemanager.cpp'
--- mixxx/src/midi/mididevicemanager.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/midi/mididevicemanager.cpp	2009-11-10 00:33:17 +0000
@@ -0,0 +1,299 @@
+/**
+  * @file mididevicemanager.cpp
+  * @author Albert Santoni [e-mail] & Sean Pappalardo [e-mail]
+  * @date Thu Dec 18 2008
+  * @brief Manages creation/enumeration/deletion of MidiDevices.
+  */
+
+/***************************************************************************
+*                                                                         *
+*   This program is free software; you can redistribute it and/or modify  *
+*   it under the terms of the GNU General Public License as published by  *
+*   the Free Software Foundation; either version 2 of the License, or     *
+*   (at your option) any later version.                                   *
+*                                                                         *
+***************************************************************************/
+
+#include <QtCore>
+#include "mididevice.h"
+//#include "midilearnlistener.h"
+//#include "midilearningprocessor.h"
+//#include "midicontrolprocessor.h"
+#include "midideviceportmidi.h"
+#include "dlgprefmidibindings.h"
+#include "mididevicemanager.h"
+#include "../mixxxcontrol.h"
+#include "midimapping.h"
+
+#define DEVICE_CONFIG_PATH BINDINGS_PATH.append("MixxxMIDIDevices")
+
+MidiDeviceManager::MidiDeviceManager(ConfigObject<ConfigValue> * pConfig) : QObject()
+{
+    m_pConfig = pConfig;
+    m_pPrimaryMidiDevice = NULL;
+    m_pDeviceSettings = new ConfigObject<ConfigValue>(DEVICE_CONFIG_PATH);
+}
+
+MidiDeviceManager::~MidiDeviceManager()
+{
+    closeDevices();
+}
+
+void MidiDeviceManager::saveMappings(bool onlyActive) {
+    // Write out MIDI mappings for currently connected devices
+    QList<MidiDevice*> deviceList = getDeviceList(false, true);
+    QListIterator<MidiDevice*> it(deviceList);
+    
+    QList<QString> filenames;
+    
+    while (it.hasNext())
+    {
+        MidiDevice *cur= it.next();
+        if (onlyActive && !cur->isOpen()) continue;
+        MidiMapping *mapping = cur->getMidiMapping();
+        QString name = cur->getName();
+        
+        QString ofilename = name.right(name.size()-name.indexOf(" ")-1).replace(" ", "_");
+        
+        QString filename = ofilename;
+        
+        int i=1;
+        while (filenames.contains(filename)) {
+            i++;
+            filename = QString("%1--%2").arg(ofilename).arg(i);
+        }
+        
+        filenames.append(filename);
+        mapping->savePreset(BINDINGS_PATH.append(filename + MIDI_MAPPING_EXTENSION));
+    }
+}
+
+QList<MidiDevice*> MidiDeviceManager::getDeviceList(bool bOutputDevices, bool bInputDevices)
+{
+    qDebug() << "MidiDeviceManager::getDeviceList";
+    bool bMatchedCriteria = false;   //Whether or not the current device matched the filtering criteria
+
+    if (m_devices.empty())
+        this->queryDevices();
+
+    //Create a list of MIDI devices filtered to match the given input/output options.
+    QList<MidiDevice*> filteredDeviceList;
+    QListIterator<MidiDevice*> dev_it(m_devices);
+    while (dev_it.hasNext())
+    {
+        bMatchedCriteria = false;                //Reset this for the next device.
+        MidiDevice *device = dev_it.next();
+        
+        if ((bOutputDevices == device->isOutputDevice()) ||
+            (bInputDevices == device->isInputDevice())) {
+            bMatchedCriteria = true;
+        }
+    
+        if (bMatchedCriteria)
+            filteredDeviceList.push_back(device);
+    }
+    return filteredDeviceList;
+}
+
+void MidiDeviceManager::closeDevices()
+{
+    QListIterator<MidiDevice*> dev_it(m_devices);
+    while (dev_it.hasNext())
+    {
+        qDebug() << "Closing MIDI device" << dev_it.peekNext()->getName();
+        dev_it.next()->close();
+    }
+}
+
+/** Enumerate the MIDI devices 
+  * This method needs a bit of intelligence because PortMidi (and the underlying MIDI APIs) like to split
+  * output and input into separate devices. Eg. PortMidi would tell us the Hercules is two half-duplex devices.
+  * To help simplify a lot of code, we're going to aggregate these two streams into a single full-duplex device.
+  */
+void MidiDeviceManager::queryDevices()
+{
+    qDebug() << "Scanning MIDI devices:";
+    int iNumDevices = Pm_CountDevices();
+    
+    QListIterator<MidiDevice*> dev_it(m_devices);
+    while (dev_it.hasNext()) {
+        delete dev_it.next();
+    }
+    
+    m_devices.clear();
+    
+    const PmDeviceInfo *deviceInfo, *inputDeviceInfo, *outputDeviceInfo;
+    int inputDevIndex, outputDevIndex;
+    QMap<int,QString> unassignedOutputDevices;
+    
+    // Build a complete list of output devices for later pairing
+    for (int i = 0; i < iNumDevices; i++)
+    {
+        deviceInfo = Pm_GetDeviceInfo(i);
+        if (deviceInfo->output) {
+            qDebug() << " Found output device" << "#" << i << deviceInfo->name;
+            QString deviceName = deviceInfo->name;
+            // Ignore "To" text in the device names
+            if (deviceName.indexOf("to",0,Qt::CaseInsensitive)!=-1) deviceName = deviceName.right(deviceName.length()-2);
+            unassignedOutputDevices[i] = deviceName;
+        }
+    }
+
+    // Search for input devices and pair them with output devices if applicable
+    for (int i = 0; i < iNumDevices; i++)
+    {
+        deviceInfo = Pm_GetDeviceInfo(i);
+        
+        //If we found an input device
+        if (deviceInfo->input)
+        {
+            qDebug() << " Found input device" << "#" << i << deviceInfo->name;
+            inputDeviceInfo = deviceInfo;
+            inputDevIndex = i;
+            
+            //Reset our output device variables before we look for one incase we find none.
+            outputDeviceInfo = NULL;
+            outputDevIndex = -1;
+            
+            //Search for a corresponding output device
+            QMapIterator<int, QString> j(unassignedOutputDevices);
+            while (j.hasNext()) {
+                j.next();
+                
+                // Ignore "From" text in the device names
+                QString deviceName = inputDeviceInfo->name;
+                if (deviceName.indexOf("from",0,Qt::CaseInsensitive)!=-1) deviceName = deviceName.right(deviceName.length()-4);
+
+                QByteArray outputName = QString(j.value()).toUtf8();
+                if (strcmp(outputName, deviceName) == 0) {
+                    outputDevIndex = j.key();
+                    outputDeviceInfo = Pm_GetDeviceInfo(outputDevIndex);
+                    
+                    unassignedOutputDevices.remove(outputDevIndex);
+                    
+                    qDebug() << "    Linking to output device #" << outputDevIndex << outputName;
+                    break;
+                }
+            }
+
+            //So at this point in the code, we either have an input-only MIDI device (outputDeviceInfo == NULL)
+            //or we've found a matching output MIDI device (outputDeviceInfo != NULL).
+            
+            //.... so create our (aggregate) MIDI device!            
+            MidiDevicePortMidi *currentDevice = new MidiDevicePortMidi(/*new MidiControlProcessor(NULL)*/ NULL,
+                                                                          inputDeviceInfo,
+                                                                          outputDeviceInfo,
+                                                                          inputDevIndex,
+                                                                          outputDevIndex); 
+            m_devices.push_back((MidiDevice*)currentDevice);
+            
+        }
+
+//         if (deviceInfo->input || deviceInfo->output)
+//         {
+//             MidiDevicePortMidi *currentDevice = new MidiDevicePortMidi(new MidiControlProcessor(NULL), deviceInfo, i);
+//             m_devices.push_back((MidiDevice*)currentDevice);
+//         }
+    }
+}
+
+/** Open whatever MIDI devices are selected in the preferences. */
+int MidiDeviceManager::setupDevices()
+{
+    QList<MidiDevice*> deviceList = getDeviceList(false, true);
+    QListIterator<MidiDevice*> it(deviceList);
+    
+    qDebug() << "MidiDeviceManager: Setting up devices";
+    
+    QList<QString> filenames;
+    
+    while (it.hasNext())
+    {
+        MidiDevice *cur= it.next();
+        MidiMapping *mapping = cur->getMidiMapping();
+        QString name = cur->getName();
+        mapping->setName(name);
+        
+        cur->close();
+        
+        QString ofilename = name.right(name.size()-name.indexOf(" ")-1).replace(" ", "_");
+        
+        QString filename = ofilename;
+        
+        int i=1;
+        while (filenames.contains(filename)) {
+            i++;
+            filename = QString("%1--%2").arg(ofilename).arg(i);
+        }
+        
+        filenames.append(filename);
+        mapping->loadPreset(BINDINGS_PATH.append(filename + MIDI_MAPPING_EXTENSION),true);
+        
+        if ( m_pConfig->getValueString(ConfigKey("[Midi]", name.replace(" ", "_"))) != "1" )
+            continue;
+        
+        qDebug() << "Opening Device:" << name;
+
+        cur->open();
+        mapping->applyPreset();
+        
+    }
+    
+    return 0;
+}
+
+
+/** This should be in MidiProcessor because it's bindings related */
+QStringList MidiDeviceManager::getConfigList(QString path)
+{
+    // Make sure list is empty
+    QStringList configs;
+    configs.clear();
+
+    // Get list of available midi configurations
+    QDir dir(path);
+    dir.setFilter(QDir::Files);
+    dir.setNameFilters(QStringList() << "*.midi.xml" << "*.MIDI.XML");
+
+    //const QFileInfoList *list = dir.entryInfoList();
+    //if (dir.entryInfoList().empty())
+    {
+        QListIterator<QFileInfo> it(dir.entryInfoList());
+        QFileInfo fi;                          // pointer for traversing
+        while (it.hasNext())
+        {
+            fi = it.next();
+            configs.append(fi.fileName());
+        }
+    }
+
+    return configs;
+}
+
+
+void MidiDeviceManager::associateInputAndOutputDevices(MidiDevice* inputDevice, QString outputDeviceName)
+{
+    //TODO: This function needs to be updated to work with our "aggregate" input/ouput MidiDevice class
+    //      or just simply removed all together. I just sent out a mixxx-devel email with more history
+    //      on this, check the archive if you need more info. -- Albert Nov 9/09 (1.8 CRUNCH TIME!)
+    //      
+
+/*
+    //Find the output MidiDevice object that corresponds to outputDeviceName.
+    QListIterator<MidiDevice*> dev_it(m_devices);
+    MidiDevice* outputDevice = NULL;
+    while (dev_it.hasNext()) {
+        outputDevice = dev_it.next();
+        if (outputDevice->getName() == outputDeviceName) {
+            qDebug() << "associating input dev" << inputDevice->getName() << "with" << outputDeviceName;
+            break;
+        }
+    }    
+    
+    if (outputDevice == NULL) //No output device matched outputDeviceName...
+        return;
+    
+    //Tell the input device that it's corresponding output device is... outputDevice.
+    inputDevice->setOutputDevice(outputDevice);    
+    */
+}

=== added file 'mixxx/src/midi/mididevicemanager.h'
--- mixxx/src/midi/mididevicemanager.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/midi/mididevicemanager.h	2009-11-10 00:33:17 +0000
@@ -0,0 +1,53 @@
+/**
+  * @file mididevicemanager.h
+  * @author Albert Santoni [e-mail]
+  * @date Thu Dec 18 2008
+  * @brief Manages creation/enumeration/deletion of MidiDevices.
+  */
+
+/***************************************************************************
+*                                                                         *
+*   This program is free software; you can redistribute it and/or modify  *
+*   it under the terms of the GNU General Public License as published by  *
+*   the Free Software Foundation; either version 2 of the License, or     *
+*   (at your option) any later version.                                   *
+*                                                                         *
+***************************************************************************/
+
+#ifndef MIDIDEVICEMANAGER_H
+#define MIDIDEVICEMANAGER_H
+
+#include "configobject.h"
+class MidiDevice;
+class MidiLearnListener;
+class MidiLearnProcessor;
+class DlgPrefMidiBindings;
+
+/** Manages creation/enumeration/deletion of MidiDevices. */
+class MidiDeviceManager : public QObject
+{
+    Q_OBJECT
+	public:
+		MidiDeviceManager(ConfigObject<ConfigValue> * pConfig);
+		~MidiDeviceManager();
+        QList<MidiDevice*> getDeviceList(bool bOutputDevices=true, bool bInputDevice=true);
+        QStringList getConfigList(QString path);
+        void saveMappings(bool onlyActive=false);
+        void closeDevices();
+        void queryDevices();
+        int setupDevices();
+        ConfigObject<ConfigValue>* getDeviceSettings() { return m_pDeviceSettings; };
+        void associateInputAndOutputDevices(MidiDevice* inputDevice, QString outputDeviceName);
+    /*    MidiDevice* getPrimaryMidiDevice() { return m_pPrimaryMidiDevice; }; //HACK while our code still sucks
+        void enableMidiLearn(DlgPrefMidiBindings* listener);
+        void disableMidiLearn(); */ //Moving MIDI learning into MIDI device, a la 1.7.0
+    signals:
+        void devicesChanged();
+	private:
+		QList<MidiDevice*> m_devices;
+	    ConfigObject<ConfigValue> *m_pDeviceSettings;
+	    ConfigObject<ConfigValue> *m_pConfig;
+	    MidiDevice* m_pPrimaryMidiDevice;
+    };
+    
+#endif

=== added file 'mixxx/src/midi/midideviceportmidi.cpp'
--- mixxx/src/midi/midideviceportmidi.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/midi/midideviceportmidi.cpp	2009-11-10 00:33:17 +0000
@@ -0,0 +1,245 @@
+/**
+  * @file midideviceportmidi.cpp
+  * @author Albert Santoni [e-mail]
+  * @date Thu Dec 18 2008
+  * @brief PortMidi-based MIDI backend
+  * 
+  * MidiDevicePortMidi is a class representing a MIDI device, either
+  * physical or software. It uses the PortMidi API to send and receive
+  * MIDI events to/from the device. It's important to note that PortMidi
+  * treats input and output on a single physical device as two separate
+  * half-duplex devices. In this class, we wrap those together into a 
+  * single device, which is why the MidiDevicePortMidi constructor takes
+  * both arguments pertaining to both input and output "devices". 
+  *
+  *
+  */
+
+/***************************************************************************
+*                                                                         *
+*   This program is free software; you can redistribute it and/or modify  *
+*   it under the terms of the GNU General Public License as published by  *
+*   the Free Software Foundation; either version 2 of the License, or     *
+*   (at your option) any later version.                                   *
+*                                                                         *
+***************************************************************************/
+
+#include <QtCore>
+#include "configobject.h"
+#include "midimapping.h"
+#include "midideviceportmidi.h"
+
+QMutex MidiDevicePortMidi::m_sPMLock;   // PortMidi is not thread-safe
+
+MidiDevicePortMidi::MidiDevicePortMidi(MidiMapping* mapping, 
+                                       const PmDeviceInfo* inputDeviceInfo, 
+                                       const PmDeviceInfo* outputDeviceInfo, 
+                                       int inputDeviceIndex,
+                                       int outputDeviceIndex)
+                                        : MidiDevice(mapping), QThread() 
+{
+    m_pInputStream = NULL;
+    m_pOutputStream = NULL;
+    m_bStopRequested = false;
+    m_pInputDeviceInfo = inputDeviceInfo;
+    m_pOutputDeviceInfo = outputDeviceInfo;
+    m_iInputDeviceIndex = inputDeviceIndex;
+    m_iOutputDeviceIndex = outputDeviceIndex;
+    
+    //Note: We prepend the input stream's index to the device's name to prevent duplicate devices from causing mayhem.
+    m_strDeviceName = QString("%1. %2").arg(QString::number(m_iInputDeviceIndex)).arg(inputDeviceInfo->name);
+    
+    if (inputDeviceInfo) {
+        m_bIsInputDevice = m_pInputDeviceInfo->input;
+    }
+    if (outputDeviceInfo) {
+        m_bIsOutputDevice = m_pOutputDeviceInfo->output;
+    }
+}
+
+MidiDevicePortMidi::~MidiDevicePortMidi()
+{
+    close();
+}
+
+int MidiDevicePortMidi::open()
+{
+    if (m_bIsOpen) {
+        qDebug() << "PortMIDI device" << m_strDeviceName << "already open";
+        return -1;
+    }
+    
+    startup();
+    
+    m_bStopRequested = false;
+    
+    if (m_strDeviceName == MIXXX_PORTMIDI_NO_DEVICE_STRING)
+        return -1;
+
+    PmError err = Pm_Initialize();
+    if( err != pmNoError )
+    {
+        qDebug() << "PortMidi error:" << Pm_GetErrorText(err);
+        return -1;
+    }
+
+    if (m_pInputDeviceInfo)
+    {    
+        if (m_bIsInputDevice)
+        {
+            if (midiDebugging()) qDebug() << "MidiDevicePortMidi: Opening" << m_pInputDeviceInfo->name << "index" << m_iInputDeviceIndex << "for input";
+
+            err = Pm_OpenInput( &m_pInputStream,
+                    m_iInputDeviceIndex,
+                    NULL, //No drive hacks
+                    MIXXX_PORTMIDI_BUFFER_LEN,
+                    NULL, 
+                    NULL);
+    
+            if( err != pmNoError )
+            {
+                qDebug() << "PortMidi error:" << Pm_GetErrorText(err);
+                return -2;
+            }
+        }
+    }
+    if (m_pOutputDeviceInfo)
+    {
+        if (m_bIsOutputDevice)
+        {
+            if (midiDebugging()) qDebug() << "MidiDevicePortMidi: Opening" << m_pOutputDeviceInfo->name << "index" << m_iOutputDeviceIndex << "for output";
+
+            err = Pm_OpenOutput( &m_pOutputStream,
+                    m_iOutputDeviceIndex,
+                    NULL, // No driver hacks
+                    0,      // No buffering
+                    NULL, // Use PortTime for timing
+                    NULL, // No time info
+                    0);   // No latency compensation.
+
+            if( err != pmNoError )
+            {
+                qDebug() << "PortMidi error:" << Pm_GetErrorText(err);
+                return -2;
+            }
+        }
+    }   
+    
+    m_bIsOpen = true;
+    start();
+    
+    return 0;
+
+}
+
+int MidiDevicePortMidi::close()
+{
+    if (!m_bIsOpen) {
+        qDebug() << "PortMIDI device" << m_strDeviceName << "already closed";
+        return -1;
+    }
+    
+    shutdown();
+
+    m_bStopRequested = true;
+    m_mutex.lock();
+    
+    if (m_pInputStream)
+    {
+        m_sPMLock.lock();
+        PmError err = Pm_Close(m_pInputStream);
+        if( err != pmNoError )
+        {
+            qDebug() << "PortMidi error:" << Pm_GetErrorText(err);
+            m_sPMLock.unlock();
+            return -1;
+        }
+        m_sPMLock.unlock();
+    }
+    
+    if (m_pOutputStream)
+    {
+        m_sPMLock.lock();
+        PmError err = Pm_Close(m_pOutputStream);
+        if( err != pmNoError )
+        {
+            qDebug() << "PortMidi error:" << Pm_GetErrorText(err);
+            m_sPMLock.unlock();
+            return -1;
+        }
+        m_sPMLock.unlock();
+    }
+    
+    m_bIsOpen = false;
+    
+    m_mutex.unlock();
+        
+    return 0;
+}
+
+void MidiDevicePortMidi::run()
+{
+    QThread::currentThread()->setObjectName(QString("PM %1").arg(m_strDeviceName));
+    int numEvents = 0;
+    bool stopRunning = false;
+    
+
+    do
+    {
+        m_mutex.lock();
+        if (m_pInputStream)
+        {
+            m_sPMLock.lock();
+            numEvents = Pm_Read(m_pInputStream, m_midiBuffer, MIXXX_PORTMIDI_BUFFER_LEN);
+            m_sPMLock.unlock();
+    
+            for (int i = 0; i < numEvents; i++)
+            {
+                //if (Pm_MessageStatus(m_midiBuffer[i].message) == 0x90) //Note on, channel 1
+                {
+                    m_sPMLock.lock();
+                    unsigned char status = Pm_MessageStatus(m_midiBuffer[i].message);
+                    unsigned char opcode = status & 0xF0;
+                    unsigned char channel = status & 0x0F;
+                    unsigned char note = Pm_MessageData1(m_midiBuffer[i].message);
+                    unsigned char velocity = Pm_MessageData2(m_midiBuffer[i].message);
+                    m_sPMLock.unlock();
+                                    
+                    MidiDevice::receive((MidiStatusByte)status, channel, note, velocity);
+
+                }
+            }
+        }
+        
+        usleep(5000); //Sleep this thread for 5 milliseconds between checking for new MIDI events.
+        
+        stopRunning = m_bStopRequested; //Cache locally for thread-safety.
+        m_mutex.unlock(); //Have to unlock inside the loop to give the other thread a chance to lock.
+        
+    } while (!stopRunning);
+    
+
+}
+
+void MidiDevicePortMidi::sendShortMsg(unsigned int word) 
+{
+    if (m_pOutputStream)
+    {
+        m_sPMLock.lock();
+        PmError err = Pm_WriteShort(m_pOutputStream, 0, word);
+        if( err != pmNoError ) qDebug() << "PortMidi sendShortMsg error:" << Pm_GetErrorText(err);
+        m_sPMLock.unlock();
+    }
+}
+
+// The sysex data must already contain the start byte 0xf0 and the end byte 0xf7.
+void MidiDevicePortMidi::sendSysexMsg(unsigned char data[], unsigned int length) 
+{
+    if (m_pOutputStream)
+    {
+        m_sPMLock.lock();
+        PmError err = Pm_WriteSysEx(m_pOutputStream, 0, data);
+        if( err != pmNoError ) qDebug() << "PortMidi sendSysexMsg error:" << Pm_GetErrorText(err);
+        m_sPMLock.unlock();
+    } 
+}

=== added file 'mixxx/src/midi/midideviceportmidi.h'
--- mixxx/src/midi/midideviceportmidi.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/midi/midideviceportmidi.h	2009-11-10 00:33:17 +0000
@@ -0,0 +1,60 @@
+/**
+  * @file midideviceportmidi.h
+  * @author Albert Santoni [e-mail]
+  * @date Thu Dec 18 2008
+  * @brief PortMidi-based MIDI backend
+  *
+  */
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef MIDIDEVICEPORTMIDI_H
+#define MIDIDEVICEPORTMIDI_H
+
+#include <portmidi.h>
+#include <porttime.h>
+#include <QtCore>
+#include "mididevice.h"
+
+#define MIXXX_PORTMIDI_BUFFER_LEN 64 /**Number of MIDI messages to buffer*/
+#define MIXXX_PORTMIDI_NO_DEVICE_STRING "None" /**String to display for no MIDI devices present */
+/**
+  *@author Albert Santoni
+  */
+
+/** A PortMidi-based implementation of MidiDevice */
+class MidiDevicePortMidi : public MidiDevice, public QThread {
+public:
+    MidiDevicePortMidi(MidiMapping* mapping, 
+                       const PmDeviceInfo* inputDeviceInfo, 
+                       const PmDeviceInfo* outputDeviceInfo, 
+                       int inputDeviceIndex,
+                       int outputDeviceIndex);
+    ~MidiDevicePortMidi();
+    int open();
+    int close();
+    void sendShortMsg(unsigned int word);
+    void sendSysexMsg(unsigned char data[], unsigned int length);
+protected:
+    void run();
+    const PmDeviceInfo* m_pInputDeviceInfo;
+    const PmDeviceInfo* m_pOutputDeviceInfo;
+    int m_iInputDeviceIndex;
+    int m_iOutputDeviceIndex;
+    PortMidiStream *m_pInputStream;
+    PortMidiStream *m_pOutputStream;
+    PmEvent m_midiBuffer[MIXXX_PORTMIDI_BUFFER_LEN];
+    static QList<QString> m_deviceList;
+    QMutex m_mutex;
+    static QMutex m_sPMLock;    // PortMidi is not thread-safe, so we need to only allow one thread at a time
+    bool m_bStopRequested;
+};
+
+#endif

=== renamed file 'mixxx/src/midiinputmapping.h' => 'mixxx/src/midi/midiinputmapping.h'
=== renamed file 'mixxx/src/midiinputmappingtablemodel.cpp' => 'mixxx/src/midi/midiinputmappingtablemodel.cpp'
=== renamed file 'mixxx/src/midiinputmappingtablemodel.h' => 'mixxx/src/midi/midiinputmappingtablemodel.h'
=== renamed file 'mixxx/src/midiledhandler.cpp' => 'mixxx/src/midi/midiledhandler.cpp'
--- mixxx/src/midiledhandler.cpp	2009-08-11 04:38:51 +0000
+++ mixxx/src/midi/midiledhandler.cpp	2009-11-10 00:33:17 +0000
@@ -6,9 +6,9 @@
 
 Q3PtrList<MidiLedHandler> MidiLedHandler::allhandlers = Q3PtrList<MidiLedHandler>();
 
-MidiLedHandler::MidiLedHandler(QString group, QString key, MidiObject & midi, double min,
-                               double max, unsigned char status, unsigned char midino, QString device, unsigned char on, unsigned char off)
-    : m_min(min), m_max(max), m_midi(midi), m_status(status), m_midino(midino), m_device(device), m_on(on), m_off(off) {
+MidiLedHandler::MidiLedHandler(QString group, QString key, MidiDevice & midi, double min,
+                               double max, unsigned char status, unsigned char midino, unsigned char on, unsigned char off)
+    : m_min(min), m_max(max), m_midi(midi), m_status(status), m_midino(midino), m_on(on), m_off(off) {
 
     //OMGWTFBBQ: Massive hack to temporarily fix LP #254564 for the 1.6.0 release.
     //           Something's funky with our <lights> blocks handling? -- Albert 08/05/2008
@@ -49,7 +49,7 @@
     m_reentracyBlock.unlock();
 }
 
-void MidiLedHandler::createHandlers(QDomNode node, MidiObject & midi, QString device) {
+void MidiLedHandler::createHandlers(QDomNode node, MidiDevice & midi) {
     if (!node.isNull() && node.isElement()) {
         QDomNode light = node;
         while (!light.isNull()) {
@@ -78,8 +78,8 @@
                 if (!light.firstChildElement("maximum").isNull()) {
                     max = WWidget::selectNodeFloat(light, "maximum");
                 }
-                qDebug() << "Creating LED handler hook for:" << group << key << "between"<< min << "and" << max << "to midi out:" << status << midino << "on" << device << "on/off:" << on << off;
-                allhandlers.append(new MidiLedHandler(group, key, midi, min, max, status, midino, device, on, off));
+                qDebug() << "Creating LED handler hook for:" << group << key << "between"<< min << "and" << max << "to midi out:" << status << midino << "on/off:" << on << off;
+                allhandlers.append(new MidiLedHandler(group, key, midi, min, max, status, midino, on, off));
             }
             light = light.nextSibling();
         }

=== renamed file 'mixxx/src/midiledhandler.h' => 'mixxx/src/midi/midiledhandler.h'
--- mixxx/src/midiledhandler.h	2009-04-19 18:54:16 +0000
+++ mixxx/src/midi/midiledhandler.h	2009-11-10 00:33:17 +0000
@@ -5,7 +5,7 @@
 #define MIDILEDHANDLER_H
 
 #include "controlobject.h"
-#include "midiobject.h"
+#include "mididevice.h"
 
 #include <q3ptrlist.h>
 
@@ -13,11 +13,11 @@
 {
     Q_OBJECT
 public:
-	MidiLedHandler(QString group, QString key, MidiObject& midi, double min, double max,
-		unsigned char status, unsigned char midino, QString device, unsigned char on, unsigned char off);
+	MidiLedHandler(QString group, QString key, MidiDevice & midi, double min, double max,
+		unsigned char status, unsigned char midino, unsigned char on, unsigned char off);
     ~MidiLedHandler();
 
-	static void createHandlers(QDomNode node, MidiObject& midi, QString device);
+	static void createHandlers(QDomNode node, MidiDevice & midi);
 	static void destroyHandlers();
 	static Q3PtrList<MidiLedHandler> allhandlers;
 
@@ -25,13 +25,12 @@
 	void controlChanged(double value);
 
 private:
-	MidiObject& m_midi;
+	MidiDevice& m_midi;
 	double m_min;
 	double m_max;
 	ControlObject* m_cobj;
 	unsigned char m_status;
 	unsigned char m_midino;
-	QString m_device;
 	unsigned char m_on;
 	unsigned char m_off;
 	unsigned char lastStatus;

=== renamed file 'mixxx/src/midimapping.cpp' => 'mixxx/src/midi/midimapping.cpp'
--- mixxx/src/midimapping.cpp	2009-11-10 00:33:14 +0000
+++ mixxx/src/midi/midimapping.cpp	2009-11-10 00:33:17 +0000
@@ -4,6 +4,7 @@
                            -------------------
     begin                : Sat Jan 17 2009
     copyright            : (C) 2009 Sean M. Pappalardo
+                           (C) 2009 Albert Santoni
     email                : [e-mail]
 
 ***************************************************************************/
@@ -22,40 +23,139 @@
 #include "widget/wwidget.h"    // FIXME: This should be xmlparse.h
 #include "mixxxcontrol.h"
 #include "midimessage.h"
+#include "defs.h"
 #include "midiinputmappingtablemodel.h"
 #include "midioutputmappingtablemodel.h"
 #include "midimapping.h"
+#include "mididevicedummy.h"
 #include "midiledhandler.h"
 #include "configobject.h"
 
-#define REQUIRED_MAPPING_FILE "midi-mappings-scripts.js"
+#define REQUIRED_SCRIPT_FILE "midi-mappings-scripts.js"
 #define XML_SCHEMA_VERSION "1"
+#define DEFAULT_DEVICE_PRESET BINDINGS_PATH.append(m_deviceName.right(m_deviceName.size()-m_deviceName.indexOf(" ")-1).replace(" ", "_") + MIDI_MAPPING_EXTENSION)
 
 static QString toHex(QString numberStr) {
     return "0x" + QString("0" + QString::number(numberStr.toUShort(), 16).toUpper()).right(2);
 }
 
-MidiMapping::MidiMapping(MidiObject& midi_object) : QObject(), m_rMidiObject(midi_object), m_mappingLock(QMutex::Recursive) {
+MidiMapping::MidiMapping(MidiDevice* outputMidiDevice)
+        : QObject(),
+          m_mappingLock(QMutex::Recursive) {
+    // If BINDINGS_PATH doesn't exist, create it
+    if (!QDir(BINDINGS_PATH).exists()) {
+        qDebug() << "Creating new MIDI presets directory" << BINDINGS_PATH;
+        QDir().mkpath(BINDINGS_PATH);
+    }
+
+    //Q_ASSERT(outputMidiDevice);
+
 #ifdef __MIDISCRIPT__
-    m_pScriptEngine = midi_object.getMidiScriptEngine();
+    //Start the scripting engine.
+    m_pScriptEngine = NULL;
+    m_pOutputMidiDevice = outputMidiDevice;
+    if (m_pOutputMidiDevice)
+        m_deviceName = m_pOutputMidiDevice->getName(); //Name of the device to look for the <controller> block for in the XML.
+
+    startupScriptEngine();
 #endif
     m_pMidiInputMappingTableModel = new MidiInputMappingTableModel(this);
     m_pMidiOutputMappingTableModel = new MidiOutputMappingTableModel(this);
 }
 
 MidiMapping::~MidiMapping() {
-#ifdef __MIDISCRIPT__
-    // Call each script's shutdown function if it exists
-    QListIterator<QString> prefixIt(m_pScriptFunctionPrefixes);
-    while (prefixIt.hasNext()) {
-        QString shutName = prefixIt.next();
-        if (shutName!="") {
-            shutName.append(".shutdown");
-            qDebug() << "MidiMapping: Executing" << shutName;
-            if (!m_pScriptEngine->execute(shutName))
-                qWarning() << "MidiMapping: No" << shutName << "function in script";
-        }
-    }
+
+}
+
+#ifdef __MIDISCRIPT__
+void MidiMapping::startupScriptEngine() {
+
+    if(m_pScriptEngine) return;
+
+    //XXX Deadly hack attack:
+    if (m_pOutputMidiDevice == NULL) {
+        m_pOutputMidiDevice = new MidiDeviceDummy(this); //Just make some dummy device :(
+    }
+    //XXX Memory leak :(
+
+    qDebug () << "Starting script engine with output device" << m_pOutputMidiDevice->getName();
+
+    m_pScriptEngine = new MidiScriptEngine(m_pOutputMidiDevice);
+
+    m_pScriptEngine->moveToThread(m_pScriptEngine);
+
+    connect(m_pScriptEngine, SIGNAL(initialized()),
+            this, SLOT(slotScriptEngineReady()),
+            Qt::DirectConnection);
+    m_scriptEngineInitializedMutex.lock();
+    m_pScriptEngine->start();
+    // Wait until the script engine is initialized
+    m_scriptEngineInitializedCondition.wait(&m_scriptEngineInitializedMutex);
+    m_scriptEngineInitializedMutex.unlock();
+
+}
+
+void MidiMapping::loadScriptCode() {
+        ConfigObject<ConfigValue> *config = new ConfigObject<ConfigValue>(QDir::homePath().append("/").append(SETTINGS_PATH).append(SETTINGS_FILE));
+
+        qDebug() << "MidiMapping: Loading & evaluating all MIDI script code";
+
+        QListIterator<QString> it(m_pScriptFileNames);
+        while (it.hasNext()) {
+            QString curScriptFileName = it.next();
+            m_pScriptEngine->evaluate(config->getConfigPath().append("midi/").append(curScriptFileName));
+
+            if(m_pScriptEngine->hasErrors(curScriptFileName)) {
+                qDebug() << "Errors occured while loading " << curScriptFileName;
+            }
+        }
+}
+
+void MidiMapping::initializeScripts() {
+    if(m_pScriptEngine) {
+        // Call each script's init function if it exists
+        QListIterator<QString> prefixIt(m_pScriptFunctionPrefixes);
+        while (prefixIt.hasNext()) {
+            QString initName = prefixIt.next();
+            if (initName!="") {
+                initName.append(".init");
+                qDebug() << "MidiMapping: Executing" << initName;
+                if (!m_pScriptEngine->execute(initName, m_deviceName))
+                    qWarning() << "MidiMapping: No" << initName << "function in script";
+            }
+        }
+    }
+}
+
+void MidiMapping::shutdownScriptEngine() {
+    if(m_pScriptEngine) {
+        // Call each script's shutdown function if it exists
+        QListIterator<QString> prefixIt(m_pScriptFunctionPrefixes);
+        while (prefixIt.hasNext()) {
+            QString shutName = prefixIt.next();
+            if (shutName!="") {
+                shutName.append(".shutdown");
+                qDebug() << "MidiMapping: Executing" << shutName;
+                if (!m_pScriptEngine->execute(shutName))
+                    qWarning() << "MidiMapping: No" << shutName << "function in script";
+            }
+        }
+        qDebug() << "MidiMapping: Deleting MIDI script engine...";
+        MidiScriptEngine *engine = m_pScriptEngine;
+        m_pScriptEngine = NULL;
+        delete engine;
+    }
+}
+#endif
+
+void MidiMapping::setOutputMidiDevice(MidiDevice* outputMidiDevice)
+{
+    m_mappingLock.lock();
+    m_pOutputMidiDevice = outputMidiDevice;
+    m_mappingLock.unlock();
+#ifdef __MIDISCRIPT__
+    //Restart the script engine so it gets its pointer to the output MIDI device updated.
+    restartScriptEngine();
 #endif
 }
 
@@ -384,34 +484,41 @@
 }
 #endif
 
-/* loadInitialPreset()
- * Loads a set of MIDI bindings from either the default file or one specified on the command line.
+/* setName(QString)
+ * Sets the controller name this mapping corresponds to
+ * @param name The controller name this mapping is hooked to
  */
-void MidiMapping::loadInitialPreset() {
-    // Try to read in the current XML bindings file, one from the command line, or create one if nothing is available
-    QStringList commandLineArgs = QApplication::arguments();
-    int loadXML = commandLineArgs.indexOf("--loadXMLfile");
+void MidiMapping::setName(QString name) {
+    m_deviceName = name;
+}
 
-    if (loadXML!=-1) {
-        qDebug() << "MidiMapping: Loading custom MIDI mapping file:" << commandLineArgs.at(loadXML+1);
-        loadPreset(commandLineArgs.at(loadXML+1));
-    }
-    else loadPreset(BINDINGS_PATH);
-    applyPreset();
+/* loadPreset()
+ * Overloaded function for convenience, uses the default device path
+ * @param forceLoad Forces the MIDI mapping to be loaded, regardless of whether or not the controller id
+ *        specified in the mapping matches the device this MidiMapping object is hooked up to.
+ */
+void MidiMapping::loadPreset(bool forceLoad) {
+    loadPreset(DEFAULT_DEVICE_PRESET, forceLoad);
 }
 
 /* loadPreset(QString)
  * Overloaded function for convenience
+ * @param path The path to a MIDI mapping XML file.
+ * @param forceLoad Forces the MIDI mapping to be loaded, regardless of whether or not the controller id
+ *        specified in the mapping matches the device this MidiMapping object is hooked up to.
  */
-void MidiMapping::loadPreset(QString path) {
-    qDebug() << "MidiMapping: Loading MIDI XML from" << path;
-    loadPreset(WWidget::openXMLFile(path, "controller"));
+void MidiMapping::loadPreset(QString path, bool forceLoad) {
+    qDebug() << "MidiMapping: Loading MIDI preset from" << path;
+    loadPreset(WWidget::openXMLFile(path, "controller"), forceLoad);
 }
 
 /* loadPreset(QDomElement)
  * Loads a set of MIDI bindings from a QDomElement structure.
+ * @param root The root node of the XML document for the MIDI mapping.
+ * @param forceLoad Forces the MIDI mapping to be loaded, regardless of whether or not the controller id
+ *        specified in the mapping matches the device this MidiMapping object is hooked up to.
  */
-void MidiMapping::loadPreset(QDomElement root) {
+void MidiMapping::loadPreset(QDomElement root, bool forceLoad) {
     //qDebug() << QString("MidiMapping: loadPreset() called in thread ID=%1").arg(this->thread()->currentThreadId(),0,16);
 
     if (root.isNull()) return;
@@ -426,8 +533,6 @@
     m_mappingLock.lock();
 
 #ifdef __MIDISCRIPT__
-    m_rMidiObject.restartScriptEngine();
-    m_pScriptEngine = m_rMidiObject.getMidiScriptEngine();
     m_pScriptFileNames.clear();
     m_pScriptFunctionPrefixes.clear();
 #endif
@@ -435,19 +540,31 @@
     // For each controller in the DOM
     m_Bindings = root;
     QDomElement controller = m_Bindings.firstChildElement("controller");
+
+    // For each controller in the MIDI mapping XML...
+    //(Only parse the <controller> block if it's id matches our device name, otherwise
+    //keep looking at the next controller blocks....)
+    QString device;
     while (!controller.isNull()) {
-        // For each controller
         // Get deviceid
-        QString device = controller.attribute("id","");
-        qDebug() << device << " settings found" << endl;
-
+        device = controller.attribute("id","");
+        if (device != m_deviceName && !forceLoad) {
+            controller = controller.nextSiblingElement("controller");
+        }
+        else
+            break;
+    }
+
+    if (!controller.isNull()) {
+
+        qDebug() << device << " settings found";
 #ifdef __MIDISCRIPT__
+        // Build a list of MIDI script files to load
 
-        // Get a list of MIDI script files to load
         QDomElement scriptFile = controller.firstChildElement("scriptfiles").firstChildElement("file");
 
         // Default currently required file
-        addScriptFile(REQUIRED_MAPPING_FILE,"");
+        addScriptFile(REQUIRED_SCRIPT_FILE,"");
 
         // Look for additional ones
         while (!scriptFile.isNull()) {
@@ -458,33 +575,7 @@
             scriptFile = scriptFile.nextSiblingElement("file");
         }
 
-        // Load Script files
-        ConfigObject<ConfigValue> *config = new ConfigObject<ConfigValue>(QDir::homePath().append("/").append(SETTINGS_PATH).append(SETTINGS_FILE));
-
-        qDebug() << "MidiMapping: Loading & evaluating all MIDI script code";
-
-        QListIterator<QString> it(m_pScriptFileNames);
-        while (it.hasNext()) {
-            QString curScriptFileName = it.next();
-            m_pScriptEngine->evaluate(config->getConfigPath().append("midi/").append(curScriptFileName));
-
-            if(m_pScriptEngine->hasErrors(curScriptFileName)) {
-                qDebug() << "Errors occured while loading " << curScriptFileName;
-            }
-
-        }
-
-        // Call each script's init function if it exists
-        QListIterator<QString> prefixIt(m_pScriptFunctionPrefixes);
-        while (prefixIt.hasNext()) {
-            QString initName = prefixIt.next();
-            if (initName!="") {
-                initName.append(".init");
-                qDebug() << "MidiMapping: Executing" << initName;
-                if (!m_pScriptEngine->execute(initName, device))
-                    qWarning() << "MidiMapping: No" << initName << "function in script";
-            }
-        }
+        loadScriptCode();   // Actually load code from the list built above
 
         QStringList scriptFunctions = m_pScriptEngine->getScriptFunctions();
 
@@ -543,25 +634,33 @@
         }
 
         qDebug() << "MidiMapping: Output parsed!";
-        controller = controller.nextSiblingElement("controller");
+        //controller = controller.nextSiblingElement("controller"); //FIXME: Remove this line of code permanently - Albert
     }
 
     m_mappingLock.unlock();
 
 }   // END loadPreset(QDomElement)
 
+/* savePreset()
+ * Saves the current table of bindings to the default device XML file.
+ */
+void MidiMapping::savePreset() {
+    savePreset(DEFAULT_DEVICE_PRESET);
+}
+
 /* savePreset(QString)
  * Given a path, saves the current table of bindings to an XML file.
  */
 void MidiMapping::savePreset(QString path) {
+    qDebug() << "Writing MIDI preset file" << path;
     m_mappingLock.lock();
     QFile output(path);
     if (!output.open(QIODevice::WriteOnly | QIODevice::Truncate)) return;
     QTextStream outputstream(&output);
     // Construct the DOM from the table
-    buildDomElement();
+    QDomDocument docBindings = buildDomElement();
     // Save the DOM to the XML file
-    m_Bindings.save(outputstream, 4);
+    docBindings.save(outputstream, 4);
     output.close();
     m_mappingLock.unlock();
 }
@@ -571,21 +670,36 @@
  * the LED handler.
  */
 void MidiMapping::applyPreset() {
+    qDebug() << "MidiMapping::applyPreset()";
     m_mappingLock.lock();
     MidiLedHandler::destroyHandlers();
 
-    QDomElement controller = m_Bindings.firstChildElement("controller");
-    // For each device
-    while (!controller.isNull()) {
-        // Device Outputs - LEDs
-        QString deviceId = controller.attribute("id","");
-
-        qDebug() << "MidiMapping: Processing MIDI Output Bindings for" << deviceId;
-        MidiLedHandler::createHandlers(controller.namedItem("outputs").firstChild(),
-                                       m_rMidiObject, deviceId);
-
-        // Next device
-        controller = controller.nextSiblingElement("controller");
+#ifdef __MIDISCRIPT__
+    // Since this can be called after re-enabling a device without reloading the XML preset,
+    // the script engine must have its code loaded here as well
+    QStringList scriptFunctions = m_pScriptEngine->getScriptFunctions();
+    if (scriptFunctions.isEmpty()) loadScriptCode();
+
+    initializeScripts();
+#endif
+
+    if (m_pOutputMidiDevice != NULL) {
+        //^^^ Only execute this code if we have an output device hooked up
+        //    to this MidiMapping...
+
+        QDomElement controller = m_Bindings.firstChildElement("controller");
+        // For each device
+        while (!controller.isNull()) {
+            // Device Outputs - LEDs
+            QString deviceId = controller.attribute("id","");
+
+            qDebug() << "MidiMapping: Processing MIDI Output Bindings for" << deviceId;
+            MidiLedHandler::createHandlers(controller.namedItem("outputs").firstChild(),
+                                           *m_pOutputMidiDevice);
+
+            // Next device
+            controller = controller.nextSiblingElement("controller");
+        }
     }
     m_mappingLock.unlock();
 }
@@ -606,69 +720,96 @@
 /* buildDomElement()
  * Updates the DOM with what is currently in the table
  */
- void MidiMapping::buildDomElement() {
-     // We should hold the mapping lock.
-
-     clearPreset(); // Create blank document
-
-     const QString wtfbbqdevicename = "Last used";
+ QDomDocument MidiMapping::buildDomElement() {
+     // We should hold the mapping lock. The lock is recursive so if we already
+     // hold it it will relock.
+     m_mappingLock.lock();
+
+    clearPreset(); // Create blank document
+
+    QDomDocument doc("Bindings");
+    QString blank = "<MixxxMIDIPreset schemaVersion=\"" + QString(XML_SCHEMA_VERSION) + "\" mixxxVersion=\"" + QString(VERSION) + "+\">\n"
+                    "</MixxxMIDIPreset>\n";
+
+    doc.setContent(blank);
+
+    QDomElement rootNode = doc.documentElement();
+    QDomElement controller = doc.createElement("controller");
+    controller.setAttribute("id", m_deviceName.right(m_deviceName.size()-m_deviceName.indexOf(" ")-1));
+    rootNode.appendChild(controller);
+
 #ifdef __MIDISCRIPT__
-      //This sucks, put this code inside MidiScriptEngine instead of here,
-      // and just ask MidiScriptEngine to spit it out for us.
-     qDebug() << "MidiMapping: Writing script block!";
-     for (int i = 0; i < m_pScriptFileNames.count(); i++) {
-         qDebug() << "MidiMapping: writing script block for" << m_pScriptFileNames[i];
-          QString filename = m_pScriptFileNames[i];
-          if (filename != REQUIRED_MAPPING_FILE) { //Don't need to write anything for the required mapping file.
-              QString functionPrefix = m_pScriptFunctionPrefixes[i];
-              //and now for the worst XML code since... WWidget...
-              QDomDocument sucksBalls;
-              QDomElement scriptFile = sucksBalls.createElement("file");
-              scriptFile.setAttribute("filename", filename);
-              scriptFile.setAttribute("functionprefix", functionPrefix);
-
-              //Add the XML dom element to the right spot in the XML document.
-              addMidiScriptInfo(scriptFile, wtfbbqdevicename);
-          }
-     }
+    //This sucks, put this code inside MidiScriptEngine instead of here,
+    // and just ask MidiScriptEngine to spit it out for us.
+//     qDebug() << "MidiMapping: Writing script block!";
+
+    QDomElement scriptFiles = doc.createElement("scriptfiles");
+    controller.appendChild(scriptFiles);
+
+
+    for (int i = 0; i < m_pScriptFileNames.count(); i++) {
+//         qDebug() << "MidiMapping: writing script block for" << m_pScriptFileNames[i];
+        QString filename = m_pScriptFileNames[i];
+
+
+        //Don't need to write anything for the required mapping file.
+        if (filename != REQUIRED_SCRIPT_FILE) {
+            qDebug() << "MidiMapping: writing script block for" << filename;
+            QString functionPrefix = m_pScriptFunctionPrefixes[i];
+            QDomElement scriptFile = doc.createElement("file");
+
+
+            scriptFile.setAttribute("filename", filename);
+            scriptFile.setAttribute("functionprefix", functionPrefix);
+
+            scriptFiles.appendChild(scriptFile);
+        }
+    }
 #endif
 
+    QDomElement controls = doc.createElement("controls");
+    controller.appendChild(controls);
+
+
     //Iterate over all of the command/control pairs in the input mapping
-     QHashIterator<MidiMessage, MixxxControl> it(m_inputMapping);
-     while (it.hasNext()) {
-         it.next();
-         QDomElement controlNode;
-         QDomDocument nodeMaker;
-
-         //Create <control> block
-         controlNode = nodeMaker.createElement("control");
-
-         //Save the MidiMessage and MixxxControl objects as XML
-         it.key().serializeToXML(controlNode);
-         it.value().serializeToXML(controlNode);
-
-          //Add the control node we just created to the XML document in the proper spot
-         addControl(controlNode, wtfbbqdevicename); //FIXME: Remove this device shit until we have multiple device support.
-     }
-
-     //Iterate over all of the control/command pairs in the OUTPUT mapping
-     QHashIterator<MixxxControl, MidiMessage> outIt(m_outputMapping);
-     while (outIt.hasNext()) {
-         outIt.next();
-         QDomElement outputNode;
-         QDomDocument nodeMaker;
-
-         //Create <output> block
-         outputNode = nodeMaker.createElement("output");
-
-         //Save the MidiMessage and MixxxControl objects as XML
-         outIt.key().serializeToXML(outputNode, true);
-         outIt.value().serializeToXML(outputNode, true);
-
-          //Add the control node we just created to the XML document in the proper spot
-         addOutput(outputNode, wtfbbqdevicename); //FIXME: Remove this device shit until we have multiple device support.
-     }
- }
+    QHashIterator<MidiMessage, MixxxControl> it(m_inputMapping);
+    while (it.hasNext()) {
+        it.next();
+
+        QDomElement controlNode = doc.createElement("control");
+
+        //Save the MidiMessage and MixxxControl objects as XML
+        it.key().serializeToXML(controlNode);
+        it.value().serializeToXML(controlNode);
+
+        //Add the control node we just created to the XML document in the proper spot
+        controls.appendChild(controlNode);
+    }
+
+
+    QDomElement outputs = doc.createElement("outputs");
+    controller.appendChild(outputs);
+
+    //Iterate over all of the control/command pairs in the OUTPUT mapping
+    QHashIterator<MixxxControl, MidiMessage> outIt(m_outputMapping);
+    while (outIt.hasNext()) {
+        outIt.next();
+
+        QDomElement outputNode = doc.createElement("output");
+
+
+        //Save the MidiMessage and MixxxControl objects as XML
+        outIt.key().serializeToXML(outputNode, true);
+        outIt.value().serializeToXML(outputNode, true);
+
+        //Add the control node we just created to the XML document in the proper spot
+        outputs.appendChild(outputNode);
+    }
+
+    m_mappingLock.unlock();
+
+    return doc;
+}
 
 /* -------- ------------------------------------------------------
    Purpose: Adds an input MIDI mapping block to the XML.
@@ -954,3 +1095,23 @@
     m_controlToLearn = MixxxControl();
     m_mappingLock.unlock();
 }
+
+#ifdef __MIDISCRIPT__
+void MidiMapping::restartScriptEngine()
+{
+    shutdownScriptEngine();
+    startupScriptEngine();
+}
+#endif
+
+void MidiMapping::slotScriptEngineReady() {
+#ifdef __MIDISCRIPT__	// Can't ifdef slots in the .h file, so we just do the body.
+
+    // The lock prevents us from waking before the main thread is waiting on the
+    // condition.
+    m_scriptEngineInitializedMutex.lock();
+    m_scriptEngineInitializedCondition.wakeAll();
+    m_scriptEngineInitializedMutex.unlock();
+
+#endif
+}

=== renamed file 'mixxx/src/midimapping.h' => 'mixxx/src/midi/midimapping.h'
--- mixxx/src/midimapping.h	2009-07-15 02:32:40 +0000
+++ mixxx/src/midi/midimapping.h	2009-11-10 00:33:17 +0000
@@ -4,6 +4,7 @@
                            -------------------
     begin                : Sat Jan 17 2009
     copyright            : (C) 2009 Sean M. Pappalardo
+                           (C) 2009 Albert Santoni
     email                : [e-mail]
 
 ***************************************************************************/
@@ -20,7 +21,7 @@
 #ifndef MIDIMAPPING_H
 #define MIDIMAPPING_H
 
-#include "midiobject.h"
+#include "mididevice.h"
 #include "midimessage.h"
 #include "mixxxcontrol.h"
 #include "midiinputmapping.h"
@@ -28,14 +29,14 @@
 #include <QTableWidget>
 
 #ifdef __MIDISCRIPT__
-#include "script/midiscriptengine.h"
+#include "midiscriptengine.h"
 #endif
 
 //Forward declarations
 class MidiInputMappingTableModel;
 class MidiOutputMappingTableModel;
 
-#define BINDINGS_PATH QDir::homePath().append("/").append(SETTINGS_PATH).append("MixxxMIDIBindings.xml")
+#define BINDINGS_PATH QDir::homePath().append("/").append(SETTINGS_PATH).append("midi/")
 #define MIDI_MAPPING_EXTENSION ".midi.xml"
 
 class MidiMapping : public QObject
@@ -44,14 +45,18 @@
 
     public:
     /** Constructor also loads & applies the default XML MIDI mapping file */
-    MidiMapping(MidiObject &midi_object);
+    MidiMapping(MidiDevice* outputMidiDevice=NULL);
     ~MidiMapping();
-
-    void loadInitialPreset();
-    void loadPreset(QString path);
-    void loadPreset(QDomElement root);
-
-    void savePreset(QString path = BINDINGS_PATH);
+    void setOutputMidiDevice(MidiDevice* outputMidiDevice);
+    
+    void setName(QString name);
+
+    void loadPreset(bool forceLoad=false);
+    void loadPreset(QString path, bool forceLoad=false);
+    void loadPreset(QDomElement root, bool forceLoad=false);
+
+    void savePreset();
+    void savePreset(QString path);
     void applyPreset();
     
     
@@ -87,12 +92,20 @@
     void clearOutputMidiMapping(int index);
     void clearOutputMidiMapping(MixxxControl control);
     void clearOutputMidiMapping(int index, int count);
+#ifdef __MIDISCRIPT__
+    void initializeScripts();
+    void startupScriptEngine();
+    void shutdownScriptEngine();
+    void restartScriptEngine();
+    MidiScriptEngine *getMidiScriptEngine() { return m_pScriptEngine; };
+#endif
 
 public slots:
     void finishMidiLearn(MidiMessage message);
     void beginMidiLearn(MixxxControl control);
     void cancelMidiLearn();
-
+    void slotScriptEngineReady();
+    
 signals:
     void inputMappingChanged();
     void inputMappingChanged(int startIndex, int endIndex);
@@ -115,7 +128,7 @@
                                       MidiMessage command,
                                       bool shouldEmit);
     void clearPreset();
-    void buildDomElement();
+    QDomDocument buildDomElement();
     void addControl(QDomElement& control, QString device);
     void addOutput(QDomElement& output, QString device);
     void addMidiScriptInfo(QDomElement &scriptFile, QString device); //Sucks
@@ -129,19 +142,27 @@
 #ifdef __MIDISCRIPT__
     /** Adds a script file name and function prefix to the list to be loaded */
     void addScriptFile(QString filename, QString functionprefix);
+    /** Actually loads script code from the files in the list */
+    void loadScriptCode();
 
     QList<QString> m_pScriptFileNames;
     QList<QString> m_pScriptFunctionPrefixes;
     MidiScriptEngine *m_pScriptEngine;
+
+    QMutex m_scriptEngineInitializedMutex;
+    QWaitCondition m_scriptEngineInitializedCondition;
 #endif
     QMutex m_mappingLock;
     QDomElement m_Bindings;
-    MidiObject &m_rMidiObject;
     MidiInputMapping m_inputMapping;
     MidiOutputMapping m_outputMapping;
     MidiInputMappingTableModel* m_pMidiInputMappingTableModel;
     MidiOutputMappingTableModel* m_pMidiOutputMappingTableModel;
     MixxxControl m_controlToLearn;
+    QString m_deviceName; /** Name of the device to look for in the <controller> XML nodes... */
+    MidiDevice* m_pOutputMidiDevice; /** We need a pointer back to an _output_ MIDI device so our
+                                         LED handlers know where to fire MIDI messages. Note that
+                                         this can be NULL if there is no output MIDI device! */
 };
 
 #endif

=== renamed file 'mixxx/src/midimessage.cpp' => 'mixxx/src/midi/midimessage.cpp'
=== renamed file 'mixxx/src/midimessage.h' => 'mixxx/src/midi/midimessage.h'
--- mixxx/src/midimessage.h	2009-04-19 17:25:23 +0000
+++ mixxx/src/midi/midimessage.h	2009-11-10 00:33:17 +0000
@@ -16,6 +16,18 @@
     MIDI_STATUS_PITCH_BEND = 0xE0,
 } MidiStatusByte;
   
+ // This enum is used in the decoding of the status message into voice categories
+// This is just cruft leftover from ages ago, unfortunately. Hasn't been properly removed/refactored yet.
+typedef enum {
+    NOTE_OFF         = 0x80,
+    NOTE_ON          = 0x90,
+    AFTERTOUCH       = 0xA0,
+    CTRL_CHANGE      = 0xB0,
+    PROG_CHANGE      = 0xC0,
+    CHANNEL_PRESSURE = 0xD0,
+    PITCH_WHEEL      = 0xE0,
+} MidiCategory; 
+  
   /** The key used in the MIDI mapping hash table */
   class MidiMessage
   {

=== renamed file 'mixxx/src/midinodelegate.cpp' => 'mixxx/src/midi/midinodelegate.cpp'
=== renamed file 'mixxx/src/midinodelegate.h' => 'mixxx/src/midi/midinodelegate.h'
=== renamed file 'mixxx/src/midioptiondelegate.cpp' => 'mixxx/src/midi/midioptiondelegate.cpp'
=== renamed file 'mixxx/src/midioptiondelegate.h' => 'mixxx/src/midi/midioptiondelegate.h'
=== renamed file 'mixxx/src/midioutputmapping.h' => 'mixxx/src/midi/midioutputmapping.h'
=== renamed file 'mixxx/src/midioutputmappingtablemodel.cpp' => 'mixxx/src/midi/midioutputmappingtablemodel.cpp'
=== renamed file 'mixxx/src/midioutputmappingtablemodel.h' => 'mixxx/src/midi/midioutputmappingtablemodel.h'
=== renamed file 'mixxx/src/script/midiscriptengine.cpp' => 'mixxx/src/midi/midiscriptengine.cpp'
--- mixxx/src/script/midiscriptengine.cpp	2009-08-11 04:38:51 +0000
+++ mixxx/src/midi/midiscriptengine.cpp	2009-11-10 00:33:17 +0000
@@ -16,11 +16,11 @@
  *                                                                         *
  ***************************************************************************/
 
-#include <qapplication.h>
-
-#include "midiscriptengine.h"
 #include "controlobject.h"
 #include "controlobjectthread.h"
+#include "mididevice.h"
+#include "midiscriptengine.h"
+
 
 #ifdef _MSC_VER
 #include <float.h>  // for _isnan() on VC++
@@ -30,9 +30,9 @@
 #endif
 
 
-MidiScriptEngine::MidiScriptEngine(MidiObject* midi_object) :
+MidiScriptEngine::MidiScriptEngine(MidiDevice* midiDevice) :
     m_pEngine(NULL),
-    m_pMidiObject(midi_object)
+    m_pMidiDevice(midiDevice)
 {
 }
 
@@ -88,11 +88,13 @@
     //qDebug() << "MidiScriptEngine::run() m_pEngine->parent() is " << m_pEngine->parent();
     //qDebug() << "MidiScriptEngine::run() m_pEngine->thread() is " << m_pEngine->thread();
 
+    qDebug() << "MIDI Device in script engine is:" << m_pMidiDevice->getName();
+
     // Make this MidiScriptEngine instance available to scripts as
     // 'engine'.
     QScriptValue engineGlobalObject = m_pEngine->globalObject();
     engineGlobalObject.setProperty("engine", m_pEngine->newQObject(this));
-    engineGlobalObject.setProperty("midi", m_pEngine->newQObject(m_pMidiObject));
+    engineGlobalObject.setProperty("midi", m_pEngine->newQObject(m_pMidiDevice));
 
 }
 
@@ -162,9 +164,10 @@
    -------- ------------------------------------------------------ */
 bool MidiScriptEngine::execute(QString function, char channel,
                                char control, char value,
-                               MidiStatusByte status) {
+                               MidiStatusByte status,
+                               QString group) {
     m_scriptEngineLock.lock();
-    bool ret = safeExecute(function, channel, control, value, status);
+    bool ret = safeExecute(function, channel, control, value, status, group);
     m_scriptEngineLock.unlock();
     return ret;
 }
@@ -237,7 +240,8 @@
    -------- ------------------------------------------------------ */
 bool MidiScriptEngine::safeExecute(QString function, char channel,
                                    char control, char value,
-                                   MidiStatusByte status) {
+                                   MidiStatusByte status,
+                                   QString group) {
     //qDebug() << QString("MidiScriptEngine: Exec2 Thread ID=%1").arg(QThread::currentThreadId(),0,16);
 
     if(m_pEngine == NULL) {
@@ -261,6 +265,7 @@
     args << QScriptValue(m_pEngine, control);
     args << QScriptValue(m_pEngine, value);
     args << QScriptValue(m_pEngine, status);
+    args << QScriptValue(m_pEngine, group);
 
     scriptFunction.call(QScriptValue(), args);
     if (checkException())
@@ -338,7 +343,7 @@
 
         if (line.indexOf('#') != 0 && line.indexOf("//") != 0) {    // ignore commented out lines
             QStringList field = line.split(" ");
-            qDebug() << "MidiScriptEngine: Found function:" << field[0] << "at line" << position;