Use OSC Messaging to avoid calling QMessageBox from the core

CMakeLists.txt

@@ -465,6 +465,7 @@ ADD_SUBDIRECTORY(plugins)
 ADD_SUBDIRECTORY(tests)
 ADD_SUBDIRECTORY(data)
 ADD_SUBDIRECTORY(doc)
+ADD_SUBDIRECTORY(lib)
 
 # post-install tasks
 ADD_SUBDIRECTORY(cmake/postinstall)

include/Engine.h

@@ -30,6 +30,7 @@
 #include <QtCore/QString>
 #include <QtCore/QObject>
 
+#include "Messenger.h"
 
 #include "export.h"
 
@@ -42,9 +43,8 @@ class Song;
 class Ladspa2LMMS;
 
 
-class EXPORT Engine : public QObject
+class EXPORT Engine
 {
-	Q_OBJECT
 public:
 	static void init( bool renderOnly );
 	static void destroy();
@@ -85,23 +85,16 @@ class EXPORT Engine : public QObject
 		return s_dummyTC;
 	}
 
-	static float framesPerTick()
+	static Messenger * messenger()
 	{
-		return s_framesPerTick;
+		return &s_messenger;
 	}
-	static void updateFramesPerTick();
 
-	static inline Engine * inst()
+	static float framesPerTick()
 	{
-		if( s_instanceOfMe == NULL )
-		{
-			s_instanceOfMe = new Engine();
-		}
-		return s_instanceOfMe;
+		return s_framesPerTick;
 	}
-
-signals:
-	void initProgress(const QString &msg);
+	static void updateFramesPerTick();
 
 
 private:
@@ -127,6 +120,9 @@ class EXPORT Engine : public QObject
 
 	static Ladspa2LMMS * s_ladspaManager;
 
+	// object to send/receive Open Sound Control messages
+	static Messenger s_messenger;
+
 	// even though most methods are static, an instance is needed for Qt slots/signals
 	static Engine * s_instanceOfMe;
 

include/GuiApplication.h

@@ -25,11 +25,14 @@
 #ifndef GUIAPPLICATION_H
 #define GUIAPPLICATION_H
 
-#include <QtCore/QObject>
+#include <QObject>
+#include <QString>
 
 #include "export.h"
+#include "OscMsgListener.h"
 
 class QLabel;
+class QSplashScreen;
 
 class AutomationEditorWindow;
 class BBEditor;
@@ -40,11 +43,12 @@ class PianoRollWindow;
 class ProjectNotes;
 class SongEditorWindow;
 
-class EXPORT GuiApplication : public QObject
+class EXPORT GuiApplication : public QObject, public OscMsgListener
 {
 	Q_OBJECT;
 public:
-	explicit GuiApplication();
+	explicit GuiApplication(const QString &fileToLoad, const QString &fileToImport,
+		bool fullscreen, bool exitAfterImport);
 	~GuiApplication();
 
 	static GuiApplication* instance();
@@ -57,12 +61,41 @@ class EXPORT GuiApplication : public QObject
 	ProjectNotes* getProjectNotes() { return m_projectNotes; }
 	AutomationEditorWindow* automationEditor() { return m_automationEditor; }
 	ControllerRackView* getControllerRackView() { return m_controllerRackView; }
+
+	// override of callback defined by OscMsgListener
+	void processMessage(const QByteArray &msg);
 
 public slots:
 	void displayInitProgress(const QString &msg);
 
 private slots:
 	void childDestroyed(QObject *obj);
+	// this slot should always be connected via Qt::QueuedConnection so that it operates in the gui thread
+	void processOscMsgInGuiThread(QByteArray msg);
+	// staged initialization (in order to avoid blocking the gui thread)
+	void initEngine();
+	void initMainWindow();
+	void initSongEditorWindow();
+	void initFxMixerView();
+	void initControllerRackView();
+	void initProjectNotes();
+	void initBbEditor();
+	void initPianoRoll();
+	void initAutomationEditor();
+	void handleCtorOptions();
+signals:
+	void postInitEngine();
+	void postInitMainWindow();
+	void postInitSongEditorWindow();
+	void postInitFxMixerView();
+	void postInitControllerRackView();
+	void postInitProjectNotes();
+	void postInitBbEditor();
+	void postInitPianoRoll();
+	void postInitAutomationEditor();
+	// sent whenever we receive an Open Sound Control message 
+	//   (presumably from the core or another section of the UI)
+	void receivedOscMessage(QByteArray msg);
 
 private:
 	static GuiApplication* s_instance;
@@ -76,6 +109,13 @@ private slots:
 	ProjectNotes* m_projectNotes;
 	ControllerRackView* m_controllerRackView;
 	QLabel* m_loadingProgressLabel;
+	QSplashScreen* m_splashScreen;
+
+	// initialization arguments:
+	QString m_fileToLoad;
+	QString m_fileToImport;
+	bool m_fullscreen;
+	bool m_exitAfterImport;
 };
 
 #define gui GuiApplication::instance()

include/MainWindow.h

@@ -131,6 +131,11 @@ public slots:
 	void undo();
 	void redo();
 
+private slots:
+	void exportProject();
+	void exportProjectTracks();
+	void exportProjectMidi();
+
 
 protected:
 	virtual void closeEvent( QCloseEvent * _ce );
@@ -150,6 +155,10 @@ public slots:
 	void toggleWindow( QWidget *window, bool forceShow = false );
 	void refocus();
 
+	// returns true if the project can be exported,
+	//   shows a warning message & returns false if the project is empty
+	bool checkProjectExportable();
+
 
 	QMdiArea * m_workspace;
 

include/Messenger.h

@@ -0,0 +1,93 @@
+/*
+ * Messenger: class to abstract the routing of Open Sound Control messages from the core
+ *   to another area of the core and/or the gui
+ *
+ * (c) 2015 Colin Wallace (https://github.com/Wallacoloo)
+ *
+ * This file is part of LMMS - http://lmms.io
+ *
+ * This file is released under the MIT License.
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MESSENGER_H
+#define MESSENGER_H
+
+#include <cstring>
+
+#include <QReadWriteLock>
+#include <QSet>
+
+class QString;
+
+class OscMsgListener;
+
+
+class Messenger
+{
+public:
+	// const strings to specify the Open Sound Control endpoint locations,
+	// e.g. "/mixer/ch/n/volume"
+	class Endpoints
+	{
+	public:
+		// Endpoints to send general and already-translated warnings / error messages
+		static const char *Warning;
+		static const char *Error;
+
+		static const char *WaveTableInit;
+		static const char *MixerDevInit;
+		static const char *MixerProcessingStart;
+	};
+
+	// Send message to indicate that the following components have completed their initialization
+	void broadcastWaveTableInit();
+	// Mixer has opened its audio devices
+	void broadcastMixerDevInit();
+	// Indicates that mixer has started its processing thread(s).
+	void broadcastMixerProcessing();
+
+	// whenever the core encounters a warning, it can broadcast it to listeners
+	//   rather than explicitly pop a Qt Dialog / log it, etc.
+	void broadcastWarning(const QString &brief, const QString &warning);
+
+	// broadcast an error message. The fact that it's an error does *not* imply
+	//   that the core/gui should exit.
+	// @brief is one-line summary of the error,
+	// @msg is the full message
+	void broadcastError(const QString &brief, const QString &msg);
+
+	// add a function to listen for OSC messages directed to a gui
+	// NOTE: This handler should have hard timing guarantees
+	//   preferrably, it will just enqueue the message and then process it later *in a separate thread*
+	void addGuiOscListener(OscMsgListener *listener);
+private:
+	// dispatch an OSC formatted message to ALL attached listeners
+	// if length is 0, an error will be logged and no action taken
+	// Therefore this can be safely used like so:
+	// char buffer[512];
+	// broadcast(buffer, rtosc_message(buffer, 512, "/test", "s", "Test broadcast"))
+	void broadcast(const char *buffer, std::size_t length);
+
+	// list of handlers that are called whenever we wish to broadcast a message to all GUIs
+	QSet<OscMsgListener*> m_guiListeners;
+	QReadWriteLock m_guiListenersLock;
+};
+
+#endif

include/OscMsgListener.h

@@ -0,0 +1,54 @@
+/*
+ * OscMsgListener: virtual base class to listen for Open Sound Control messages sent from core/gui
+ *   and handle them appropriately.
+ *   If you have a class that wants to listen in on OSC messages, just derive it from this,
+ *   implement the appropriate callbacks & register it with some OSC broadcaster (e.g. Messenger)
+ *
+ * (c) 2015 Colin Wallace (https://github.com/Wallacoloo)
+ *
+ * This file is part of LMMS - http://lmms.io
+ *
+ * This file is released under the MIT License.
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <QByteArray>
+#include <QMutex>
+#include <QQueue>
+#include <QWaitCondition>
+
+class OscMsgListener
+{
+	public:
+		virtual ~OscMsgListener();
+		// call to asyncronously push a message into the received queue
+		void queue(const char *msg, std::size_t length);
+		// Continually wait for new messages and process them as they arrive.
+		void listenerLoop();
+		// spawn a new thread and have it call listenerLoop()
+		void listenInNewThread();
+	protected:
+		// called whenever a message is received
+		virtual void processMessage(const QByteArray &msg) = 0;
+	private:
+		// queue of unprocessed received messages
+		QQueue<QByteArray> m_rxQueue;
+		QMutex m_rxMutex;
+		QWaitCondition m_rxConditionVar;
+};

include/Song.h

@@ -253,6 +253,10 @@ class EXPORT Song : public TrackContainer
 		return m_timeSigModel;
 	}
 
+	void exportProject( bool multiExport = false );
+	void exportProjectTracks();
+	void exportProjectMidi();
+
 
 public slots:
 	void playSong();
@@ -264,9 +268,6 @@ public slots:
 	void stop();
 
 	void importProject();
-	void exportProject( bool multiExport = false );
-	void exportProjectTracks();
-	void exportProjectMidi();
 
 	void startExport();
 	void stopExport();

lib/CMakeLists.txt

@@ -0,0 +1,4 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+
+# Build RTOSC from its CMakeFiles.txt
+ADD_SUBDIRECTORY(rtosc)

lib/rtosc/.travis.yml

@@ -0,0 +1,30 @@
+language: cpp
+
+compiler:
+    - gcc
+    - clang
+
+before_install:
+    - if [[ $NEW_GCC == true ]]; then sudo apt-get --purge remove gcc; fi;
+    - if [[ $NEW_GCC == true ]]; then sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test; fi;
+    - if [[ $NEW_GCC == true ]]; then sudo apt-get -qq update; fi;
+    - if [[ $NEW_GCC == true ]]; then sudo apt-get -qq install g++-4.8; fi;
+    - if [[ $NEW_GCC == true ]]; then sudo apt-get -qq install gcc-4.8; fi;
+    - if [[ $NEW_GCC == true ]]; then sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 90; fi;
+    - if [[ $NEW_GCC == true ]]; then sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 90; fi;
+    - sudo apt-get install liblo-dev
+
+script:
+    - mkdir build && cd build
+    - cmake ..
+    - make
+    - ctest --output-on-failure
+
+env:
+    - NEW_GCC=true
+    - NEW_GCC=false
+
+matrix:
+    exclude:
+        - compiler: clang
+          env:      NEW_GCC=true