--- src/SConscript.orig	1969-12-31 16:00:00.000000000 -0800
+++ src/SConscript	2008-04-09 01:00:05.000000000 -0700
@@ -0,0 +1,1067 @@
+import os
+import sys
+import glob
+import SCons
+import shutil
+
+# BIG FAT WARNING:
+# Make sure you use TABS for indentation, NOT spaces! (Python doesn't like spaces, be forewarned!)
+#
+#   ####       ####  ##########  #####    #####  #####    #####  #####    #####
+#   ######   ######     ####      #####  #####    #####  #####    #####  #####
+#   #### ## ## ####     ####        ########        ########        ########
+#   ####   #   ####     ####      #####  #####    #####  #####    #####  #####
+#   ####       ####  ##########  #####    #####  #####    #####  #####    #####
+#
+#  #############################################################################
+#    #########################################################################
+#
+
+#
+#Useful functions
+#
+
+def getSVNRevision(): # GPL code taken from http://trac.zeitherrschaft.org/zzub/browser/trunk/SConstruct
+	# if this is a repository, take the string from svnversion
+	svnversionpath = env.WhereIs('svnversion', os.environ['PATH'])
+	if os.path.isdir('../.svn') and (svnversionpath != None):  # we always start in .obj for some reason, so we must use ../.svn
+		rev = os.popen('svnversion ..').readline().strip()
+		if rev != "" and rev != "exported":
+			return rev
+	return ""
+
+#Checks for OpenGL on all three platforms
+def CheckOpenGL():
+	if not conf.CheckLib('GL') and not conf.CheckLib('opengl32') and not conf.CheckCHeader('/System/Library/Frameworks/OpenGL.framework/Versions/A/Headers/gl.h'):
+		print 'Did not find OpenGL development files, exiting!'
+		Exit(1)
+
+	if not conf.CheckLib('GLU') and not conf.CheckLib('glu32') and not conf.CheckCHeader('/System/Library/Frameworks/OpenGL.framework/Versions/A/Headers/glu.h'):
+		print 'Did not find GLU development files, exiting!'
+		Exit(1)
+	#Workaround for SCONS not detecting frameworks on OS X
+	if platform == 'osx':
+		env.Append(LINKFLAGS = '-framework OpenGL')
+
+	return
+
+#Checks for OGG/Vorbis on all three platforms
+def CheckOggVorbis():
+	#Check for Ogg and Vorbis on Linux, OS X, and Win32
+	if not conf.CheckLib('vorbisfile'):
+		print 'Did not find libvorbisfile.a, libvorbisfile.lib, or the libvorbisfile development headers, exiting!'
+		Exit(1)
+
+	if not conf.CheckLib('vorbis'):
+		print 'Did not find libvorbis.a, libvorbis.lib, or the libvorbisfile development headers, exiting!'
+		Exit(1)
+
+	if not conf.CheckLib('ogg'):
+		print 'Did not find libogg.a, libogg.lib, or the libogg development headers, exiting!'
+		Exit(1)
+
+# This function is here for historical reasons. It used to be easiest to build
+# Mixxx on OS X using the Vorbis and OGG "frameworks", and so this function
+# used to have some OS X-specific stuff in it. If you're building on OS X now
+# though, just install libvorbis and libogg from source.
+
+	return
+
+#Check for FFMPEG support
+def CheckFFMPEG(conf, sources):
+	flags_ffmpeg = ARGUMENTS.get('ffmpeg', 0)
+	if int(flags_ffmpeg):
+		if platform == 'linux':
+			#Check for libavcodec, libavformat
+			#I just randomly picked version numbers lower than mine for this - Albert
+			if not conf.CheckForPKG('libavcodec', '51.20.0'):
+				print 'libavcodec not found.'
+				Exit(1)
+			if not conf.CheckForPKG('libavformat', '51.1.0'):
+				print 'libavcodec not found.'
+				Exit(1)
+			else:
+				#Grabs the libs and cflags for ffmpeg
+				env.ParseConfig('pkg-config libavcodec --silence-errors --cflags --libs') 
+				env.ParseConfig('pkg-config libavformat --silence-errors --cflags --libs') 
+				env.Append(CXXFLAGS = '-D__FFMPEGFILE__')
+		else:
+			# aptitude install libavcodec-dev libavformat-dev liba52-0.7.4-dev libdts-dev
+			env.Append(LIBS = 'avcodec')
+			env.Append(LIBS = 'avformat')
+			env.Append(LIBS = 'z')
+			env.Append(LIBS = 'a52')
+			env.Append(LIBS = 'dts')
+			env.Append(LIBS = 'gsm')
+			env.Append(LIBS = 'dc1394_control')
+			env.Append(LIBS = 'dl')
+			env.Append(LIBS = 'vorbisenc')
+			env.Append(LIBS = 'raw1394')
+			env.Append(LIBS = 'avutil')
+			env.Append(LIBS = 'vorbis')
+			env.Append(LIBS = 'm')
+			env.Append(LIBS = 'ogg')
+			env.Append(CXXFLAGS = '-D__FFMPEGFILE__')
+		sources += Split("""soundsourceffmpeg.cpp """)
+		print "Not working FFMPEG support... enabled"
+	else:
+		print "Not working FFMPEG support... disabled"
+	return	
+
+
+# Checks for pkg-config on Linux
+def CheckForPKGConfig( context, version='0.0.0' ):
+	context.Message( "Checking for pkg-config (at least version %s)... " % version )
+	ret = context.TryAction( "pkg-config --atleast-pkgconfig-version=%s" %version )[0]
+	context.Result( ret )
+	return ret
+
+# Uses pkg-config to check for a minimum version
+def CheckForPKG( context, name, version="" ):
+	if version == "":
+		context.Message( "Checking for %s... \t" % name )
+		ret = context.TryAction( "pkg-config --exists '%s'" % name )[0]
+	else:
+		context.Message( "Checking for %s (%s or higher)... \t" % (name,version) )
+		ret = context.TryAction( "pkg-config --atleast-version=%s '%s'" % (version,name) )[0]
+		context.Result( ret )
+	return ret
+	
+
+def flatten(x):
+	"""flatten(sequence) -> list
+
+	Returns a single, flat list which contains all elements retrieved
+	from the sequence and all recursively contained sub-sequences
+    (iterables).
+
+    Examples:
+    >>> [1, 2, [3,4], (5,6)]
+    [1, 2, [3, 4], (5, 6)]
+    >>> flatten([[[1,2,3], (42,None)], [4,5], [6], 7, MyVector(8,9,10)])
+    [1, 2, 3, 42, None, 4, 5, 6, 7, 8, 9, 10]"""
+
+	result = []
+	for el in x:
+		#if isinstance(el, (list, tuple)):
+		if hasattr(el, "__iter__"):
+			result.extend(flatten(el))
+		else:
+			result.append(el)
+	return result
+
+def getFlags(env, argflag, default=0):
+	"""
+	* get value passed as an argument to scons as argflag=value
+	* if no value is passed to scons use stored value
+	* if no value is stored, use default
+	Returns the value and stores it in env[argflag]
+	"""
+	flags = ARGUMENTS.get(argflag, -1)
+	if int(flags) < 0:
+		if env.has_key(argflag):
+			flags = env[argflag]
+		else: #default value
+			flags = default
+	env[argflag] = flags
+	return flags
+1
+###### MAIN LINE ######
+#######################
+#Get the platform/OS that we're building on:
+if os.name == 'nt':
+	print 'Platform: Windows'
+	platform = 'win32'
+elif sys.platform == 'linux2':
+	print 'Platform: Linux'
+	platform = 'linux'
+elif sys.platform == 'darwin':
+	print 'Platform: OS X'
+	platform = 'osx'
+else:
+	print 'Platform: Unknown (assuming Linux-like)'
+	platform = 'linux'
+
+#Figure out what the QT path is
+if platform == 'linux':
+	default_qtdir = '/usr/share/qt4'
+elif platform == 'osx':
+	default_qtdir = '/usr/local/Trolltech/Qt-4.3.2/'
+elif platform == 'win32':
+	default_qtdir = 'C:\\qt\\4.3.0'
+
+#Read the qtdir flag, if it was set explicitly
+flags_qtdir = ARGUMENTS.get('qtdir', default_qtdir)
+if not os.path.exists(flags_qtdir) and platform != 'osx': #OS X doesn't have a qt path.
+	print "Error: QT path does not exist or QT4 is not installed."
+	print "Please specify your QT path by running 'scons qtdir=[path]'"
+	Exit(1)
+elif flags_qtdir.find("qt3") != -1 or flags_qtdir.find("qt/3") != -1:
+	print "Error: Mixxx now requires QT4 instead of QT3 - please use your QT4 path with the qtdir build flag."
+	Exit(1)
+else:
+	print "QT path: " + flags_qtdir
+
+#Set up our environment, tell SCONS to use it's QT tools, and set some enviroment variables for it.
+#The ENV = os.environ part pulls in your existing environment variables. This is useful for awkward Linux setups
+#and on Windows where all the paths are set in the shell.
+if platform == 'linux' or platform == 'osx':
+	env = Environment(tools=['default','qt4', 'msvs'], toolpath=['../', './'], QTDIR=flags_qtdir, QT_LIB='', ENV = os.environ)
+elif platform == 'win32':
+	#Pull in the environment's variables for win32...
+	env = Environment(tools=['default','qt4', 'msvs'], toolpath=['../', './'], QTDIR=flags_qtdir, QT_LIB='', VCINSTALLDIR = os.getenv('VCInstallDir'), ENV = os.environ)
+#	env.Append(LIBPATH = (flags_qtdir + "/plugins/iconengines"))
+
+## Global cache directory
+## Put all project files in it so a rm -rf cache will clean up the config
+if not env.has_key('CACHEDIR'):
+  env['CACHEDIR'] =os.getcwd()+ '/../../cache/'
+if not os.path.isdir(env['CACHEDIR']):
+  os.mkdir(env['CACHEDIR'])
+
+## Avoid spreading .sconsign files everywhere - keep this line
+env.SConsignFile(env['CACHEDIR']+'/scons_signatures')
+
+#Hijack scons -h and --help
+cachefile = env['CACHEDIR'] + 'custom.py'
+opts = Options(cachefile)
+opts.Add('prefix', 'Set to your install prefix', '/usr/local')
+opts.Add('qtdir', 'Set to your QT4 directory', '/usr/share/qt4')
+opts.Add('djconsole', 'Set to 1 to enable Hercules support through libdjconsole', 0)
+opts.Add('djconsole_legacy', 'Set to 1 to enable legacy Hercules support (for Hercules MP3 Control only, not MK2', 0)
+opts.Add('hifieq', 'Set to 1 to enable high quality EQs', 1)
+opts.Add('ladspa', '(EXPERIMENTAL) Set to 1 to enable LADSPA plugin support', 0)
+opts.Add('ffmpeg', '(EXPERIMENTAL) Set to 1 to enable FFMPEG support', 0)
+opts.Add('vinylcontrol', 'Set to 1 to enable vinyl control support', 1)
+opts.Add('shoutcast', 'Set to 1 to enable shoutcast support', 0)
+opts.Add('msvshacks', 'Set to 1 to build properly with MS Visual Studio 2005 (Express users should leave this off)', 0)
+opts.Add('cmetrics', 'Set to 1 to enable crash reporting/usage statistics via Case Metrics (This should be disabled on development builds)', 0)
+opts.Add('optimize', 'Set to 1 to enable -O3 compiler optimizations. Set to 2 to enable Pentium 4 optimizations.', 1)
+if not platform == 'win32':
+	opts.Add('gprof', '(DEVELOPER) Set to 1 to enable profiling using gprof', 0)
+	opts.Add('tuned', '(EXPERIMENTAL) Set to 1 to optimise mixxx for this CPU', 0)
+#env = Environment(options = opts)
+opts.Update(env)
+Help(opts.GenerateHelpText(env))
+
+# user-defined CXXFLAGS
+if os.environ.has_key('CXXFLAGS'):
+	env.Append(CXXFLAGS = SCons.Util.CLVar( os.environ['CXXFLAGS'] ))
+
+### embed SVN version into build
+build_rev = getSVNRevision()
+### Old way - causes everything to be rebuilt each time the SVN ver moves. :(
+#if build_rev != '': 
+# 	env.Append(CXXFLAGS = '-DBUILD_REV=\\"' + build_rev + '\\"')
+### Put version info into a file, so it doesn't force a rebuild of everything :)
+f = open("../.mixxx_version.svn","w")
+try:
+	f.write('#define BUILD_REV "' + build_rev + '"\n')
+finally:
+	f.close()
+
+#Mixxx sources to build
+sources = Split("""enginebuffercue.cpp input.cpp mixxxmenuplaylists.cpp trackplaylistlist.cpp mixxxkeyboard.cpp configobject.cpp controlobjectthread.cpp
+ controlobjectthreadwidget.cpp controlobjectthreadmain.cpp controlevent.cpp controllogpotmeter.cpp controlobject.cpp controlnull.cpp controlpotmeter.cpp
+ controlpushbutton.cpp controlttrotary.cpp controlbeat.cpp dlgpreferences.cpp dlgprefsound.cpp dlgprefmidi.cpp dlgprefplaylist.cpp dlgprefcontrols.cpp dlgbpmtap.cpp dlgprefbpm.cpp dlgbpmscheme.cpp dlgabout.cpp
+ dlgprefeq.cpp dlgprefcrossfader.cpp enginebuffer.cpp enginebufferscale.cpp enginebufferscalelinear.cpp engineclipping.cpp enginefilterblock.cpp enginefilteriir.cpp  enginefilter.cpp engineobject.cpp
+ enginepregain.cpp enginevolume.cpp main.cpp midiobject.cpp midiobjectnull.cpp mixxx.cpp mixxxview.cpp
+ soundsourcemp3.cpp soundsourceoggvorbis.cpp enginechannel.cpp enginemaster.cpp wwidget.cpp wpixmapstore.cpp wlabel.cpp wnumber.cpp wnumberpos.cpp wnumberrate.cpp wnumberbpm.cpp wknob.cpp wdisplay.cpp wvumeter.cpp wpushbutton.cpp wslidercomposed.cpp wslider.cpp  wstatuslight.cpp enginedelay.cpp engineflanger.cpp enginespectralfwd.cpp mathstuff.cpp readerextract.cpp readerextractwave.cpp
+ readerevent.cpp rtthread.cpp windowkaiser.cpp probabilityvector.cpp reader.cpp enginevumeter.cpp peaklist.cpp rotary.cpp log.cpp
+ track.cpp trackcollection.cpp trackplaylist.cpp wtracktableview.cpp wtracktablemodel.cpp proxymodel.cpp xmlparse.cpp trackimporter.cpp parser.cpp parserpls.cpp parserm3u.cpp
+ enginetemporal.cpp visual/visualbuffertemporal.cpp wavesummary.cpp bpmdetector.cpp bpmdetect.cpp bpmscheme.cpp  peakfinder.cpp wavesegmentation.cpp soundsourceproxy.cpp woverview.cpp enginebeatseek.cpp
+ enginebufferscalereal.cpp powermate.cpp  hercules.cpp joystick.cpp mouse.cpp
+ wvisualsimple.cpp wvisualwaveform.cpp visual/visualbackplane.cpp visual/texture.cpp visual/visualbox.cpp visual/visualbuffer.cpp visual/visualbuffersignal.cpp
+ visual/visualbuffersignalhfc.cpp visual/visualbuffermarks.cpp visual/visualchannel.cpp visual/visualcontroller.cpp visual/visualdisplay.cpp visual/visualdisplaybuffer.cpp
+ visual/light.cpp visual/material.cpp visual/picking.cpp visual/pickable.cpp visual/visualobject.cpp
+ imginvert.cpp imgloader.cpp imgcolor.cpp wskincolor.cpp
+ trackinfoobject.cpp soundsource.cpp
+ midiledhandler.cpp
+ sounddevice.cpp soundmanager.cpp sounddeviceportaudio.cpp
+ enginevinylsoundemu.cpp enginesidechain.cpp wtracktablefilter.cpp
+ wplaylistlistmodel.cpp libraryscanner.cpp libraryscannerdlg.cpp enginefilterbutterworth8.cpp enginexfader.cpp playerinfo.cpp wabstractcontrol.cpp""")
+
+#Crap we don't use anymore:
+#playerportaudio.cpp player.cpp playerproxy.cpp
+
+#Compile platform specific hardware support
+if platform == 'linux':
+	sources += Split("""powermatelinux.cpp herculeslinux.cpp joysticklinux.cpp mouselinux.cpp """)
+#elif platform == 'win32':
+#	sources += Split("""powermatewin.cpp mousewin.cpp """)
+
+#Compile platform specific MIDI support
+if platform == 'linux':
+	sources += Split("""midiobjectalsaseq.cpp """)  #ALSA Sequencer MIDI support for Linux
+	env.Append(CXXFLAGS = '-D__ALSASEQMIDI__')
+elif platform == 'win32':
+	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__')
+
+
+#Set up the library path on Windows:
+if platform == 'win32':
+	env.Append(CPPPATH='../../../mixxx-winlib') #If you add more directories, separate them with a semicolon (;)
+	env.Append(LIBPATH='../../../mixxx-winlib')
+	env.Append(LINKFLAGS = ['/nodefaultlib:libc.lib', '/nodefaultlib:libcd.lib', '/subsystem:windows', '/entry:mainCRTStartup'])
+
+#Check for dependencies if we're not doing a clean...
+
+if not env.GetOption('clean') and not SCons.Util.containsAny(os.sys.argv, ['-h', '--help']):
+	conf = Configure(env, custom_tests = { 'CheckForPKGConfig' : CheckForPKGConfig, 'CheckForPKG' : CheckForPKG })
+	
+#TODO: Add all of the other configure checks as custom_tests properly.
+	
+# On Posix default SCons.LIBPREFIX = 'lib', on Windows default SCons.LIBPREFIX = ''
+
+	if not conf.CheckLibWithHeader('portaudio', 'portaudio.h', 'C'):
+		print 'Did not find libportaudio.a, portaudio.lib, or the PortAudio-v19 development header files - exiting!'
+		Exit(1)
+
+# 	if not conf.CheckLib(['$QTDIR/lib/qt-mt','$QTDIR/lib/qt-mt3']):
+# 		print 'Did not find libqt-mt.a or libqt-mt.lib, exiting!'
+# 		Exit(1)
+
+	if not conf.CheckLib(['mad','libmad']):
+		print 'Did not find libmad.a, libmad.lib, or the libmad development header files - exiting!'
+		Exit(1)
+
+	if not conf.CheckLib(['id3tag','libid3tag-release']):
+		print 'Did not find libid3tag.a, libid3tag.lib, or the libid3tag development header files - exiting!'
+		Exit(1)
+
+	#Check for Ogg and Vorbis
+	CheckOggVorbis()
+
+	#Check for OpenGL (it's messy to do it for all three platforms)
+	CheckOpenGL()
+	
+	#Check if FFMPEG was enabled
+	CheckFFMPEG(conf, sources)
+
+	#Platform-specific checks for Linux and Win32...
+	if platform == 'linux' or platform == 'win32':
+	    #Check for libsndfile
+		#if not conf.CheckLibWithHeader(['sndfile', 'libsndfile'], 'sndfile.h', 'C'):
+		if not conf.CheckLib(['sndfile', 'libsndfile']):
+			print "Did not find libsndfile or it\'s development headers, exiting!"
+			Exit(1)
+		else:
+			env.Append(CXXFLAGS = ' -D__SNDFILE__')
+			sources.append('soundsourcesndfile.cpp') ## TODO: Convert this to a SharedLibrary, so it can be installed without having to run scons twice after a clean
+			# libsndfile = env.SharedLibrary(
+			# "libsndfile",
+			# source=["soundsourcesndfile.cpp", "trackinfoobject.cpp"])
+
+	#Platform-specific checks for Linux...
+	if platform == 'linux':
+		#Check for g++ (yeah, SCONS is a bit dumb here)
+		if os.system("which g++ > /dev/null"): #Checks for non-zero return code
+			print "Did not find gcc/g++, exiting!"
+			Exit(1)
+		
+		#Check for pkg-config
+		if not conf.CheckForPKGConfig('0.15.0'):
+			print 'pkg-config >= 0.15.0 not found.'
+			Exit(1)
+		
+		#Check for QT >= 4.3	
+		if not conf.CheckForPKG('QtCore', '4.3'):
+			print 'QT >= 4.3 not found.'
+			Exit(1)
+		else:
+			#Grabs the QT4 include paths
+			env.ParseConfig('pkg-config QtCore --silence-errors --cflags --libs') 
+			env.ParseConfig('pkg-config Qt3Support --silence-errors --cflags') #QT3 support breaks the build
+			env.ParseConfig('pkg-config QtGui --silence-errors --cflags --libs')
+			env.ParseConfig('pkg-config QtXml --silence-errors --cflags --libs')
+			env.ParseConfig('pkg-config QtOpenGL --silence-errors --cflags --libs')
+			# Might be missing $QTDIR/include/Qt still...
+
+		#Check for libasound (libasound2?) (needed for ALSA seq MIDI support)
+		if not conf.CheckLib('asound'):
+			print "Did not find libasound (aka. libasound2), exiting!"
+			Exit(1)
+
+        #Check for libdjconsole, if it was passed as a flag
+		flags_djconsole = getFlags(env, 'djconsole', 0)
+		flags_djconsole_legacy = getFlags(env, 'djconsole_legacy', 0)
+		if int(flags_djconsole):
+			if not conf.CheckLibWithHeader('djconsole', 'libdjconsole/djconsole.h', 'C++'):
+				print "Did not find libdjconsole or it\'s development headers, exiting!"
+				Exit(1)
+			env.ParseConfig('pkg-config libdjconsole --silence-errors --cflags --libs')
+			env.Append(CXXFLAGS = '-D__LIBDJCONSOLE__')
+		elif int(flags_djconsole_legacy):
+			# legacy support can not be enabled if libDJConsole support is enabled via djconsole=1
+			env.Append(CXXFLAGS = '-D__DJCONSOLE_LEGACY__')
+
+		#Another check for PortAudio-v19
+		env.ParseConfig('pkg-config --cflags --libs portaudio-2.0')
+		#If the above line looks like magic, it's because it really is. (Read about ParseConfig, it's nifty)
+
+	#Platform-specific checks for OS X
+	if platform == 'osx':
+	#Check for libsndfile
+		#if not conf.CheckLibWithHeader(['sndfile', 'libsndfile'], 'sndfile.h', 'C'):
+		if not conf.CheckLib(['sndfile', 'libsndfile']):
+			print "Did not find libsndfile or it\'s development headers, exiting!"
+			Exit(1)
+		else:
+			env.Append(CXXFLAGS = ' -D__SNDFILE__')
+			sources.append('soundsourcesndfile.cpp') ## TODO: Convert this to a SharedLibrary, so it can be installed without having to run scons twice after a clean
+			# libsndfile = env.SharedLibrary(
+			# "libsndfile",
+			# source=["soundsourcesndfile.cpp", "trackinfoobject.cpp"])
+
+		#Check for QT4 (framework)
+		"""if not os.path.exists('/Library/Frameworks/QtCore.framework/Versions/4/Headers/QtCore') or :
+			print 'Did not find QT4 framework, going to look for libs instead (use qtdir flag)...'
+		else:
+			env.Append(LINKFLAGS = '-framework QtCore -framework QtOpenGL -framework Qt3Support -framework QtGui -framework QtXml -framework QtNetwork -framework QtSql')
+			env.Append(CXXFLAGS = '-I/Library/Frameworks/QtCore.framework/Headers/')
+			env.Append(CXXFLAGS = '-I/Library/Frameworks/QtOpenGL.framework/Headers/')
+			env.Append(CXXFLAGS = '-I/Library/Frameworks/Qt3Support.framework/Headers/')
+			env.Append(CXXFLAGS = '-I/Library/Frameworks/QtGui.framework/Headers/')
+			env.Append(CXXFLAGS = '-I/Library/Frameworks/QtXml.framework/Headers/')
+"""
+		#Check for QT libs (rather than framework)
+		if not os.path.exists(flags_qtdir):
+			print 'Did not find QT4 path (qtdir: ' + flags_qtdir + ' not found), exiting!'
+		else:
+			env.Append(LIBPATH=flags_qtdir + '/lib/')
+			env.Append(CPPPATH=flags_qtdir + '/include/')
+			env.Append(LIBS = 'Qt3Support');
+			env.Append(LIBS = 'QtXml');
+			env.Append(LIBS = 'QtGui');
+			env.Append(LIBS = 'QtCore');
+			env.Append(LIBS = 'QtOpenGL');
+			env.Append(LIBS = 'QtNetwork');
+			env.Append(LIBS = 'QtSql');
+			
+			
+		#Check for CoreMIDI
+		if not conf.CheckCXXHeader('/System/Library/Frameworks/CoreMIDI.framework/Headers/CoreMIDI.h'):
+			print 'Did not find CoreMIDI framework, exiting! (Please install it)'
+			Exit(1)
+		else:
+			env.Append(LINKFLAGS = '-framework CoreMIDI -framework CoreFoundation -framework CoreAudio -framework Carbon -framework Quicktime -framework AudioToolbox -framework AudioUnit') #Have to add the rest of these frameworks somewhere...
+
+
+	env = conf.Finish()
+
+
+#Declare the flags for Mixxx's config/track listing files:
+if platform == 'linux':
+	env.Append(CXXFLAGS = ' -D__UNIX__ -D__LINUX__ -DBPMSCHEME_FILE=\\".mixxxbpmscheme.xml\\" -DSETTINGS_FILE=\\".mixxx.cfg\\" -DTRACK_FILE=\\".mixxxtrack.xml\\"')
+	env.Append(CXXFLAGS = ' -DUNIX_SHARE_PATH=\\"' + ARGUMENTS.get('prefix', '/usr/local') + '/share/mixxx\\"')
+elif platform == 'osx':
+	env.Append(CXXFLAGS = ' -D__MACX__ -DBPMSCHEME_FILE=\\".mixxxbpmscheme.xml\\" -DSETTINGS_FILE=\\".mixxx.cfg\\" -DTRACK_FILE=\\".mixxxtrack.xml\\"')
+elif platform == 'win32':
+	env.Append(CXXFLAGS = '-D__WIN32__ -DBPMSCHEME_FILE=\\"mixxxbpmschemes.xml\\" -DSETTINGS_FILE=\\"mixxx.cfg\\" -DTRACK_FILE=\\"mixxxtrack.xml\\"')
+
+#... and yes, we need to double-escape those quotes
+env.Append(CXXFLAGS = ' -D__PORTAUDIO__'); #Turn on PortAudio support in Mixxx
+env.Append(CPPPATH = ['.', '../', '../../']) #Fun fun fun with paths
+
+
+if platform == 'linux':
+	env.Append(LIBS = 'Qt3Support');
+	env.Append(LIBS = 'QtXml');
+	env.Append(LIBS = 'QtGui');
+	env.Append(LIBS = 'QtCore');
+	env.Append(LIBS = 'QtOpenGL');
+
+if platform == 'win32':
+	env.Append(LIBS = 'Qt3Support4'); #Win32 needs this instead of 'Qt3Support'
+	env.Append(LIBS = 'QtXml4');
+	env.Append(LIBS = 'QtGui4');
+	env.Append(LIBS = 'QtCore4');
+	env.Append(LIBS = 'QtOpenGL4');
+	env.Append(LIBS = 'WinMM'); #Needed for Midi stuff
+	env.Append(LIBS = 'ogg_static')
+	env.Append(LIBS = 'vorbis_static')
+	env.Append(LIBS = 'vorbisfile_static')
+	env.Append(LIBS = 'imm32')
+	env.Append(LIBS = 'wsock32')
+	env.Append(LIBS = 'delayimp')
+	env.Append(LIBS = 'winspool')
+	env.Append(LIBS = 'shell32')
+
+env.Append(CXXFLAGS = ' -DQT3_SUPPORT -DQT3_SUPPORT_WARNINGS -DQT_THREAD_SUPPORT -DQT_SHARED -DQT_TABLET_SUPPORT') #Stolen from Mixxx's build output
+
+# Manually add the include paths for win32 and OS X (we use pkg-config on Linux)
+if not platform == 'linux':
+	env.Append(CXXFLAGS = ' -I$QTDIR/include/Qt3Support -I$QTDIR/include/QtCore -I$QTDIR/include/QtGui -I$QTDIR/include/QtXml -I$QTDIR/include/QtOpenGL -I$QTDIR/include/Qt -I"$VCINSTALLDIR/include/atl"')
+
+if not platform == 'win32':
+	env.Append(CCFLAGS = Split(""" -pipe -Wall -W -g -D_REENTRANT """)) # omghax
+	env.Append(LINKFLAGS = Split(""" -pipe -Wall -W -g"""))
+if platform == 'win32':
+	env.Append(CXXFLAGS = '-DWIN32 -D__WIN__ -DUNICODE -D_WINDOWS') #for soundtouch
+	env.Append(CCFLAGS  = '-DWIN32 -D__WIN__ -DUNICODE -D_WINDOWS') #for soundtouch
+
+#Uic these guys (they're moc'd automatically after this) - Generates the code for the QT UI forms
+env.Uic4('dlgpreferencesdlg.ui')
+env.Uic4('dlgprefsounddlg.ui')
+env.Uic4('dlgprefmididlg.ui')
+env.Uic4('dlgprefplaylistdlg.ui')
+env.Uic4('dlgprefcontrolsdlg.ui')
+env.Uic4('dlgprefeqdlg.ui')
+env.Uic4('dlgprefcrossfaderdlg.ui')
+env.Uic4('dlgprefbpmdlg.ui')
+env.Uic4('dlgbpmschemedlg.ui')
+env.Uic4('dlgbpmtapdlg.ui')
+env.Uic4('dlgprefvinyldlg.ui')
+env.Uic4('dlgprefrecorddlg.ui')
+env.Uic4('dlgaboutdlg.ui')
+
+#Add the QRC file which compiles in some extra resources (prefs icons, etc.)
+env.Qrc('mixxx.qrc')
+sources += Split(""" qrc_mixxx.cc """)
+
+if platform == 'win32':
+	env.RES('mixxx.rc')
+	sources += Split(""" mixxx.res """)
+
+# Uic4 does not need this --> Add these uic/moc generated files to the list of stuff we need to build:
+#sources.append(Split("""uic_dlgprefsounddlg.cc 		moc_dlgprefsounddlg.cc
+#						uic_dlgprefcontrolsdlg.cc	moc_dlgprefcontrolsdlg.cc
+#						uic_dlgprefmididlg.cc		moc_dlgprefmididlg.cc
+#						uic_dlgprefplaylistdlg.cc	moc_dlgprefplaylistdlg.cc
+#						uic_dlgprefmixerdlg.cc	    moc_dlgprefmixerdlg.cc
+#						uic_dlgprefrecorddlg.cc	    moc_dlgprefrecorddlg.cc
+#					  	"""))
+
+#More complicated way of doing Uic (gives us control over the filenames, but doesn't really matter...)
+#env.Uic(target = Split('dlgprefcontrolsdlg.h .ui/dlgprefcontrolsdlg.cpp .moc/dlgprefcontrolsdlg.cpp'),
+#        source = 'dlgprefcontrolsdlg.ui')
+
+#Tell SCons to build libraries that are bundled with Mixxx
+#===================================================
+
+#SoundTouch
+env.Append(CPPPATH=['../../lib/soundtouch']) #Needed two ../../'s because we're compiling from "src/.obj"
+sources += Split("""enginebufferscalest.cpp ../../lib/soundtouch/SoundTouch.cpp ../../lib/soundtouch/TDStretch.cpp ../../lib/soundtouch/RateTransposer.cpp ../../lib/soundtouch/AAFilter.cpp ../../lib/soundtouch/FIFOSampleBuffer.cpp ../../lib/soundtouch/FIRFilter.cpp """)
+if platform == 'win32':
+	sources += Split("""../../lib/soundtouch/cpu_detect_x86_win.cpp ../../lib/soundtouch/mmx_win.cpp ../../lib/soundtouch/sse_win.cpp ../../lib/soundtouch/3dnow_win.cpp""")
+else:
+	sources += Split("""../../lib/soundtouch/cpu_detect_x86_gcc.cpp""")
+
+#KissFFT
+env.Append(CPPPATH=['../../lib/kissfft'])
+sources += Split("""../../lib/kissfft/kiss_fft.c""")
+
+#libsamplerate
+env.Append(CPPPATH='../../lib/libsamplerate')
+sources += Split("""enginebufferscalesrc.cpp ../../lib/libsamplerate/samplerate.c ../../lib/libsamplerate/src_linear.c ../../lib/libsamplerate/src_sinc.c ../../lib/libsamplerate/src_zoh.c""")
+
+#fidlib (for EQs)
+env.Append(CPPPATH='../../lib/fidlib-0.9.9/')
+sources += Split("""../../lib/fidlib-0.9.9/fidlib.c """)
+#Platform-specific compile/link flags needed for fidlib
+if platform == 'linux' or platform == 'osx':
+	env.Append(CCFLAGS = '-DT_LINUX')
+elif platform == 'win32':
+	env.Append(CCFLAGS = '-DT_MSVC')
+	env.Append(CXXFLAGS = '-DT_MSVC')
+	env.Append(LINKFLAGS = ['/nodefaultlib:LIBCMT.lib', '/nodefaultlib:LIBCMTD.lib'])
+
+
+#Parse command-line build flags
+build_flags = ""
+
+print "\nFeatures Summary:\n================"
+
+#Python/lua scripting
+#flags_script = ARGUMENTS.get('script', 0) #Default value is 0
+#if int(flags_script):
+#	env.Append(CXXFLAGS = '-D__SCRIPT__ -D__LUA__ -D__PYTHON__')
+#	sources += Split("""script/*.cpp script/lua/*.cpp script/python/*.cpp""")
+#	env.ParseConfig('python-config --include --ldflags')
+#	env.Append(LIBS = 'lua')
+#	env.Append(LIBS = 'lualib')
+#	env.Append(LIBS = 'tulua')
+#	print "Python and Lua scripting... enabled"
+#else:
+#	print "Python and Lua scripting... disabled"
+ #TODO: FINISH THIS!
+
+
+#Hercules support through libdjconsole on Linux
+#(handled somewhere else above this in the file...
+# just printing the summary here)
+flags_djconsole = getFlags(env, 'djconsole', 0)
+if int(flags_djconsole) == 0:
+	print "libdjconsole support... disabled"
+else:
+	print "libdjconsole support... enabled"
+	build_flags += 'djconsole '
+
+#High quality EQs
+flags_hifieq = getFlags(env, 'hifieq', 1)
+if int(flags_hifieq) == 0:
+	env.Append(CXXFLAGS = '-D__LOFI__ -D__NO_INTTYPES__') #Enables old crappy EQs
+	print "High quality EQs... disabled"
+else:
+	print "High quality EQs... enabled"
+	build_flags += 'hifieq '
+
+#Case Metrics
+flags_cmetrics = getFlags(env, 'cmetrics', 0)
+if int(flags_cmetrics):
+	env.Append(CXXFLAGS = '-D__C_METRICS__')
+	if platform == 'win32':
+	    env.Append(LIBS = 'cmetrics')
+	else:
+	    client = 'MIXXX'
+	    server = 'casemetrics.net' #NOTE: Permission to use this server is granted only to mixxx, any other use must obtain prior permission
+	    Export('env platform client server')
+	    env.Append(CPPPATH='../../lib/cmetrics')
+	    sources += SConscript('../../lib/cmetrics/SConscript')
+	print "Case Metrics profiling... enabled"
+	build_flags += 'cmetrics '
+else:
+	print "Case Metrics profiling... disabled"
+
+#Experimental Shoutcast
+flags_shoutcast = getFlags(env, 'shoutcast', 0)
+if int(flags_shoutcast):
+#TODO: check for libshout
+	env.Append(LIBS = 'shout');
+	env.Append(LIBS = 'vorbisenc');
+	env.Append(CXXFLAGS = '-D__SHOUTCAST__')
+	sources += Split(""" dlgprefshoutcast.cpp engineshoutcast.cpp encodervorbis.cpp """ )
+	env.Uic4('dlgprefshoutcastdlg.ui')
+	print "Shoutcast support... enabled"
+	build_flags += 'shoutcast '
+else:
+	print "Shoutcast support... disabled"
+
+#LADSPA
+#TODO: Make sure we check for ladspa.h and the library...
+flags_ladspa = getFlags(env, 'ladspa', 0)
+if int(flags_ladspa):
+	env.Append(CXXFLAGS = '-D__LADSPA__')
+	sources += Split("""engineladspa.cpp ladspaloader.cpp ladspalibrary.cpp ladspaplugin.cpp ladspainstance.cpp ladspacontrol.cpp ladspainstancestereo.cpp ladspainstancemono.cpp ladspaview.cpp ladspapreset.cpp ladspapresetmanager.cpp ladspapresetknob.cpp ladspapresetinstance.cpp dlgladspa.cpp""")
+	print "LADSPA support... enabled"
+	build_flags += 'ladspa '
+else:
+	print "LADSPA support... disabled"
+
+#Vinyl Control
+flags_vinylcontrol = getFlags(env, 'vinylcontrol', 1)
+if int(flags_vinylcontrol):
+	env.Append(CXXFLAGS = '-D__VINYLCONTROL__')
+	sources += Split(""" vinylcontrol.cpp vinylcontrolproxy.cpp vinylcontrolscratchlib.cpp vinylcontrolxwax.cpp dlgprefvinyl.cpp
+	                     enginevinylcontrol.cpp """)
+	env.Append(CPPPATH='../../lib/xwax')
+	if platform == 'win32':
+		sources += Split("""../../lib/xwax/timecoder_win32.c """)
+	else:
+		sources += Split("""../../lib/xwax/timecoder.c """)
+	env.Append(CPPPATH='../../lib/scratchlib')
+	sources += Split("""../../lib/scratchlib/DAnalyse.cpp """)
+	print "Vinyl Control... enabled"
+	build_flags += 'vinylcontrol '
+else:
+	print "Vinyl Control... disabled"
+
+flags_msvcdebug = getFlags(env, 'msvcdebug', 1)
+if int(flags_msvcdebug) and platform == 'win32':
+	env.Append(LINKFLAGS = '/DEBUG')
+	env.Append(CXXFLAGS = '/ZI')
+	print "MSVC Debugging... enabled"
+	build_flags += 'msvcdebug '
+else:
+	print "MSVC Debugging... disabled"
+
+flags_script = getFlags(env, 'script', 0)
+if int(flags_script):
+	if platform == 'win32':
+		env.Append(LIBS = 'QtScript4')
+	else:
+		env.Append(LIBS = 'QtScript')
+	print "SuperCoolAwesomeScript (name contest pending)... enabled"
+	build_flags += 'script '
+	sources += Split("""script/scriptengine.cpp script/scriptcontrolqueue.cpp
+			script/scriptstudio.cpp script/scriptrecorder.cpp
+			script/playinterface.cpp script/macro.cpp
+			script/scriptcontrolevent.cpp script/trackcontrolevent.cpp
+			script/numbercontrolevent.cpp script/numberrecorder.cpp
+			script/macrolist.cpp script/trackrecorder.cpp
+			script/sdatetime.cpp script/signalrecorder.cpp
+			script/macrolistitem.cpp script/qtscriptinterface.cpp""")
+	env.Append(CXXFLAGS = '-I$QTDIR/include/QtScript')
+	env.Append(CXXFLAGS = '-D__SCRIPT__')
+	
+	env.Uic4('script/scriptstudio.ui')
+else:
+	flags_script = 0
+	print "SuperCoolAwesomeScript (name contest pending)... disabled"
+
+#Optimization
+if platform == 'win32':
+    flags_optimize = getFlags(env, 'optimize', 0)   #Default to off on win32
+else:
+    flags_optimize = getFlags(env, 'optimize', 1)   #Default to on for Linux/OS X
+if int(flags_optimize):
+	if platform == 'win32':
+		if int(flags_msvcdebug):
+			print "Optimizations... DISABLED DUE TO DEBUG"
+		else:
+			print "Optimizations... enabled"
+			env.Append(CXXFLAGS = '/O2 /GL')
+			env.Append(LINKFLAGS = '/LTCG:STATUS')
+	else:
+		print "Optimizations... enabled"
+		build_flags += 'optimize=' + str(flags_optimize) + ' '
+		if flags_optimize=='1':
+			env.Append(CXXFLAGS = '-O3')
+		elif flags_optimize=='2':
+			print "  P4 MMX/SSE optimizations enabled."
+			env.Append(CXXFLAGS = '-O3 -march=pentium4 -mmmx -msse2 -mfpmath=sse -fomit-frame-pointer -ffast-math -funroll-loops')
+                elif flags_optimize=='3':
+                        print "  Intel Core Solo/Duo optimizations enabled."
+                        env.Append(CXXFLAGS = '-O3 -march=prescott -mmmx -msse3 -mfpmath=sse -fomit-frame-pointer -ffast-math -funroll-loops')
+                elif flags_optimize=='4':
+                        print "  Intel Core 2 optimizations enabled."
+                        env.Append(CXXFLAGS = '-O3 -march=nocona -mmmx -msse3 -mfpmath=sse -fomit-frame-pointer -ffast-math -funroll-loops')
+else:
+	print "Optimizations... disabled"
+
+
+
+
+# Profiling and Optimization
+if not platform == 'win32':
+	flags_gprof = getFlags(env, 'gprof', 0)
+	if int(flags_gprof):
+		env.Append(CCFLAGS = '-pg')
+		env.Append(LINKFLAGS = '-pg')
+		print "gprof profiling support... enabled"
+		build_flags += 'gprof '
+	else:
+		print "gprof profiling support... disabled"
+	flags_tuned = getFlags(env, 'tuned', 0)
+	if int(flags_tuned):
+		ccv = env['CCVERSION'].split('.')
+		if int(ccv[0]) >= 4 and int(ccv[1]) >= 2:
+			env.Append(CCFLAGS = '-march=native')
+			env.Append(LINKFLAGS = '-march=native')
+			print "Optimizing for this CPU... yes"
+			build_flags += 'tuned '
+		else:
+			print "Optimizing for this CPU... no (requires gcc >= 4.2.0)"
+	else:
+		print "Optimizing for this CPU... no"
+
+#Visual Studio 2005 hacks (MSVS Express Edition users shouldn't enable this)
+flags_msvshacks = getFlags(env, 'msvshacks', 0)
+if int(flags_msvshacks):
+	env.Append(CXXFLAGS = '-D__MSVS2005__')
+	print "MSVS 2005 hacks... enabled"
+	build_flags += 'msvshacks '
+else:
+	print "MSVS 2005 hacks... disabled"
+
+print "================\n"
+
+### Put flags info into a file
+f = open("../.mixxx_flags.svn","w")
+try:
+	f.write('#define BUILD_FLAGS "' + build_flags + '"\n')
+finally:
+	f.close()
+
+
+#Save the options to cache
+opts.Save(cachefile, env)
+
+#Tell SCons to build Mixxx
+#=========================
+if platform == 'win32':
+	mixxx_bin = env.Program('mixxx', sources, LINKCOM  = [env['LINKCOM'], 'mt.exe -nologo -manifest ${TARGET}.manifest -outputresource:$TARGET;1'])
+else:
+	mixxx_bin = env.Program('mixxx', sources)
+
+#Set up the MSVC target to build a Visual Studio project/solution file
+if 'msvc' in COMMAND_LINE_TARGETS:
+	includes = glob.glob('src/*.h')
+	includes += glob.glob('src/visual/*.h')
+	#Make the project file aware of any command-line arguments that were passed...
+	cmdargs = ""
+	for k in SCons.Script.ARGUMENTS:
+		cmdargs += " " + k + "=" + SCons.Script.ARGUMENTS[k]
+	env.Append(MSVSSCONSFLAGS = cmdargs)
+	#env.Append(MSVSSCONSFLAGS = ' qtdir=' + flags_qtdir)
+
+	# This is the right way to do it but scons is stupid and doesn't copy flags in... Adam
+	# Set up environment for debug target
+	# TODO Handle lib versions ie /MDd /Md etc...
+	#debugenv = env.Clone()
+	#debugenv.Prepend(LINKFLAGS = ['/DEBUG','/PDB:dist/mixxx.pdb']) # Generate MS VC Program Debug Database
+	#debugenv.Append(CXXFLAGS = '/ZI')
+
+	msvc = env.MSVSProject(target = 'mixxx' + env['MSVSPROJECTSUFFIX'], srcs = flatten(sources), incs = flatten(includes), variant = 'Debug', runfile = '../dist/mixxx')
+
+	# Reenable this once bug in scons is fixed...
+	#msvc = env.MSVSProject(target = 'mixxx' + env['MSVSPROJECTSUFFIX'], srcs = flatten(sources), incs = flatten(includes), variant = 'Release', runfile = '../dist/mixxx')
+
+	env.Alias('msvc', msvc)
+
+#Set up the install target
+#=========================
+"""
+flags_prefix = ARGUMENTS.get('prefix', '/usr/local')
+if not os.path.exists(flags_prefix):
+	print "Error: Prefix path does not exist!"
+	Exit(1)
+else:
+	unix_share_path = flags_prefix + "/share"
+	unix_bin_path   = flags_prefix + "/bin"
+"""
+
+#Mixxx binary
+binary_files = mixxx_bin;
+
+#Skins
+skin_files = glob.glob('../skins/*')
+
+#MIDI mappings
+midimappings_files = glob.glob('../midi/*')
+
+#Keyboard mapping(s)
+keyboardmappings_files = glob.glob('../keyboard/*')
+
+#Documentation
+docs_files = glob.glob('../../LICENSE')
+docs_files += glob.glob('../../README')
+docs_files += glob.glob('../../Mixxx-Manual.pdf')
+
+#.desktop file for KDE/GNOME menu
+dotdesktop_files = glob.glob('../mixxx.desktop')
+
+#Icon file for menu entry
+icon_files = glob.glob('../mixxx-icon.png')
+
+#Images for preferences dialog
+image_files = glob.glob('../images/preferences/*')  # These are compiled in to the "mixxx" binary through mixxx.qrc
+
+#Windows DLLs
+dll_files = glob.glob('../../../mixxx-winlib/*.dll') # TODO: Use reference to SharedLibrary for libsndfile and others, glob only gets all files on 2+ builds after a clean.
+# dll_files = libsndfile
+dll_files += Split("""$QTDIR/lib/Qt3Support4.dll $QTDIR/lib/QtCore4.dll $QTDIR/lib/QtGui4.dll $QTDIR/lib/QtNetwork4.dll $QTDIR/lib/QtOpenGL4.dll $QTDIR/lib/QtSql4.dll $QTDIR/lib/QtXml4.dll """)
+
+if int(flags_script):
+	dll_files += Split("""$QTDIR/lib/QtScript4.dll""")
+
+if platform == 'linux':
+	flags_prefix = ARGUMENTS.get('prefix', '/usr/local')
+	if not os.path.exists(flags_prefix):
+		print "Error: Prefix path does not exist!"
+		Exit(1)
+	else:
+		#install_root is used in Debian/Ubuntu packaging (check the debian/rules file in the Ubuntu package)
+		#Basically, the flags_prefix is compiled into strings in Mixxx, whereas the install_root is not. When you're
+		#building a Debian package, pbuilder wants to install Mixxx to a temporary directory, but you still need
+		#the compiled-in strings using /usr as the prefix. That's why we have install_root and flags_prefix.
+		install_root = ARGUMENTS.get('install_root', flags_prefix)
+		print "Install root: " + install_root
+		if install_root != flags_prefix:
+			unix_share_path = install_root + "/share"
+			unix_bin_path   = install_root + "/bin"			
+		else:
+			unix_share_path = flags_prefix + "/share"
+			unix_bin_path   = flags_prefix + "/bin"
+
+		binary = env.Install(unix_bin_path, binary_files)
+		skins = env.Install(unix_share_path + "/mixxx/skins", skin_files)
+		midimappings = env.Install(unix_share_path + "/mixxx/midi", midimappings_files)
+		keyboardmappings = env.Install(unix_share_path + "/mixxx/keyboard", keyboardmappings_files)
+		dotdesktop = env.Install(unix_share_path + "/applications", dotdesktop_files)
+		docs = env.Install(unix_share_path + "/doc/mixxx", docs_files)
+		icon = env.Install(unix_share_path + "/pixmaps", icon_files)
+
+        #Makes each of those Install builders get fired off when you run "scons install" :)
+		env.Alias('install', binary)
+		env.Alias('install', skins)
+		env.Alias('install', midimappings)
+		env.Alias('install', keyboardmappings)
+		env.Alias('install', docs)
+		env.Alias('install', dotdesktop)
+		env.Alias('install', icon)
+		
+		#Delete the old Mixxx installation (because SCONS won't overwrite it)
+		#if 'install' in COMMAND_LINE_TARGETS:
+			#os.system('scons -c install')
+			#Delete(unix_share_path + "/mixxx/skins")
+			#print "Copying skins..."
+			#env.Command(unix_share_path + "/mixxx/skins", skin_files, Copy("$TARGET", "$SOURCE"), source_scanner = DirScanner)
+			#Copy(unix_share_path + "/.ixxx/skins", skin_files)
+            #Delete(unix_bin_path + "mixxx")
+			
+			#Delete(unix_share_path + "/mixxx/midi")
+			#Delete(unix_share_path + "/mixxx/keyboard")
+
+#Build the Mixxx.app directory 
+if platform == 'osx':
+
+	#Files needed to create the OS X package
+	osx_plist_file = glob.glob('../osx/Info.plist')
+	osx_pkginfo_file = glob.glob('../osx/PkgInfo')
+	osx_icns_file = glob.glob('../osx/application.icns')
+	
+	osx_dist_path = "../../Mixxx.app"
+	osx_share_path = osx_dist_path
+	binary = env.Install(osx_dist_path + "/Contents/MacOS", binary_files)
+	skins = env.Install(osx_dist_path + "/skins", skin_files)
+	midimappings = env.Install(osx_dist_path + "/midi", midimappings_files)
+	keyboardmappings = env.Install(osx_dist_path + "/keyboard", keyboardmappings_files)
+	docs = env.Install(osx_dist_path + "/doc", docs_files)
+	osx_plist = env.Install(osx_dist_path + "/Contents", osx_plist_file)
+	osx_pkginfo = env.Install(osx_dist_path + "/Contents", osx_pkginfo_file)
+	osx_icns = env.Install(osx_dist_path + "/Contents/Resources", osx_icns_file)
+
+	
+	#Makes each of those Install builders get fired off when you run "scons install" :)
+	env.Alias('install', binary)
+	env.Alias('install', skins)
+	env.Alias('install', midimappings)
+	env.Alias('install', keyboardmappings)
+	env.Alias('install', osx_plist)
+	env.Alias('install', osx_pkginfo)
+	env.Alias('install', osx_icns)
+
+		
+if platform == 'win32':
+	skins = env.Install("../../dist/skins", skin_files)
+	midimappings = env.Install("../../dist/midi", midimappings_files)
+	keyboardmappings = env.Install("../../dist/keyboard", keyboardmappings_files)
+	docs = env.Install("../../dist/doc/", docs_files)
+	#icon = env.Install("../../dist", icon_files)
+	dlls = env.Install("../../dist/", dll_files)
+	binary = env.Install("../../dist/", binary_files)
+
+	#Always trigger these install builders when compiling on Windows
+	env.Alias('mixxx', skins)
+	env.Alias('mixxx', midimappings)
+	env.Alias('mixxx', keyboardmappings)
+	env.Alias('mixxx', docs)
+	env.Alias('mixxx', dlls)
+	#env.Alias('mixxx', icon)
+	env.Alias('mixxx', binary)
+
+
+
+def BuildRelease(target, source, env):
+	print 
+	print "==== Mixxx Post-Build Checks ===="
+	print 
+	print "You have built version ",
+	os.system('grep -m 1 VERSION src/defs.h | cut -d \' \' -f 3')
+	print
+	print "Binary has size ",
+	os.system('ls -lh dist/mixxx.exe | cut -d \' \' -f 5')
+	print
+	print "Installer file ",
+	os.system('grep OutFile Mixxx.nsi | cut -d \' \' -f 2')
+	print
+	print "Top line of README, check version:"
+	os.system('head -n 1 README')
+	print
+	print "Top 2 lines of LICENSE, check version and copyright dates:"
+	os.system('head -n 2 LICENSE')
+	print
+	print "More checks here soon... :)"
+	print
+
+	if (raw_input("Go ahead and build installer (yes/[no])? ") == "yes"):
+		print "Now building installer..."
+		os.system('"c:/Program Files/NSIS/makensis.exe" Mixxx.nsi')
+	else:
+		print "Aborted building installer"
+
+# Do release things 
+versionbld = Builder(action = BuildRelease, suffix = '.foo', src_suffix = '.bar')
+env.Append(BUILDERS = {'BuildRelease' : versionbld})
+
+if 'makerelease' in COMMAND_LINE_TARGETS:
+	makerelease = env.BuildRelease('', binary_files)
+	env.Alias('makerelease', makerelease)
+	
+#Build the Ubuntu package
+def BuildUbuntuPackage(target, source, env):
+	print 
+	print "==== Mixxx Post-Build Checks ===="
+	print 
+	print "You have built version ",
+	p = os.popen('grep -m 1 VERSION src/defs.h | cut -d \' \' -f 3 | tr -d \'\"\' | tr -d \'\n\'')
+	version = p.readline()
+	p.close()
+	print
+	print
+	print "Top line of README, check version:"
+	os.system('head -n 1 README')
+	print
+	print "Top 2 lines of LICENSE, check version and copyright dates:"
+	os.system('head -n 2 LICENSE')
+	print
+	print "Top line of debian/ubuntu changelog, check version:"
+	os.system('head -n 1 src/debian/changelog')
+	print
+
+	if ("yes" == "yes"):
+		print "Now building DEB package..."
+		
+		mixxx_dir = 'mixxx-' + version
+		mixxx_tarball = 'mixxx_' + version + '.orig.tar.gz' #The underscore is super important here
+															#to make the deb package work
+		
+		if not os.path.exists('ubuntu'):
+			os.mkdir('ubuntu')
+		print "Exporting source tree from HEAD" 
+		
+		os.system('svn export --force -rHEAD . ubuntu/mixxx-' + version)
+		
+		os.chdir('ubuntu')
+		
+		#Temporarily move the debian directory out of the source directory
+		#because it can't be included in the source tarball (which we create next).
+		#print "Moving debian directory"
+		#os.system('rm -f debian')
+		#os.system('mv mixxx-' + version + '/src/debian .')
+		
+		print "Tarring source directory..."
+		os.system("rm -f mixxx_" + version + ".orig.tar.gz") #Remove old tarball
+		os.system('tar --exclude=debian --exclude=debian/* -cvzf  mixxx_' + version + '.orig.tar.gz ' + mixxx_dir) 
+		 
+		#Move the debian directory into the right spot.
+		#os.system('mv debian mixxx-' + version)
+		os.system('rm -rf ' + mixxx_dir + '/debian')
+		os.system('mv ' + mixxx_dir + '/src/debian ' + mixxx_dir)
+		
+		#Run pbuilder
+		os.chdir(mixxx_dir)
+		os.system('pdebuild')
+		
+		#/var/cache/pbuilder/result
+		print
+		print "Signing the .deb changes file..."
+		os.system('sudo debsign /var/cache/pbuilder/result/*.changes')
+		
+		print "Done! Package and tarballs are in /var/cache/pbuilder/result"
+		
+	else:
+		print "Aborted building installer"
+
+#Build the Ubuntu package if "makeubuntu" was passed as an argument
+versiondebbld = Builder(action = BuildUbuntuPackage, suffix = '.foo', src_suffix = '.bar')
+env.Append(BUILDERS = {'BuildUbuntuPackage' : versiondebbld})
+
+if 'makeubuntu' in COMMAND_LINE_TARGETS:
+	makeubuntu = env.BuildUbuntuPackage('', binary_files)
+	env.Alias('makeubuntu', makeubuntu)