6 files changed, 347 insertions, 87 deletions

diff --git a/libmultimc/include/instance.h b/libmultimc/include/instance.h
index c41e6718..258a0dab 100644
--- a/libmultimc/include/instance.h
+++ b/libmultimc/include/instance.h
@@ -65,6 +65,9 @@ class LIBMULTIMC_EXPORT Instance : public QObject
 	//! The instance's notes.
 	Q_PROPERTY(QString notes READ notes WRITE setNotes)
 	
+	//! The instance's group.
+	Q_PROPERTY(QString group READ group WRITE setGroup)
+	
 	/*!
 	 * Whether or not the instance's minecraft.jar needs to be rebuilt.
 	 * If this is true, when the instance launches, its jar mods will be 
@@ -173,14 +176,29 @@ public:
 	
 	//// General Info ////
 	virtual QString name() { return settings().get("name").toString(); }
-	virtual void setName(QString val) { settings().set("name", val); }
+	virtual void setName(QString val)
+	{
+		settings().set("name", val);
+		emit propertiesChanged(this);
+	}
 	
 	virtual QString iconKey() const { return settings().get("iconKey").toString(); }
-	virtual void setIconKey(QString val) { settings().set("iconKey", val); }
+	virtual void setIconKey(QString val)
+	{
+		settings().set("iconKey", val);
+		emit propertiesChanged(this);
+	}
 	
 	virtual QString notes() const { return settings().get("notes").toString(); }
 	virtual void setNotes(QString val) { settings().set("notes", val); }
 	
+	virtual QString group() const { return m_group; }
+	virtual void setGroup(QString val)
+	{
+		m_group = val;
+		emit propertiesChanged(this);
+	}
+	
 	virtual bool shouldRebuild() const { return settings().get("NeedsRebuild").toBool(); }
 	virtual void setShouldRebuild(bool val) { settings().set("NeedsRebuild", val); }
 	
@@ -202,7 +220,10 @@ public:
 	
 	virtual qint64 lastLaunch() { return settings().get("lastLaunchTime").value<qint64>(); }
 	virtual void setLastLaunch(qint64 val = QDateTime::currentMSecsSinceEpoch()) 
-	{ settings().set("lastLaunchTime", val); }
+	{
+		settings().set("lastLaunchTime", val);
+		emit propertiesChanged(this);
+	}
 	
 	
 	////// Directories //////
@@ -277,8 +298,15 @@ public:
 	 */
 	virtual SettingsObject &settings() const;
 	
+signals:
+	/*!
+	 * \brief Signal emitted when properties relevant to the instance view change
+	 */
+	void propertiesChanged(Instance * inst);
+	
 private:
 	QString m_rootDir;
+	QString m_group;
 	SettingsObject *m_settings;
 };
 
diff --git a/libmultimc/include/instancelist.h b/libmultimc/include/instancelist.h
index d4e7556a..a0d8788a 100644
--- a/libmultimc/include/instancelist.h
+++ b/libmultimc/include/instancelist.h
@@ -17,16 +17,14 @@
 #define INSTANCELIST_H
 
 #include <QObject>
-
 #include <QSharedPointer>
 
-#include "siglist.h"
-
+#include "instance.h"
 #include "libmmc_config.h"
 
 class Instance;
 
-class LIBMULTIMC_EXPORT InstanceList : public QObject, public SigList< QSharedPointer<Instance> >
+class LIBMULTIMC_EXPORT InstanceList : public QObject
 {
 	Q_OBJECT
 public:
@@ -46,14 +44,46 @@ public:
 	QString instDir() const { return m_instDir; }
 	
 	/*!
-	 * \brief Loads the instance list.
+	 * \brief Loads the instance list. Triggers notifications.
 	 */
 	InstListError loadList();
 	
-	DEFINE_SIGLIST_SIGNALS(QSharedPointer<Instance>);
-	SETUP_SIGLIST_SIGNALS(QSharedPointer<Instance>);
+	/*!
+	 * \brief Get the instance at index
+	 */
+	InstancePtr at(int i) const
+	{
+		return m_instances.at(i);
+	};
+	
+	/*!
+	 * \brief Get the count of loaded instances
+	 */
+	int count() const
+	{
+		return m_instances.count();
+	};
+	
+	/// Clear all instances. Triggers notifications.
+	void clear();
+	
+	/// Add an instance. Triggers notifications, returns the new index
+	int add(InstancePtr t);
+	
+	/// Get an instance by ID
+	InstancePtr getInstanceById (QString id);
+
+signals:
+	void instanceAdded(int index);
+	void instanceChanged(int index);
+	void invalidated();
+	
+private slots:
+	void propertiesChanged(Instance * inst);
+	
 protected:
 	QString m_instDir;
+	QList< InstancePtr > m_instances;
 };
 
 #endif // INSTANCELIST_H
diff --git a/libmultimc/include/minecraftprocess.h b/libmultimc/include/minecraftprocess.h
index 8986f7ad..ac4d6be2 100644
--- a/libmultimc/include/minecraftprocess.h
+++ b/libmultimc/include/minecraftprocess.h
@@ -6,7 +6,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *	 http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -24,73 +24,97 @@
 #include "libmmc_config.h"
 
 /**
+ * @brief the MessageLevel Enum
+ * defines what level a message is
+ */
+namespace MessageLevel {
+enum LIBMULTIMC_EXPORT Enum {
+	MultiMC,	/**< MultiMC Messages */
+	Debug,		/**< Debug Messages */
+	Info,		/**< Info Messages */
+	Message,	/**< Standard Messages */
+	Warning,	/**< Warnings */
+	Error,		/**< Errors */
+	Fatal		/**< Fatal Errors */
+};
+}
+
+/**
  * @file data/minecraftprocess.h
  * @brief The MinecraftProcess class
  */
 class LIBMULTIMC_EXPORT MinecraftProcess : public QProcess
 {
-    Q_OBJECT
+	Q_OBJECT
 public:
-    /**
-     * @brief MinecraftProcess constructor
-     * @param inst the Instance pointer to launch
-     * @param user the minecraft username
-     * @param session the minecraft session id
-     * @param console the instance console window
-     */
-    MinecraftProcess(InstancePtr inst, QString user, QString session);
-
-    /**
-     * @brief launch minecraft
-     */
-    void launch();
-
-    /**
-     * @brief extract the instance icon
-     * @param inst the instance
-     * @param destination the destination path
-     */
-    static inline void extractIcon(InstancePtr inst, QString destination);
-
-    /**
-     * @brief extract the MultiMC launcher.jar
-     * @param destination the destination path
-     */
-    static inline void extractLauncher(QString destination);
-
-    /**
-     * @brief prepare the launch by extracting icon and launcher
-     * @param inst the instance
-     */
-    static void prepare(InstancePtr inst);
-
-    /**
-     * @brief split a string into argv items like a shell would do
-     * @param args the argument string
-     * @return a QStringList containing all arguments
-     */
-    static QStringList splitArgs(QString args);
+	/**
+	 * @brief MinecraftProcess constructor
+	 * @param inst the Instance pointer to launch
+	 * @param user the minecraft username
+	 * @param session the minecraft session id
+	 * @param console the instance console window
+	 */
+	MinecraftProcess(InstancePtr inst, QString user, QString session);
+
+	/**
+	 * @brief launch minecraft
+	 */
+	void launch();
+
+	/**
+	 * @brief extract the instance icon
+	 * @param inst the instance
+	 * @param destination the destination path
+	 */
+	static inline void extractIcon(InstancePtr inst, QString destination);
+
+	/**
+	 * @brief extract the MultiMC launcher.jar
+	 * @param destination the destination path
+	 */
+	static inline void extractLauncher(QString destination);
+
+	/**
+	 * @brief prepare the launch by extracting icon and launcher
+	 * @param inst the instance
+	 */
+	static void prepare(InstancePtr inst);
+
+	/**
+	 * @brief split a string into argv items like a shell would do
+	 * @param args the argument string
+	 * @return a QStringList containing all arguments
+	 */
+	static QStringList splitArgs(QString args);
 
 signals:
-    /**
-     * @brief emitted when mc has finished and the PostLaunchCommand was run
-     */
-    void ended();
+	/**
+	 * @brief emitted when mc has finished and the PostLaunchCommand was run
+	 */
+	void ended();
+
+	/**
+	 * @brief emitted when we want to log something
+	 * @param text the text to log
+	 * @param level the level to log at
+	 */
+	void log(QString text, MessageLevel::Enum level=MessageLevel::MultiMC);
 
 protected:
-    InstancePtr m_instance;
-    QString m_user;
-    QString m_session;
-    QProcess m_prepostlaunchprocess;
-    QStringList m_arguments;
+	InstancePtr m_instance;
+	QString m_user;
+	QString m_session;
+	QString m_err_leftover;
+	QString m_out_leftover;
+	QProcess m_prepostlaunchprocess;
+	QStringList m_arguments;
 
-    void genArgs();
-    void log(QString text);
+	void genArgs();
 
 protected slots:
-    void finish(int, QProcess::ExitStatus status);
-    void on_stdErr();
-    void on_stdOut();
+	void finish(int, QProcess::ExitStatus status);
+	void on_stdErr();
+	void on_stdOut();
 
 };
 
diff --git a/libmultimc/src/instance.cpp b/libmultimc/src/instance.cpp
index 1af359d1..f9e105c7 100644
--- a/libmultimc/src/instance.cpp
+++ b/libmultimc/src/instance.cpp
@@ -48,6 +48,12 @@ Instance::Instance(const QString &rootDir, QObject *parent) :
 	settings().registerSetting(new OverrideSetting("PostExitCommand", 
 												   globalSettings->getSetting("PostExitCommand")));
 	
+	// Window Size
+	settings().registerSetting(new OverrideSetting("LaunchCompatMode", globalSettings->getSetting("LaunchCompatMode")));
+	settings().registerSetting(new OverrideSetting("LaunchMaximized", globalSettings->getSetting("LaunchMaximized")));
+	settings().registerSetting(new OverrideSetting("MinecraftWinWidth", globalSettings->getSetting("MinecraftWinWidth")));
+	settings().registerSetting(new OverrideSetting("MinecraftWinHeight", globalSettings->getSetting("MinecraftWinHeight")));
+	
 	// Memory
 	settings().registerSetting(new OverrideSetting("MinMemAlloc", globalSettings->getSetting("MinMemAlloc")));
 	settings().registerSetting(new OverrideSetting("MaxMemAlloc", globalSettings->getSetting("MaxMemAlloc")));
diff --git a/libmultimc/src/instancelist.cpp b/libmultimc/src/instancelist.cpp
index 78650634..f9c525d0 100644
--- a/libmultimc/src/instancelist.cpp
+++ b/libmultimc/src/instancelist.cpp
@@ -15,17 +15,21 @@
 
 #include "include/instancelist.h"
 
-#include "siglist_impl.h"
-
 #include <QDir>
 #include <QFile>
 #include <QDirIterator>
+#include <QThread>
+#include <QTextStream>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonArray>
 
 #include "include/instance.h"
 #include "include/instanceloader.h"
 
 #include "pathutils.h"
 
+const static int GROUP_FILE_FORMAT_VERSION = 1;
 
 InstanceList::InstanceList(const QString &instDir, QObject *parent) :
 	QObject(parent), m_instDir("instances")
@@ -38,6 +42,104 @@ InstanceList::InstListError InstanceList::loadList()
 	QDir dir(m_instDir);
 	QDirIterator iter(dir);
 	
+	QString groupFileName = m_instDir + "/instgroups.json";
+	// temporary map from instance ID to group name
+	QMap<QString, QString> groupMap;
+	
+	// HACK: this is really an if. breaks after one iteration.
+	while (QFileInfo(groupFileName).exists())
+	{
+		QFile groupFile(groupFileName);
+		
+		if (!groupFile.open(QIODevice::ReadOnly))
+		{
+			// An error occurred. Ignore it.
+			qDebug("Failed to read instance group file.");
+			break;
+		}
+		
+		QTextStream in(&groupFile);
+		QString jsonStr = in.readAll();
+		groupFile.close();
+		
+		QJsonParseError error;
+		QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonStr.toUtf8(), &error);
+		
+		if (error.error != QJsonParseError::NoError)
+		{
+			qWarning(QString("Failed to parse instance group file: %1 at offset %2").
+					 arg(error.errorString(), QString::number(error.offset)).toUtf8());
+			break;
+		}
+		
+		if (!jsonDoc.isObject())
+		{
+			qWarning("Invalid group file. Root entry should be an object.");
+			break;
+		}
+		
+		QJsonObject rootObj = jsonDoc.object();
+		
+		// Make sure the format version matches.
+		if (rootObj.value("formatVersion").toVariant().toInt() == GROUP_FILE_FORMAT_VERSION)
+		{
+			// Get the group list.
+			if (!rootObj.value("groups").isObject())
+			{
+				qWarning("Invalid group list JSON: 'groups' should be an object.");
+				break;
+			}
+			
+			// Iterate through the list.
+			QJsonObject groupList = rootObj.value("groups").toObject();
+			
+			for (QJsonObject::iterator iter = groupList.begin(); 
+				 iter != groupList.end(); iter++)
+			{
+				QString groupName = iter.key();
+				
+				// If not an object, complain and skip to the next one.
+				if (!iter.value().isObject())
+				{
+					qWarning(QString("Group '%1' in the group list should "
+									 "be an object.").arg(groupName).toUtf8());
+					continue;
+				}
+				
+				QJsonObject groupObj = iter.value().toObject();
+				/*
+				// Create the group object.
+				InstanceGroup *group = new InstanceGroup(groupName, this);
+				groups.push_back(group);
+				
+				// If 'hidden' isn't a bool value, just assume it's false.
+				if (groupObj.value("hidden").isBool() && groupObj.value("hidden").toBool())
+				{
+					group->setHidden(groupObj.value("hidden").toBool());
+				}
+				*/
+				
+				if (!groupObj.value("instances").isArray())
+				{
+					qWarning(QString("Group '%1' in the group list is invalid. "
+									 "It should contain an array "
+									 "called 'instances'.").arg(groupName).toUtf8());
+					continue;
+				}
+				
+				// Iterate through the list of instances in the group.
+				QJsonArray instancesArray = groupObj.value("instances").toArray();
+				
+				for (QJsonArray::iterator iter2 = instancesArray.begin(); 
+					 iter2 != instancesArray.end(); iter2++)
+				{
+					groupMap[(*iter2).toString()] = groupName;
+				}
+			}
+		}
+		break;
+	}
+	m_instances.clear();
 	while (iter.hasNext())
 	{
 		QString subDir = iter.next();
@@ -75,13 +177,61 @@ InstanceList::InstListError InstanceList::loadList()
 			else
 			{
 				QSharedPointer<Instance> inst(instPtr);
-				
+				auto iter = groupMap.find(inst->id());
+				if(iter != groupMap.end())
+				{
+					inst->setGroup((*iter));
+				}
 				qDebug(QString("Loaded instance %1").arg(inst->name()).toUtf8());
 				inst->setParent(this);
-				append(QSharedPointer<Instance>(inst));
+				m_instances.append(inst);
+				connect(instPtr, SIGNAL(propertiesChanged(Instance*)),this, SLOT(propertiesChanged(Instance*)));
 			}
 		}
 	}
-	
+	emit invalidated();
 	return NoError;
 }
+
+/// Clear all instances. Triggers notifications.
+void InstanceList::clear()
+{
+	m_instances.clear();
+	emit invalidated();
+};
+
+/// Add an instance. Triggers notifications, returns the new index
+int InstanceList::add(InstancePtr t)
+{
+	m_instances.append(t);
+	emit instanceAdded(count() - 1);
+	return count() - 1;
+}
+
+InstancePtr InstanceList::getInstanceById(QString instId)
+{
+	QListIterator<InstancePtr> iter(m_instances);
+	InstancePtr inst;
+	while(iter.hasNext())
+	{
+		inst = iter.next();
+		if (inst->id() == instId)
+			break;
+	}
+	if (inst->id() != instId)
+		return InstancePtr();
+	else
+		return iter.peekPrevious();
+}
+
+void InstanceList::propertiesChanged(Instance * inst)
+{
+	for(int i = 0; i < m_instances.count(); i++)
+	{
+		if(inst == m_instances[i].data())
+		{
+			emit instanceChanged(i);
+			break;
+		}
+	}
+}
\ No newline at end of file
diff --git a/libmultimc/src/minecraftprocess.cpp b/libmultimc/src/minecraftprocess.cpp
index 943d76b1..f1b63e3d 100644
--- a/libmultimc/src/minecraftprocess.cpp
+++ b/libmultimc/src/minecraftprocess.cpp
@@ -125,22 +125,41 @@ MinecraftProcess::MinecraftProcess(InstancePtr inst, QString user, QString sessi
 // console window
 void MinecraftProcess::on_stdErr()
 {
-//	if (m_console != nullptr)
-//		m_console->write(readAllStandardError(), ConsoleWindow::ERROR);
+	QByteArray data = readAllStandardError();
+	QString str = m_err_leftover + QString::fromLocal8Bit(data);
+	m_err_leftover.clear();
+	QStringList lines = str.split("\n");
+	bool complete = str.endsWith("\n");
+	
+	for(int i = 0; i < lines.size() - 1; i++)
+	{
+		QString & line = lines[i];
+		MessageLevel::Enum level = MessageLevel::Error;
+		if(line.contains("[INFO]") || line.contains("[CONFIG]") || line.contains("[FINE]") || line.contains("[FINER]") || line.contains("[FINEST]") )
+			level = MessageLevel::Message;
+		if(line.contains("[SEVERE]") || line.contains("[WARNING]") || line.contains("[STDERR]"))
+			level = MessageLevel::Error;
+		emit log(lines[i].toLocal8Bit(), level);
+	}
+	if(!complete)
+		m_err_leftover = lines.last();
 }
 
 void MinecraftProcess::on_stdOut()
 {
-//	if (m_console != nullptr)
-//		m_console->write(readAllStandardOutput(), ConsoleWindow::DEFAULT);
-}
-
-void MinecraftProcess::log(QString text)
-{
-//	if (m_console != nullptr)
-//		m_console->write(text);
-//	else
-		qDebug(qPrintable(text));
+	QByteArray data = readAllStandardOutput();
+	QString str = m_out_leftover + QString::fromLocal8Bit(data);
+	m_out_leftover.clear();
+	QStringList lines = str.split("\n");
+	bool complete = str.endsWith("\n");
+	
+	for(int i = 0; i < lines.size() - 1; i++)
+	{
+		QString & line = lines[i];
+		emit log(lines[i].toLocal8Bit(), MessageLevel::Message);
+	}
+	if(!complete)
+		m_out_leftover = lines.last();
 }
 
 // exit handler
@@ -151,7 +170,7 @@ void MinecraftProcess::finish(int code, ExitStatus status)
 		//TODO: error handling
 	}
 	
-	log("Minecraft exited.");
+	emit log("Minecraft exited.");
 	
 	m_prepostlaunchprocess.processEnvironment().insert("INST_EXITCODE", QString(code));
 	
@@ -191,12 +210,15 @@ void MinecraftProcess::launch()
 	
 	genArgs();
 	
-	log(QString("Minecraft folder is: '%1'").arg(workingDirectory()));
-	log(QString("Instance launched with arguments: '%1'").arg(m_arguments.join("' '")));
-	
-	start(m_instance->settings().get("JavaPath").toString(), m_arguments);
+	emit log(QString("Minecraft folder is: '%1'").arg(workingDirectory()));
+	QString JavaPath = m_instance->settings().get("JavaPath").toString();
+	emit log(QString("Java path: '%1'").arg(JavaPath));
+	emit log(QString("Arguments: '%1'").arg(m_arguments.join("' '")));
+	start(JavaPath, m_arguments);
 	if (!waitForStarted())
 	{
+		emit log("Could not launch minecraft!");
+		return;
 		//TODO: error handling
 	}