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

[Sean M. Pappalardo]

This branch is now ready to be merged. It successfully provides a more flexible (and two-way) replacement for our flawed use of qWarning to create user-facing dialogs in many places. I have made this replacement in MidiMapping and MidiScriptEngine, of which the latter is a good example of usage and addresses Albert's initial desire to offer the user some actions (ignore or reload) when a MIDI script goes awry. I've tested these replacements extensively and feel that they're ready for code review and wider testing.

I respectfully ask that this branch be considered for merge to trunk in time for the 1.8 release for the following reasons:
1) It provides useful user feedback and actions when there are problems with MIDI scripts, especially now that qWarning has been disabled
2) It doesn't affect the core functionality of any classes except ErrorDialog, and the previous use of that has been accounted for and tests good. (qCritical boxes.)

I ask that reviewers pay special attention to threading intricacies in the new code as I am still very new at multi-threaded programming. I have tried to use signals for cross-thread communication but would not be surprised if I messed something up. (There is also still a thread problem on shutdown with multiple MIDI devices activated that has carried over from trunk.)

[Albert Santoni (gamegod)]

- Change DialogProperties class's name to ErrorDialogProperties.
- The DialogProperties class should have no public variables. Make public get/set methods for all the variables you want to change, and make those variables private.
- You should not have any global variables. Eg. g_pDialogHelper. If you really want to use ErrorDialog the way you are currently, you can get away with it by using the Singleton design pattern: http://www.codeguru.com/forum/showthread.php?t=344782
(The wikipedia article on it has a super overcomplicated C++ example.)
- You must make ErrorDialog thread safe. Use QMutexLocker and a single QMutex.

review: Needs Fixing

[lp:~mixxxdevelopers/mixxx/features_messageBox]

2380. By Sean M. Pappalardo on 2010-05-06

- Renamed class to a more accurate "ErrorDialogHandler"
- Renamed class to "ErrorDialogProperties"
- Protected all ErrorDialogProperties variables and made access functions
- Made ErrorDialogHandler a singleton and removed the previous global variable
- Moved ErrorDialogProperties instantiation into ErrorDialogHandler
- Fixed MidiMapping and MidiScriptEngine to work with the changes, tests good
- Mutex-protected the m_dialogKeys QList in ErrorDialogHandler, the only reentrant shared data item that is used by multiple threads
- Changed qDebugs to qWarnings in a few files where it made sense, since qWarning now just logs and they'll still show up if qDebugs are disabled

[Sean M. Pappalardo (pegasus-renegadetech)]

Addressed all of Albert's concerns, resubmitting for review.

review: Needs Resubmitting

[lp:~mixxxdevelopers/mixxx/features_messageBox]

2381. By Sean M. Pappalardo on 2010-05-07

Idiot...forgot to add the renamed files.

[Albert Santoni (gamegod)]

You should probably lock around your use of m_pSignalMapper, but other than that, I think this is a huge improvement since the last review! I'm impressed! Your code's starting to look like it was written by a C++ programmer. :)

review: Approve

=== modified file 'mixxx/src/SConscript'
--- mixxx/src/SConscript	2010-05-04 17:21:17 +0000
+++ mixxx/src/SConscript	2010-05-07 07:32:30 +0000
@@ -342,7 +342,7 @@
                 mixxxcontrol.cpp
                 mixxx.cpp
                 mixxxview.cpp
-                errordialog.cpp
+                errordialoghandler.cpp
                 upgrade.cpp
 
                 soundsource.cpp

=== removed file 'mixxx/src/errordialog.cpp'
--- mixxx/src/errordialog.cpp	2010-01-05 11:18:14 +0000
+++ mixxx/src/errordialog.cpp	1970-01-01 00:00:00 +0000
@@ -1,76 +0,0 @@
-/***************************************************************************
-                          errordialog.cpp  -  description
-                             -------------------
-    begin                : Sun Feb 22 2009
-    copyright            : (C) 2009 by Sean M. Pappalardo
-    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 "errordialog.h"
-#include <QMessageBox>
-#include <QtDebug>
-#include <QtCore>
-
-ErrorDialog::ErrorDialog() {
-    m_errorCondition=false;
-    connect(this, SIGNAL(showErrorDialog(int, QString, QString)), this, SLOT(errorDialog(int, QString, QString)));
-}
-
-ErrorDialog::~ErrorDialog()
-{
-}
-
-void ErrorDialog::requestErrorDialog(int type, QString message) {
-    switch (type) {
-        case 1: requestErrorDialog(type,"Mixxx - Critical error",message); break;
-        case 0:
-        default:
-            requestErrorDialog(type,"Mixxx - Warning",message);
-            break;
-    }
-}
-
-void ErrorDialog::requestErrorDialog(int type, QString title, QString message) {
-    emit (showErrorDialog(type, title, message));
-    disconnect(this, SIGNAL(showErrorDialog(int, QString, QString)), this, SLOT(errorDialog(int, QString, QString))); // Avoid multiple dialogs until this one is acknowledged
-}
-
-void ErrorDialog::errorDialog(int type, QString title, QString message) {
-    QMessageBox msgBox;
-    msgBox.setText(message);
-    msgBox.setWindowTitle(title);
-    switch (type) {
-        case 1: msgBox.setIcon(QMessageBox::Critical); break;
-        case 0:
-        default:
-            msgBox.setIcon(QMessageBox::Warning);
-            break;
-    }
-    msgBox.exec();  // Block so the user can read it before exiting
-
-    if (type==1) {  // If critical/fatal, gracefully exit application if possible
-        m_errorCondition=true;
-        if (QCoreApplication::instance()) {
-            QCoreApplication::instance()->exit(-1);
-        }
-        else {
-            qDebug() << "QCoreApplication::instance() is NULL! Abruptly quitting...";
-            exit(-1);
-        }
-    }
-
-    connect(this, SIGNAL(showErrorDialog(int, QString, QString)), this, SLOT(errorDialog(int, QString, QString)));    // reconnect the signal
-}
-
-bool ErrorDialog::checkError() {
-    return m_errorCondition;
-}
\ No newline at end of file

=== removed file 'mixxx/src/errordialog.h'
--- mixxx/src/errordialog.h	2010-01-05 11:18:14 +0000
+++ mixxx/src/errordialog.h	1970-01-01 00:00:00 +0000
@@ -1,51 +0,0 @@
-/***************************************************************************
-                          errordialog.h  -  description
-                             -------------------
-    begin                : Fri Feb 20 2009
-    copyright            : (C) 2009 by Sean M. Pappalardo
-    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 ERRORDIALOG_H
-#define ERRORDIALOG_H
-
-#include <QObject>
-
-/**
-  * Class used to allow all threads to display message boxes on error conditions
-  *
-  *@author Sean M. Pappalardo
-  */
-
-class ErrorDialog : public QObject {
-   Q_OBJECT
-public:
-    ErrorDialog();
-    ~ErrorDialog();
-    /** A qMessageHandler calls either of these to emit a signal to display the requested message box */
-    void requestErrorDialog(int type, QString message);
-    void requestErrorDialog(int type, QString title, QString message);
-    /** Allows a means for main() to skip exec() if there was a critical or fatal error dialog displayed on app initialization */
-    bool checkError();
-
-signals:
-    void showErrorDialog(int type, QString title, QString message);
-
-private:
-    bool m_errorCondition;
-
-private slots:
-    /** Actually displays the box */
-    void errorDialog(int type, QString title, QString message);
-};
-
-#endif

=== added file 'mixxx/src/errordialoghandler.cpp'
--- mixxx/src/errordialoghandler.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/errordialoghandler.cpp	2010-05-07 07:32:30 +0000
@@ -0,0 +1,208 @@
+/***************************************************************************
+                          errordialoghandler.cpp  -  description
+                             -------------------
+    begin                : Sun Feb 22 2009
+    copyright            : (C) 2009 by Sean M. Pappalardo
+    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 "errordialoghandler.h"
+#include <QMessageBox>
+#include <QtDebug>
+#include <QtCore>
+
+ErrorDialogProperties::ErrorDialogProperties() {
+    m_type = DLG_NONE;
+    m_icon = QMessageBox::NoIcon;
+    m_title = "Mixxx";
+    m_modal = true;
+}
+
+void ErrorDialogProperties::setTitle(QString title) {
+    m_title.append(" - ").append(title);
+}
+
+void ErrorDialogProperties::setText(QString text) {
+    // If no key is set, use this window text since it is likely to be unique
+    if (m_key.isEmpty()) m_key = text;
+    m_text = text;
+}
+
+void ErrorDialogProperties::setType(DialogType typeToSet) {
+    m_type = typeToSet;
+    switch (m_type) {
+        case DLG_FATAL:     // Fatal uses critical icon
+        case DLG_CRITICAL:  m_icon = QMessageBox::Critical; break;
+        case DLG_WARNING:   m_icon = QMessageBox::Warning; break;
+        case DLG_INFO:      m_icon = QMessageBox::Information; break;
+        case DLG_QUESTION:  m_icon = QMessageBox::Question; break;
+        case DLG_NONE:
+        default:
+            // default is NoIcon
+            break;
+    }
+}
+
+void ErrorDialogProperties::addButton(QMessageBox::StandardButton button) {
+    m_buttons.append(button);
+}
+
+
+// ----------------------------------------------------
+// ---------- ErrorDialogHandler begins here ----------
+
+ErrorDialogHandler::ErrorDialogHandler() {
+    m_pSignalMapper = new QSignalMapper(this);
+    connect(m_pSignalMapper, SIGNAL(mapped(QString)), this, SLOT(boxClosed(QString)));
+    
+    m_errorCondition=false;
+    connect(this, SIGNAL(showErrorDialog(ErrorDialogProperties*)),
+            this, SLOT(errorDialog(ErrorDialogProperties*)));
+}
+
+ErrorDialogHandler::~ErrorDialogHandler()
+{
+    delete m_pSignalMapper;
+    delete s_pInstance;
+}
+
+ErrorDialogProperties* ErrorDialogHandler::newDialogProperties() {
+    ErrorDialogProperties* props = new ErrorDialogProperties();
+    return props;
+}
+
+bool ErrorDialogHandler::requestErrorDialog(DialogType type, QString message) {
+    ErrorDialogProperties* props = newDialogProperties();
+    props->setType(type);
+    props->setText(message);
+    switch (type) {
+        case DLG_FATAL:     props->setTitle("Fatal error"); break;
+        case DLG_CRITICAL:  props->setTitle("Critical error"); break;
+        case DLG_WARNING:   props->setTitle("Warning"); break;
+        case DLG_INFO:      props->setTitle("Information"); break;
+        case DLG_QUESTION:  props->setTitle("Question"); break;
+        case DLG_NONE:
+        default:
+            // Default title & (lack of) icon is fine
+            break;
+    }
+    return requestErrorDialog(props);
+}
+
+bool ErrorDialogHandler::requestErrorDialog(ErrorDialogProperties* props) {
+
+    // Make sure the minimum items are set
+    QString text = props->getText();
+    Q_ASSERT(!text.isEmpty());
+    
+    // Skip if a dialog with the same key is already displayed
+    m_mutex.lock();
+    bool keyExists = m_dialogKeys.contains(props->getKey());
+    m_mutex.unlock();
+    if (keyExists) {
+        ErrorDialogProperties* dlgPropsTemp = props;
+        props = NULL;
+        delete dlgPropsTemp;
+        return false;
+    }
+    
+    emit (showErrorDialog(props));
+    return true;
+}
+
+void ErrorDialogHandler::errorDialog(ErrorDialogProperties* props) {
+    
+    // Jest makin' sho' this is only run in the main (GUI) thread
+    Q_ASSERT(QThread::currentThread()->objectName() == "Main");
+    
+    QMessageBox* msgBox = new QMessageBox();
+    
+    msgBox->setIcon(props->m_icon);
+    msgBox->setWindowTitle(props->m_title);
+    msgBox->setText(props->m_text);
+    if (!props->m_infoText.isEmpty()) msgBox->setInformativeText(props->m_infoText);
+    if (!props->m_details.isEmpty()) msgBox->setDetailedText(props->m_details);
+    
+    QPushButton* buttonToSet;
+    bool setDefault;
+    while(!props->m_buttons.isEmpty()) {
+        setDefault = false;
+        if (props->m_buttons.first() == props->m_defaultButton) setDefault = true;
+        
+        buttonToSet = msgBox->addButton(props->m_buttons.takeFirst());
+        
+        if (setDefault) msgBox->setDefaultButton(buttonToSet);
+    }
+    
+    if (props->m_escapeButton) msgBox->setEscapeButton(msgBox->button(props->m_escapeButton));
+    
+    msgBox->setModal(props->m_modal);
+    
+    // This deletes the msgBox automatically, avoiding a memory leak
+    msgBox->setAttribute(Qt::WA_DeleteOnClose, true);
+    
+    m_mutex.lock();
+    m_dialogKeys.append(props->m_key);    // To avoid duplicate dialogs on the same error
+    m_mutex.unlock();
+    
+    // Signal mapper calls our slot with the key parameter so it knows which to remove from the list
+    connect(msgBox, SIGNAL(finished(int)), m_pSignalMapper, SLOT(map()));
+    m_pSignalMapper->setMapping(msgBox, props->m_key);
+
+    if (props->m_modal) msgBox->exec();    // Blocks so the user has a chance to read it before application exit
+    else msgBox->show();
+
+    // If fatal, should we just abort here and not try to exit gracefully?
+    
+    if (props->m_type>=DLG_CRITICAL) {  // If critical/fatal, gracefully exit application if possible
+        m_errorCondition=true;
+        if (QCoreApplication::instance()) {
+            QCoreApplication::instance()->exit(-1);
+        }
+        else {
+            qDebug() << "QCoreApplication::instance() is NULL! Abruptly quitting...";
+            if (props->m_type==DLG_FATAL) abort();
+            else exit(-1);
+        }
+    }
+    
+    ErrorDialogProperties* dlgPropsTemp = props;
+    props = NULL;
+    delete dlgPropsTemp;
+}
+
+void ErrorDialogHandler::boxClosed(QString key)
+{
+    QMessageBox* msgBox = (QMessageBox*)m_pSignalMapper->mapping(key);
+
+    QMessageBox::StandardButton whichStdButton = msgBox->standardButton(msgBox->clickedButton());
+    
+    emit stdButtonClicked(key, whichStdButton);
+    
+    // If the user clicks "Ignore," we leave the key in the list so the same
+    //  error is not displayed again for the duration of the session
+    if (whichStdButton == QMessageBox::Ignore) {
+        qWarning() << "Suppressing this" << msgBox->windowTitle() << "error box for the duration of the application.";
+        return;
+    }
+    
+    m_mutex.lock();
+    if (m_dialogKeys.contains(key)) {
+        if (!m_dialogKeys.removeOne(key)) qWarning() << "Error dialog key removal from list failed!";
+    }
+    else qWarning() << "Error dialog key is missing from key list!";
+    m_mutex.unlock();
+}
+
+bool ErrorDialogHandler::checkError() {
+    return m_errorCondition;
+}
\ No newline at end of file

=== added file 'mixxx/src/errordialoghandler.h'
--- mixxx/src/errordialoghandler.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/errordialoghandler.h	2010-05-07 07:32:30 +0000
@@ -0,0 +1,138 @@
+/***************************************************************************
+                          errordialoghandler.h  -  description
+                             -------------------
+    begin                : Fri Feb 20 2009
+    copyright            : (C) 2009 by Sean M. Pappalardo
+    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 ERRORDIALOGHANDLER_H
+#define ERRORDIALOGHANDLER_H
+
+#include <QObject>
+#include <QMessageBox>
+#include <QSignalMapper>
+#include <QMutex>
+
+/**
+  * Class used to allow all threads to display message boxes on error conditions
+  *     with a custom list of standard buttons and to be able to react to them
+  *
+  *@author Sean M. Pappalardo
+  */
+
+typedef enum {
+    DLG_FATAL       = 5,
+    DLG_CRITICAL    = 4,
+    DLG_WARNING     = 3,
+    DLG_INFO        = 2,
+    DLG_QUESTION    = 1,
+    DLG_NONE        = 0 // No icon (default)
+} DialogType;
+
+class ErrorDialogProperties {
+    public:
+        // Befriending ErrorDialogHandler allows it to have cleaner code
+        //  since the two are closely related anyway
+        friend class ErrorDialogHandler;
+        
+        /** Set the window title. ("Mixxx" is always prepended.) */
+        void setTitle(QString title);
+        /** Set a key to prevent multiple dialogs until the first is closed */
+        void setKey(QString key) { m_key = key; }
+        QString getKey() { return m_key; }
+        /** Set the primary window text */
+        void setText(QString text);
+        QString getText() { return m_text; }
+        /** Set additional window text */
+        void setInfoText(QString text) { m_infoText = text; }
+        /** Set detailed text (causes "Show Details" button to appear.) */
+        void setDetails(QString text) { m_details = text; }
+        /** Set whether the box is modal (blocks the GUI) or not */
+        void setModal(bool modal) { m_modal = modal; }
+        /** Automatically sets the icon to match the type for convenience. */
+        void setType(DialogType typeToSet);
+        /** Set the box's icon to one of the standard ones */
+        void setIcon(QMessageBox::Icon icon) { m_icon = icon; }
+        
+        /** Add a standard button to the box */
+        void addButton(QMessageBox::StandardButton);
+        /** Set the default button to highlight */
+        void setDefaultButton(QMessageBox::StandardButton button) { m_defaultButton = button; }
+        /** Set the button to click if the Escape key is pressed */
+        void setEscapeButton(QMessageBox::StandardButton button) { m_escapeButton = button; }
+
+    protected:
+        // Protected since only ErrorDialogHandler should instantiate this
+        ErrorDialogProperties();
+        
+        QString m_title;
+        QString m_key;
+        QString m_text;
+        QString m_infoText;
+        QString m_details;
+        bool m_modal;
+        DialogType m_type;
+        QMessageBox::Icon m_icon;
+        /** List of standard buttons to add to the box, in order
+            Note that a QMessageBox::Ignore button, if clicked, will suppress
+            error boxes with the same key for the duration of the application. */
+        QList<QMessageBox::StandardButton> m_buttons;
+        /** The default button to highlight, if any. */
+        QMessageBox::StandardButton m_defaultButton;
+        /** The button that's clicked if the Escape key is pressed. */
+        QMessageBox::StandardButton m_escapeButton;
+};
+
+/** Singleton class because we only need one Handler to manage all error dialogs */
+class ErrorDialogHandler : public QObject {
+   Q_OBJECT
+public:
+    static ErrorDialogHandler* instance() {
+        if (!s_pInstance)
+            s_pInstance = new ErrorDialogHandler;
+        return s_pInstance;
+    }
+
+    ~ErrorDialogHandler();
+    /** Call this to get a new instance of ErrorDialogProperties to populate with data */
+    ErrorDialogProperties* newDialogProperties();
+    /** A qMessageHandler or any thread calls either of these to emit a signal to display the requested message box */
+    /** They return false if a dialog with the same key (or title if no key) is already displayed */
+    bool requestErrorDialog(DialogType type, QString message);
+    bool requestErrorDialog(ErrorDialogProperties* props);
+    /** Allows a means for main() to skip exec() if there was a critical or fatal error dialog displayed on app initialization */
+    bool checkError();
+    
+signals:
+    void showErrorDialog(ErrorDialogProperties* props);
+    void stdButtonClicked(QString key, QMessageBox::StandardButton whichStdButton);
+
+private:
+    ErrorDialogHandler();                                       // Private constructor
+    ErrorDialogHandler(const ErrorDialogHandler&);              // Prevent copy-construction
+    ErrorDialogHandler& operator=(const ErrorDialogHandler&);   // Prevent assignment
+    
+    static ErrorDialogHandler *s_pInstance;
+    
+    bool m_errorCondition;
+    QList<QString> m_dialogKeys;
+    QSignalMapper* m_pSignalMapper;
+    QMutex m_mutex;
+
+private slots:
+    /** Actually displays the box */
+    void errorDialog(ErrorDialogProperties* props);
+    void boxClosed(QString key);
+};
+
+#endif

=== modified file 'mixxx/src/main.cpp'
--- mixxx/src/main.cpp	2010-04-12 07:42:45 +0000
+++ mixxx/src/main.cpp	2010-05-07 07:32:30 +0000
@@ -31,8 +31,9 @@
 #include "mixxx.h"
 #include "qpixmap.h"
 #include "qsplashscreen.h"
-#include "errordialog.h"
+#include "errordialoghandler.h"
 #include "defs_audiofiles.h"
+#include "defs_version.h"
 
 #ifdef __LADSPA__
 #include <ladspa/ladspaloader.h>
@@ -70,72 +71,12 @@
 QApplication * a;
 
 QStringList plugin_paths; //yes this is global. sometimes global is good.
-ErrorDialog *dialogHelper; //= new ErrorDialog();   // allows threads to show error dialogs
+ErrorDialogHandler* ErrorDialogHandler::s_pInstance = 0;    // Resolves "undefined reference" linker errors
 
 void qInitImages_mixxx();
 
-void MessageOutput( QtMsgType type, const char * msg )
-{
-    static QMutex mutex;
-    QMutexLocker locker(&mutex);
-
-    switch ( type ) {
-    case QtDebugMsg:
-#ifdef __WINDOWS__
-        if (strstr(msg, "doneCurrent")) {
-            break;
-        }
-#endif
-        fprintf( stderr, "Debug: %s\n", msg );
-        break;
-    case QtWarningMsg:
-        fprintf( stderr, "Warning: %s\n", msg);
-        break;
-    case QtCriticalMsg:
-        fprintf( stderr, "Critical: %s\n", msg );
-        QMessageBox::warning(0, "Mixxx", msg);
-        exit(-1);
-        break;
-    case QtFatalMsg:
-        fprintf( stderr, "Fatal: %s\n", msg );
-        QMessageBox::warning(0, "Mixxx", msg);
-        abort();
-    }
-}
-
 QFile Logfile; // global logfile variable
 
-
-void MessageToLogfile( QtMsgType type, const char * msg )
-{
-    static QMutex mutex;
-    QMutexLocker locker(&mutex);
-    
-    Q3TextStream Log( &Logfile );
-    switch ( type ) {
-    case QtDebugMsg:
-        Log << "Debug: " << msg << "\n";
-        break;
-    case QtWarningMsg:
-        Log << "Warning: " << msg << "\n";
-        //a->lock(); //this doesn't do anything in Qt4
-        QMessageBox::warning(0, "Mixxx", msg);
-        //a->unlock();
-        break;
-    case QtCriticalMsg:
-        fprintf( stderr, "Critical: %s\n", msg );
-        QMessageBox::warning(0, "Mixxx", msg);
-        exit(-1);
-        break;
-    case QtFatalMsg:
-        fprintf( stderr, "Fatal: %s\n", msg );
-        QMessageBox::warning(0, "Mixxx", msg);
-        abort();
-    }
-    Logfile.flush();
-}
-
-
 /* Debug message handler which outputs to both a logfile and a
  * and prepends the thread the message came from too.
  *
@@ -161,7 +102,9 @@
 #endif
     }
       
-    Q3TextStream Log( &Logfile );	
+    Q3TextStream Log( &Logfile );
+    
+    ErrorDialogHandler* dialogHandler = ErrorDialogHandler::instance();    
     
     switch ( type ) {
     case QtDebugMsg:
@@ -176,26 +119,22 @@
     case QtWarningMsg:
         fprintf( stderr, "Warning: %s\n", s);
         Log << "Warning: " << s << "\n";
-        //QMessageBox::warning(0, "Mixxx", input);
-        //dialogHelper->requestErrorDialog(0,input);
-        //I will break your legs if you re-enable the above lines of code.
-        //You shouldn't be using qWarning for reporting user-facing errors.
-        //Implement your own error message box...
-        // - Albert (March 11, 2010)
+        // Don't use qWarning for reporting user-facing errors.
+        //dialogHandler->requestErrorDialog(DLG_WARNING,input);
         break;
     case QtCriticalMsg:
         fprintf( stderr, "Critical: %s\n", s );
         Log << "Critical: " << s << "\n";
-         //QMessageBox::critical(0, "Mixxx", input);
-        dialogHelper->requestErrorDialog(1,input);
-//         exit(-1);
-        break; //NOTREACHED(?)
+        Logfile.flush();    // Ensure the error is written to the log before exiting
+        dialogHandler->requestErrorDialog(DLG_CRITICAL,input);
+//         exit(-1);    // Done in ErrorDialogHandler
+        break; //NOTREACHED
     case QtFatalMsg:
         fprintf( stderr, "Fatal: %s\n", s );
         Log << "Fatal: " << s << "\n";
-        //QMessageBox::critical(0, "Mixxx", input);
-        dialogHelper->requestErrorDialog(1,input);
-        abort();
+        Logfile.flush();    // Ensure the error is written to the log before aborting
+        dialogHandler->requestErrorDialog(DLG_FATAL,input);
+//         abort();    // Done in ErrorDialogHandler
         break; //NOTREACHED
     }
     Logfile.flush();
@@ -208,22 +147,21 @@
 
 
 //it seems like this code should be inline in MessageHandler() but for some reason having it there corrupts the messages sometimes -kousu 2/2009
-	
+    
 
 #ifdef __WINDOWS__
   #ifdef DEBUGCONSOLE
     InitDebugConsole();
   #endif
 #endif
-   dialogHelper = new ErrorDialog(); 
-
     qInstallMsgHandler( MessageHandler );
-
+    
+    // Other things depend on this name to enforce thread exclusivity,
+    //  so if you change it here, change it also in:
+    //      * ErrorDialogHandler::errorDialog()
     QThread::currentThread()->setObjectName("Main");
     a = new QApplication(argc, argv);
 
-
-
 #ifdef __LADSPA__
     //LADSPALoader ladspaloader;
 #endif
@@ -251,7 +189,9 @@
     for (int i=0; i<argc; ++i)
     {
         if (argv[i]==QString("-h") || argv[i]==QString("--h") || argv[i]==QString("--help")) {
-            printf("Mixxx digital DJ software - command line options");
+            printf("Mixxx digital DJ software v");
+            printf(VERSION);
+            printf(" - Command line options");
             printf("\n(These are case-sensitive.)\n\n\
     [FILE]                  Load the specified music file(s) at start-up.\n\
                             Each must be one of the following file types:\n\
@@ -345,7 +285,7 @@
     
     int result = -1;
 
-    if (!dialogHelper->checkError()) {
+    if (!(ErrorDialogHandler::instance()->checkError())) {
         qDebug() << "Displaying mixxx";
         mixxx->show();
     
@@ -355,12 +295,12 @@
     
     delete mixxx;
     
-	qDebug() << "Mixxx shutdown complete.";
+    qDebug() << "Mixxx shutdown complete with code" << result;
 
-	// Don't make any more output after this
-	//	or mixxx.log will get clobbered!
+    // Don't make any more output after this
+    //    or mixxx.log will get clobbered!
     if(Logfile.isOpen())
-	Logfile.close();
+    Logfile.close();
     
     //delete plugin_paths;
     return result;

=== modified file 'mixxx/src/midi/midimapping.cpp'
--- mixxx/src/midi/midimapping.cpp	2010-02-02 19:33:39 +0000
+++ mixxx/src/midi/midimapping.cpp	2010-05-07 07:32:30 +0000
@@ -30,14 +30,15 @@
 #include "mididevicedummy.h"
 #include "midiledhandler.h"
 #include "configobject.h"
+#include "errordialoghandler.h"
 
 #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);
-}
+// static QString toHex(QString numberStr) {
+//     return "0x" + QString("0" + QString::number(numberStr.toUShort(), 16).toUpper()).right(2);
+// }
 
 MidiMapping::MidiMapping(MidiDevice* outputMidiDevice)
         : QObject(),
@@ -75,9 +76,12 @@
 
     if(m_pScriptEngine) return;
 
-    //XXX Deadly hack attack:
+    //XXX FIXME: Deadly hack attack:
     if (m_pOutputMidiDevice == NULL) {
         m_pOutputMidiDevice = new MidiDeviceDummy(this); //Just make some dummy device :(
+        /* Why can't this be the same as the input MIDI device? Most of the time,
+            the script engine thinks of it as the input device. Scripting is useful
+            even if the MIDI device has no outputs - Sean 4/19/10   */
     }
     //XXX Memory leak :(
 
@@ -110,6 +114,9 @@
             m_pScriptEngine, SLOT(execute(QString)));
     connect(this, SIGNAL(callMidiScriptFunction(QString, QString)),
             m_pScriptEngine, SLOT(execute(QString, QString)));
+            
+    // Allow the MidiScriptEngine to tell us if it needs to reset the controller (on errors)
+    connect(m_pScriptEngine, SIGNAL(resetController()), this, SLOT(reset()));
 }
 
 void MidiMapping::loadScriptCode() {
@@ -598,13 +605,46 @@
             if (mixxxControl.getMidiOption()==MIDI_OPT_SCRIPT &&
                 scriptFunctions.indexOf(mixxxControl.getControlObjectValue())==-1) {
 
-                QString statusText = QString(midiMessage.getMidiStatusByte());
-                qWarning() << "Error: Function" << mixxxControl.getControlObjectValue()
-                           << "was not found in loaded scripts."
-                           << "The MIDI Message with status byte"
-                           << statusText << midiMessage.getMidiNo()
-                           << "will not be bound. Please check the"
-                           << "mapping and script files.";
+                QString status = QString("%1").arg(midiMessage.getMidiStatusByte(), 0, 16).toUpper();
+                status = "0x"+status;
+                QString byte2 = QString("%1").arg(midiMessage.getMidiNo(), 0, 16).toUpper();
+                byte2 = "0x"+byte2;
+            
+                // If status is MIDI pitch, the 2nd byte is part of the payload so don't display it
+                if (midiMessage.getMidiStatusByte() == 0xE0) byte2 = "";
+            
+                QString errorLog = QString("MIDI script function \"%1\" not found. "
+                                    "(Mapped to MIDI message %2 %3)")
+                                    .arg(mixxxControl.getControlObjectValue())
+                                    .arg(status)
+                                    .arg(byte2);
+                
+                if (m_pOutputMidiDevice != NULL 
+                    && m_pOutputMidiDevice->midiDebugging()) {
+                        qCritical() << errorLog;
+                }
+                else {
+                    qWarning() << errorLog;
+                    ErrorDialogProperties* props = ErrorDialogHandler::instance()->newDialogProperties();
+                    props->setType(DLG_WARNING);
+                    props->setTitle(tr("MIDI script function not found"));
+                    props->setText(QString(tr("The MIDI script function '%1' was not "
+                                    "found in loaded scripts."))
+                                    .arg(mixxxControl.getControlObjectValue()));
+                    props->setInfoText(QString(tr("The MIDI message %1 %2 will not be bound."
+                                    "\n(Click Show Details for hints.)"))
+                                    .arg(status)
+                                    .arg(byte2));
+                    QString detailsText = QString(tr("* Check to see that the "
+                        "function name is spelled correctly in the mapping "
+                        "file (.xml) and script file (.js)\n"));
+                    detailsText += QString(tr("* Check to see that the script "
+                        "file name (.js) is spelled correctly in the mapping "
+                        "file (.xml)"));
+                    props->setDetails(detailsText);
+                    
+                    ErrorDialogHandler::instance()->requestErrorDialog(props);
+                }
             } else {
 #endif
                 //Add to the input mapping.
@@ -936,7 +976,7 @@
 /*MixxxControl* MidiMapping::getInputMixxxControl(MidiMessage command)
 {
     if (!m_inputMapping.contains(command)) {
-        qDebug() << "Warning: unbound MIDI command";
+        qWarning() << "Unbound MIDI command";
         qDebug() << "Midi Status:" << command.getMidiStatusByte();
         qDebug() << "Midi No:" << command.getMidiNo();
         qDebug() << "Midi Channel:" << command.getMidiChannel();
@@ -1109,6 +1149,14 @@
 }
 #endif
 
+// Reset the MIDI controller
+void MidiMapping::reset() {
+#ifdef __MIDISCRIPT__   // Can't ifdef slots in the .h file, so we just do the body.
+    restartScriptEngine();
+    applyPreset();
+#endif
+}
+
 void MidiMapping::slotScriptEngineReady() {
 #ifdef __MIDISCRIPT__	// Can't ifdef slots in the .h file, so we just do the body.
 

=== modified file 'mixxx/src/midi/midimapping.h'
--- mixxx/src/midi/midimapping.h	2010-02-02 19:33:39 +0000
+++ mixxx/src/midi/midimapping.h	2010-05-07 07:32:30 +0000
@@ -102,6 +102,9 @@
     void beginMidiLearn(MixxxControl control);
     void cancelMidiLearn();
     void slotScriptEngineReady();
+    /** Restarts the script engine and re-applies the mapping
+        to effectively reset the controller */
+    void reset();
     
 signals:
     void inputMappingChanged();

=== modified file 'mixxx/src/midi/midiscriptengine.cpp'
--- mixxx/src/midi/midiscriptengine.cpp	2010-03-24 07:13:38 +0000
+++ mixxx/src/midi/midiscriptengine.cpp	2010-05-07 07:32:30 +0000
@@ -20,13 +20,15 @@
 #include "controlobjectthread.h"
 #include "mididevice.h"
 #include "midiscriptengine.h"
+#include "errordialoghandler.h"
+
 // #include <QScriptSyntaxCheckResult>
 
 #ifdef _MSC_VER
-#include <float.h>  // for _isnan() on VC++
-#define isnan(x) _isnan(x)  // VC++ uses _isnan() instead of isnan()
+    #include <float.h>  // for _isnan() on VC++
+    #define isnan(x) _isnan(x)  // VC++ uses _isnan() instead of isnan()
 #else
-#include <math.h>  // for isnan() everywhere else
+    #include <math.h>  // for isnan() everywhere else
 #endif
 
 
@@ -34,6 +36,8 @@
     m_pEngine(NULL),
     m_pMidiDevice(midiDevice)
 {
+    // Handle error dialog buttons
+    qRegisterMetaType<QMessageBox::StandardButton>("QMessageBox::StandardButton");
 }
 
 MidiScriptEngine::~MidiScriptEngine() {
@@ -56,6 +60,7 @@
 -------- ------------------------------------------------------ */
 void MidiScriptEngine::gracefulShutdown(QList<QString> scriptFunctionPrefixes) {
     qDebug() << "MidiScriptEngine shutting down...";
+
     m_scriptEngineLock.lock();
     // Clear the m_connectedControls hash so we stop responding
     // to signals.
@@ -65,7 +70,7 @@
     disconnect(m_pMidiDevice, SIGNAL(callMidiScriptFunction(QString, char, char,
                                                             char, MidiStatusByte, QString)),
                                 this, SLOT(execute(QString, char, char, char, MidiStatusByte, QString)));
-
+                                
     // Stop all timers
     stopAllTimers();
 
@@ -201,6 +206,9 @@
     QThread::currentThread()->setObjectName(QString("MidiScriptEngine %1").arg(++id));
 
     // Prevent the script engine from strangling other parts of Mixxx
+    //  incase of a misbehaving script
+    //  - Should we perhaps not do this when running with --midiDebug so it's more
+    //      obvious if a script is taking too much CPU time? - Sean 4/19/10
     QThread::currentThread()->setPriority(QThread::LowPriority);
 
     m_scriptEngineLock.lock();
@@ -233,7 +241,7 @@
 bool MidiScriptEngine::execute(QString function) {
     m_scriptEngineLock.lock();
     bool ret = safeExecute(function);
-    if (!ret) qDebug() << "MidiScriptEngine: Invalid script function" << function;
+    if (!ret) qWarning() << "MidiScriptEngine: Invalid script function" << function;
     m_scriptEngineLock.unlock();
     return ret;
 }
@@ -246,7 +254,7 @@
 bool MidiScriptEngine::execute(QString function, QString data) {
     m_scriptEngineLock.lock();
     bool ret = safeExecute(function, data);
-    if (!ret) qDebug() << "MidiScriptEngine: Invalid script function" << function;
+    if (!ret) qWarning() << "MidiScriptEngine: Invalid script function" << function;
     m_scriptEngineLock.unlock();
     return ret;
 }
@@ -262,7 +270,7 @@
                                QString group) {
     m_scriptEngineLock.lock();
     bool ret = safeExecute(function, channel, control, value, status, group);
-    if (!ret) qDebug() << "MidiScriptEngine: Invalid script function" << function;
+    if (!ret) qWarning() << "MidiScriptEngine: Invalid script function" << function;
     m_scriptEngineLock.unlock();
     return ret;
 }
@@ -326,12 +334,7 @@
         .arg(scriptCode);
 
         if (m_midiDebug) qCritical() << "MidiScriptEngine:" << error;
-        else {
-            qDebug() << "MidiScriptEngine:" << error;
-            qWarning() << "There was an error in a MIDI script."
-                          "\nA control you just used is not working properly and you may experience erratic behavior."
-                          "\nCheck the console or mixxx.log file for details.";
-        }
+        else scriptErrorDialog(error);
         return false;
     }
 
@@ -433,30 +436,76 @@
         QString filename = exception.property("fileName").toString();
 
         QStringList error;
-        error << filename << errorMessage << QString(line);
-        m_scriptErrors.insert(filename, error);
-
+        error << (filename.isEmpty() ? "" : filename) << errorMessage << QString(line);
+        m_scriptErrors.insert((filename.isEmpty() ? "passed code" : filename), error);
+        
+        QString errorText = QString(tr("Uncaught exception at line %1 in file %2: %3"))
+                            .arg(line)
+                            .arg((filename.isEmpty() ? "" : filename))
+                            .arg(errorMessage);
+                            
+        if (filename.isEmpty())
+            errorText = QString(tr("Uncaught exception at line %1 in passed code: %2"))
+                        .arg(line)
+                        .arg(errorMessage);
+        
         if (m_midiDebug)
-            qCritical() << "MidiScriptEngine: uncaught exception:"
-                        << errorMessage
-                        << "in" << filename << "at line"
-                        << line
+            qCritical() << "MidiScriptEngine:" << errorText
                         << "\nBacktrace:\n"
                         << backtrace;
-        else {
-            qDebug() << "MidiScriptEngine WARNING: uncaught exception:"
-                         << errorMessage
-                         << "in" << filename << "at line"
-                         << line;
-            qWarning() << "There was a problem with a MIDI script."
-                          "\nA control you just used is not working properly and you may experience erratic behavior."
-                          "\nCheck the console or mixxx.log file for details.";
-        }
+        else scriptErrorDialog(errorText);
         return true;
     }
     return false;
 }
 
+/* -------- ------------------------------------------------------
+Purpose: Common error dialog creation code for run-time exceptions
+            Allows users to ignore the error or reload the mappings
+Input:   Detailed error string
+Output:  -
+-------- ------------------------------------------------------ */
+void MidiScriptEngine::scriptErrorDialog(QString detailedError) {
+    qWarning() << "MidiScriptEngine:" << detailedError;
+    ErrorDialogProperties* props = ErrorDialogHandler::instance()->newDialogProperties();
+    props->setType(DLG_WARNING);
+    props->setTitle(tr("MIDI script error"));
+    props->setText(tr("A MIDI control you just used is not working properly."));
+    props->setInfoText(tr("<html>(The MIDI script code needs to be fixed.)"
+        "<br>For now, you can:<ul><li>Ignore this error for this session but you may experience erratic behavior</li>"
+        "<li>Try to recover by resetting your controller</li></ul></html>"));
+    props->setDetails(detailedError);
+    props->setKey(detailedError);   // To prevent multiple windows for the same error
+    
+    // Allow user to suppress further notifications about this particular error
+    props->addButton(QMessageBox::Ignore);
+    
+    props->addButton(QMessageBox::Retry);
+    props->addButton(QMessageBox::Close);
+    props->setDefaultButton(QMessageBox::Close);
+    props->setEscapeButton(QMessageBox::Close);
+    props->setModal(false);
+    
+    if (ErrorDialogHandler::instance()->requestErrorDialog(props)) {
+        // Enable custom handling of the dialog buttons
+        connect(ErrorDialogHandler::instance(), SIGNAL(stdButtonClicked(QString, QMessageBox::StandardButton)),
+                this, SLOT(errorDialogButton(QString, QMessageBox::StandardButton)));
+    }
+}
+
+/* -------- ------------------------------------------------------
+Purpose: Slot to handle custom button clicks in error dialogs
+Input:   Key of dialog, StandardButton that was clicked
+Output:  -
+-------- ------------------------------------------------------ */
+void MidiScriptEngine::errorDialogButton(QString key, QMessageBox::StandardButton button) {
+    
+    // Something was clicked, so disable this signal now
+    disconnect(ErrorDialogHandler::instance(), SIGNAL(stdButtonClicked(QString, QMessageBox::StandardButton)),
+        this, SLOT(errorDialogButton(QString, QMessageBox::StandardButton)));
+            
+    if (button == QMessageBox::Retry) emit(resetController());
+}
 
 /* -------- ------------------------------------------------------
    Purpose: Returns a list of functions available in the QtScript
@@ -541,7 +590,7 @@
 
     ControlObjectThread *cot = getControlObjectThread(group, name);
     if (cot == NULL) {
-        qDebug() << "MidiScriptEngine: Unknown control" << group << name;
+        qWarning() << "MidiScriptEngine: Unknown control" << group << name;
         return 0.0;
     }
 
@@ -564,7 +613,7 @@
     }
 
     if(isnan(newValue)) {
-        qDebug() << "Warning: script setting [" << group << "," << name
+        qWarning() << "MidiScriptEngine: script setting [" << group << "," << name
                  << "] to NotANumber, ignoring.";
         return;
     }
@@ -658,7 +707,7 @@
 
     ControlObject* sender = (ControlObject*)this->sender();
     if(sender == NULL) {
-        qDebug() << "MidiScriptEngine::slotValueChanged() Shouldn't happen -- sender == NULL";
+        qWarning() << "MidiScriptEngine::slotValueChanged() Shouldn't happen -- sender == NULL";
         m_scriptEngineLock.unlock();
         return;
     }
@@ -674,16 +723,15 @@
         QScriptValue function_value = m_pEngine->evaluate(function);
         QScriptValueList args;
         args << QScriptValue(m_pEngine, value);
-//         function_value.call(QScriptValue(), args);
         args << QScriptValue(m_pEngine, key.group); // Added by Math`
         args << QScriptValue(m_pEngine, key.item);  // Added by Math`
         QScriptValue result = function_value.call(QScriptValue(), args);
         if (result.isError()) {
-            qDebug()<< "MidiScriptEngine: Call to " << function << " resulted in an error:  " << result.toString();
+            qWarning()<< "MidiScriptEngine: Call to " << function << " resulted in an error:  " << result.toString();
         }
 
     } else {
-        qDebug() << "MidiScriptEngine::slotValueChanged() Received signal from ControlObject that is not connected to a script function.";
+        qWarning() << "MidiScriptEngine::slotValueChanged() Received signal from ControlObject that is not connected to a script function.";
     }
 
     m_scriptEngineLock.unlock();
@@ -705,11 +753,24 @@
     // Read in the script file
     QFile input(filename);
     if (!input.open(QIODevice::ReadOnly)) {
-        qCritical() << "MidiScriptEngine: Problem opening the script file: "
-                    << filename
-                    << ", error #"
-                    << input.error();
-        return false;
+        QString errorLog = 
+            QString("MidiScriptEngine: Problem opening the script file: %1, error # %2, %3")
+                .arg(filename)
+                .arg(input.error())
+                .arg(input.errorString());
+                        
+        if (m_midiDebug) qCritical() << errorLog;
+        else {
+            qWarning() << errorLog;
+            ErrorDialogProperties* props = ErrorDialogHandler::instance()->newDialogProperties();
+            props->setType(DLG_WARNING);
+            props->setTitle("MIDI script file problem");
+            props->setText(QString("There was a problem opening the MIDI script file %1.").arg(filename));
+            props->setInfoText(input.errorString());
+            
+            ErrorDialogHandler::instance()->requestErrorDialog(props);
+            return false;
+        }
     }
     QString scriptCode = "";
     scriptCode.append(input.readAll());
@@ -738,10 +799,15 @@
 
         if (m_midiDebug) qCritical() << "MidiScriptEngine:" << error;
         else {
-            qDebug() << "MidiScriptEngine:" << error;
-            qWarning() << "There was an error in the MIDI script file" << filename
-                       << "\nThe functionality provided by this script file will be disabled."
-                          "\nCheck the console or mixxx.log file for details.";
+            qWarning() << "MidiScriptEngine:" << error;
+            ErrorDialogProperties* props = ErrorDialogHandler::instance()->newDialogProperties();
+            props->setType(DLG_WARNING);
+            props->setTitle("MIDI script file error");
+            props->setText(QString("There was an error in the MIDI script file %1.").arg(filename));
+            props->setInfoText("The functionality provided by this script file will be disabled.");
+            props->setDetails(error);
+            
+            ErrorDialogHandler::instance()->requestErrorDialog(props);
         }
         return false;
     }
@@ -799,7 +865,7 @@
     }
 
     if (interval<20) {
-        qDebug() << "Timer request for" << interval << "ms is too short. Setting to the minimum of 20ms.";
+        qWarning() << "Timer request for" << interval << "ms is too short. Setting to the minimum of 20ms.";
         interval=20;
     }
     // This makes use of every QObject's internal timer mechanism. Nice, clean, and simple.
@@ -809,7 +875,7 @@
     timerTarget.first = scriptCode;
     timerTarget.second = oneShot;
     m_timers[timerId]=timerTarget;
-    if (timerId==0) qDebug() << "MIDI Script timer could not be created";
+    if (timerId==0) qWarning() << "MIDI Script timer could not be created";
     else if (m_midiDebug) {
         if (oneShot) qDebug() << "Starting one-shot timer:" << timerId;
         else qDebug() << "Starting timer:" << timerId;
@@ -830,7 +896,7 @@
     if(lock) m_scriptEngineLock.unlock();
 
     if (!m_timers.contains(timerId)) {
-        qDebug() << "Killing timer" << timerId << ": That timer does not exist!";
+        qWarning() << "Killing timer" << timerId << ": That timer does not exist!";
         return;
     }
     if (m_midiDebug) qDebug() << "Killing timer:" << timerId;
@@ -868,7 +934,7 @@
 
     m_scriptEngineLock.lock();
     if (!m_timers.contains(timerId)) {
-        qDebug() << "Timer" << timerId << "fired but there's no function mapped to it!";
+        qWarning() << "Timer" << timerId << "fired but there's no function mapped to it!";
         m_scriptEngineLock.unlock();
         return;
     }

=== modified file 'mixxx/src/midi/midiscriptengine.h'
--- mixxx/src/midi/midiscriptengine.h	2010-02-03 14:13:29 +0000
+++ mixxx/src/midi/midiscriptengine.h	2010-05-07 07:32:30 +0000
@@ -19,6 +19,7 @@
 
 #include <QEvent>
 #include <QtScript>
+#include <QMessageBox>
 #include "configobject.h"
 #include "midimessage.h"
 class MidiDevice;
@@ -68,11 +69,15 @@
     
 signals:
     void initialized();
+    void resetController();
 
 protected:
     void run();
     void timerEvent(QTimerEvent *event);
 
+private slots:
+    void errorDialogButton(QString key, QMessageBox::StandardButton button);
+    
 private:
     // Only call these with the scriptEngineLock
     bool safeEvaluate(QString filepath);
@@ -82,14 +87,14 @@
     bool safeExecute(QString function, char channel, 
                      char control, char value, MidiStatusByte status, QString group);
     void initializeScriptEngine();
-
+    
+    void scriptErrorDialog(QString detailedError);
     void generateScriptFunctions(QString code);
     bool checkException();
     void stopAllTimers();
 
     ControlObjectThread* getControlObjectThread(QString group, QString name);
-    
-    
+        
     MidiDevice* m_pMidiDevice;
     bool m_midiDebug;
     QHash<ConfigKey, QString> m_connectedControls;
@@ -98,7 +103,7 @@
     QMap<QString,QStringList> m_scriptErrors;
     QMutex m_scriptEngineLock;
     QHash<ConfigKey, ControlObjectThread*> m_controlCache;
-	QHash<int, QPair<QString, bool> > m_timers;
+    QHash<int, QPair<QString, bool> > m_timers;
 };
 
 #endif

=== modified file 'mixxx/src/mixxxcontrol.cpp'
--- mixxx/src/mixxxcontrol.cpp	2009-04-26 17:25:30 +0000
+++ mixxx/src/mixxxcontrol.cpp	2010-05-07 07:32:30 +0000
@@ -61,7 +61,7 @@
         m_midiOption = MIDI_OPT_SCRIPT;
     else {
         m_midiOption = MIDI_OPT_NORMAL;
-        qDebug() << "Warning: Unknown midioption" << strMidiOption << "in" << __FILE__;
+        qWarning() << "Unknown midioption" << strMidiOption << "in" << __FILE__;
     }
     
     //Parse threshold stuff, only used for output.
@@ -140,7 +140,7 @@
         strMidiOption = "script-binding";
     else {
         strMidiOption = "Unknown";
-        qDebug() << "Warning: Unknown midioption in" << __FILE__;
+        qWarning() << "Unknown midioption in" << __FILE__;
     }
 
     QDomElement singleOption = nodeMaker.createElement(strMidiOption);

=== modified file 'mixxx/src/recording/writeaudiofile.cpp'
--- mixxx/src/recording/writeaudiofile.cpp	2008-04-29 05:21:46 +0000
+++ mixxx/src/recording/writeaudiofile.cpp	2010-05-07 07:32:30 +0000
@@ -90,7 +90,7 @@
         }
     }
     else
-        qDebug() << "Warning: Tried to open WriteAudioFile before recording control was set to RECORD_ON";
+        qWarning() << "Tried to open WriteAudioFile before recording control was set to RECORD_ON";
 }
 
 void WriteAudioFile::write(const CSAMPLE * pIn, int iBufferSize)

=== modified file 'mixxx/src/soundsourcemp3.cpp'
--- mixxx/src/soundsourcemp3.cpp	2010-02-25 10:14:57 +0000
+++ mixxx/src/soundsourcemp3.cpp	2010-05-07 07:32:30 +0000
@@ -318,7 +318,7 @@
         break;
     default:             //By the MP3 specs, an MP3 _has_ to have one of the above samplerates...
         units = MAD_UNITS_44100_HZ;
-        qDebug() << "Warning: MP3 with corrupt samplerate (" << SRATE << "), defaulting to 44100";
+        qWarning() << "MP3 with corrupt samplerate (" << SRATE << "), defaulting to 44100";
 
         SRATE = 44100; //Prevents division by zero errors.
     }

=== modified file 'mixxx/src/upgrade.cpp'
--- mixxx/src/upgrade.cpp	2010-03-06 21:46:14 +0000
+++ mixxx/src/upgrade.cpp	2010-05-07 07:32:30 +0000
@@ -190,8 +190,10 @@
 
     if (configVersion == VERSION) qDebug() << "Configuration file is at the current version" << VERSION;
     else {
-        qDebug() << "Warning: Configuration file is at version" << configVersion << "and I don't know how to upgrade it to the current" << VERSION;
-        qDebug() << "   (That means a function to do this needs to be added to upgrade.cpp.)";
+        qWarning() << "Configuration file is at version" << configVersion
+                   << "and I don't know how to upgrade it to the current" << VERSION
+                   << "\n   (That means a function to do this needs to be added to upgrade.cpp.)"
+                   << "\n-> Leaving the configuration file version as-is.";
     }
 
     return config;

=== modified file 'mixxx/src/widget/wpushbutton.cpp'
--- mixxx/src/widget/wpushbutton.cpp	2009-07-07 06:26:30 +0000
+++ mixxx/src/widget/wpushbutton.cpp	2010-05-07 07:32:30 +0000
@@ -90,7 +90,7 @@
             //If we have 2 states, tell my controlpushbutton object that we're a toggle button.
           if (iNumStates == 2) {
             if (p == 0)
-              qDebug() << "Warning: wpushbutton p is null\n";
+              qWarning() << "wpushbutton p is null\n";
             else
               p->setToggleButton(true);
           }