Added stdinstance plugin and a ton of plugin stuff.

CMakeLists.txt

@@ -16,8 +16,8 @@ ENDIF(${BIGENDIAN})
 include_directories(hacks)
 
 #### Find the required Qt parts ####
-find_package(Qt5Widgets)
+find_package(Qt5Widgets REQUIRED)
-find_package(Qt5Network)
+find_package(Qt5Network REQUIRED)
 #find_package(Qt5Declarative)
 
 include_directories(${Qt5Widgets_INCLUDE_DIRS})
@@ -35,6 +35,10 @@ include_directories(patchlib)
 # add the java launcher
 add_subdirectory(launcher)
 
+# Add the stdinstance plugin.
+add_subdirectory(plugins/stdinstance)
+
+
 IF(APPLE)
   # assume clang 4.1.0+, add C++0x/C++11 stuff
   message(STATUS "Using APPLE CMAKE_CXX_FLAGS")
@@ -108,6 +112,8 @@ data/inst/instancetype.cpp
 data/inst/instance.cpp
 data/inst/instancelist.cpp
 
+data/plugin/pluginmanager.cpp
+
 data/version/instversion.cpp
 data/version/instversionlist.cpp
 
@@ -149,6 +155,9 @@ data/inst/instancetype.h
 data/inst/instance.h
 data/inst/instancelist.h
 
+data/plugin/pluginmanager.h
+data/plugin/instancetypeplugin.h
+
 data/version/instversion.h
 data/version/instversionlist.h
 
@@ -205,7 +214,7 @@ QT5_ADD_RESOURCES(MULTIMC_QRC multimc.qrc)
 
 add_executable(MultiMC MACOSX_BUNDLE WIN32 ${MULTIMC_SOURCES} ${MULTIMC_HEADERS} ${MULTIMC_UI} ${MULTIMC_QRC})
 qt5_use_modules(MultiMC Widgets Network)
-target_link_libraries(MultiMC quazip patchlib ${MultiMC_LINK_ADDITIONAL_LIBS})
+target_link_libraries(MultiMC quazip patchlib stdinstance ${MultiMC_LINK_ADDITIONAL_LIBS})
 add_dependencies(MultiMC MultiMCLauncher)
 
 

data/inst/instance.cpp

@@ -44,6 +44,61 @@ InstanceList *Instance::instList()
 		return NULL;
 }
 
+QString Instance::minecraftDir() const
+{
+	QFileInfo mcDir(PathCombine(rootDir(), "minecraft"));
+	QFileInfo dotMCDir(PathCombine(rootDir(), ".minecraft"));
+	
+	if (dotMCDir.exists() && !mcDir.exists())
+	{
+		return dotMCDir.path();
+	}
+	else
+	{
+		return mcDir.path();
+	}
+}
+
+QString Instance::binDir() const
+{
+	return PathCombine(minecraftDir(), "bin");
+}
+
+QString Instance::savesDir() const
+{
+	return PathCombine(minecraftDir(), "saves");
+}
+
+QString Instance::mlModsDir() const
+{
+	return PathCombine(minecraftDir(), "mods");
+}
+
+QString Instance::coreModsDir() const
+{
+	return PathCombine(minecraftDir(), "coremods");
+}
+
+QString Instance::resourceDir() const
+{
+	return PathCombine(minecraftDir(), "resources");
+}
+
+QString Instance::screenshotsDir() const
+{
+	return PathCombine(minecraftDir(), "screenshots");
+}
+
+QString Instance::texturePacksDir() const
+{
+	return PathCombine(minecraftDir(), "texturepacks");
+}
+
+QString Instance::mcJar() const
+{
+	return PathCombine(binDir(), "minecraft.jar");
+}
+
 QVariant Instance::getField(const QString &name, QVariant defVal) const
 {
 	return config.get(name, defVal);

data/inst/instance.h

@@ -214,6 +214,51 @@ public:
 	{ setField("lastLaunchTime", val); }
 	
 	
+	////// Directories //////
+	//! Gets the path to the instance's minecraft folder.
+	QString minecraftDir() const;
+	
+	/*!
+	 * \brief Gets the path to the instance's instance mods folder.
+	 * This is the folder where the jar mods are kept.
+	 */
+	QString instModsDir() const;
+	
+	//! Gets the path to the instance's bin folder.
+	QString binDir() const;
+	
+	//! Gets the path to the instance's saves folder.
+	QString savesDir() const;
+	
+	//! Gets the path to the instance's mods folder. (.minecraft/mods)
+	QString mlModsDir() const;
+	
+	//! Gets the path to the instance's coremods folder.
+	QString coreModsDir() const;
+	
+	//! Gets the path to the instance's resources folder.
+	QString resourceDir() const;
+	
+	//! Gets the path to the instance's screenshots folder.
+	QString screenshotsDir() const;
+	
+	//! Gets the path to the instance's texture packs folder.
+	QString texturePacksDir() const;
+	
+	
+	////// Files //////
+	//! Gets the path to the instance's minecraft.jar
+	QString mcJar() const;
+	
+	//! Gets the path to the instance's mcbackup.jar.
+	QString mcBackup() const;
+	
+	//! Gets the path to the instance's config file.
+	QString configFile() const;
+	
+	//! Gets the path to the instance's modlist file.
+	QString modListFile() const;
+	
 	////// Settings //////
 	
 	//// Java Settings ////

data/inst/instancetype.h

@@ -37,9 +37,7 @@ public:
 	friend class InstanceLoader;
 	
 	/*!
-	 * \brief Gets the ID for this instance type.
+	 * \brief Gets the ID for this instance type. 
-	 *        By default this is the name of the Instance class that this type 
-	 *        creates, but this can be changed by overriding this function. 
 	 *        The type ID should be unique as it is used to identify the type 
 	 *        of instances when they are loaded.
 	 *        Changing this value at runtime results in undefined behavior.

data/plugin/instancetypeplugin.h

@@ -0,0 +1,41 @@
+/* Copyright 2013 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * 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
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INSTANCETYPEPLUGIN_H
+#define INSTANCETYPEPLUGIN_H
+
+#include <QList>
+
+#include "data/inst/instancetype.h"
+
+/*!
+ * \brief Interface for plugins that want to provide custom instance types.
+ */
+class InstanceTypePlugin
+{
+public:
+	/*!
+	 * \brief Gets a QList containing the instance types that this plugin provides.
+	 * These instance types are then registered with the InstanceLoader.
+	 * The InstanceType objects should \e not be deleted by the plugin. Once they 
+	 * are registered, they belong to the InstanceLoader.
+	 * \return A QList containing this plugin's instance types.
+	 */
+	virtual QList<InstanceType *> getInstanceTypes() = 0;
+};
+
+Q_DECLARE_INTERFACE(InstanceTypePlugin, "net.forkk.MultiMC.InstanceTypePlugin/0.1")
+
+#endif // INSTANCETYPEPLUGIN_H

data/plugin/pluginmanager.cpp

@@ -0,0 +1,96 @@
+/* Copyright 2013 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * 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
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "pluginmanager.h"
+
+#include <QDir>
+#include <QDirIterator>
+#include <QFileInfo>
+
+#include <QtPlugin>
+
+#include "data/plugin/instancetypeplugin.h"
+
+PluginManager PluginManager::manager;
+
+PluginManager::PluginManager() :
+	QObject(NULL)
+{
+	
+}
+
+bool PluginManager::loadPlugins(QString pluginDir)
+{
+	m_plugins.clear();
+	
+	QDir dir(pluginDir);
+	QDirIterator iter(dir);
+	
+	while (iter.hasNext())
+	{
+		QFileInfo pluginFile(dir.absoluteFilePath(iter.next()));
+		
+		if (pluginFile.exists() && pluginFile.isFile())
+		{
+			QPluginLoader pluginLoader(pluginFile.absoluteFilePath());
+			pluginLoader.load();
+			QObject *plugin = pluginLoader.instance();
+			if (plugin)
+			{
+				qDebug(QString("Loaded plugin %1.").
+					   arg(pluginFile.baseName()).toUtf8());
+				m_plugins.push_back(plugin);
+			}
+			else
+			{
+				qWarning(QString("Error loading plugin %1. Not a valid plugin.").
+						 arg(pluginFile.baseName()).toUtf8());
+			}
+		}
+	}
+	
+	return true;
+}
+
+bool PluginManager::initInstanceTypes()
+{
+	for (int i = 0; i < m_plugins.count(); i++)
+	{
+		InstanceTypePlugin *plugin = qobject_cast<InstanceTypePlugin *>(m_plugins[i]);
+		if (plugin)
+		{
+			QList<InstanceType *> instanceTypes = plugin->getInstanceTypes();
+			
+			for (int i = 0; i < instanceTypes.count(); i++)
+			{
+				InstanceLoader::InstTypeError error = 
+						InstanceLoader::loader.registerInstanceType(instanceTypes[i]);
+				switch (error)
+				{
+				case InstanceLoader::TypeIDExists:
+					qWarning(QString("Instance type %1 already registered.").
+							 arg(instanceTypes[i]->typeID()).toUtf8());
+				}
+			}
+		}
+	}
+	
+	return true;
+}
+
+QObject *PluginManager::getPlugin(int index)
+{
+	return m_plugins[index];
+}

data/plugin/pluginmanager.h

@@ -0,0 +1,71 @@
+/* Copyright 2013 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * 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
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef PLUGINMANAGER_H
+#define PLUGINMANAGER_H
+
+#include <QObject>
+#include <QList>
+#include <QPluginLoader>
+
+/*!
+ * \brief This class is a singleton that manages loading plugins.
+ */
+class PluginManager : public QObject
+{
+	Q_OBJECT
+public:
+	/*!
+	 * \brief Gets the plugin manager instance.
+	 */
+	static PluginManager &get() { return manager; }
+	
+	/*!
+	 * \brief Loads plugins from the given directory.
+	 * This function does \e not initialize the plugins. It simply loads their
+	 * classes. Use the init functions to initialize the various plugin types.
+	 * \param The directory to load plugins from.
+	 * \return True if successful. False on failure.
+	 */
+	bool loadPlugins(QString pluginDir);
+	
+	/*!
+	 * \brief Initializes the instance type plugins.
+	 * \return True if successful. False on failure.
+	 */
+	bool initInstanceTypes();
+	
+	/*!
+	 * \brief Checks how many plugins are loaded.
+	 * \return The number of plugins.
+	 */
+	int count() { return m_plugins.count(); }
+	
+	/*!
+	 * \brief Gets the plugin at the given index.
+	 * \param index The index of the plugin to get.
+	 * \return The plugin at the given index.
+	 */
+	QObject *getPlugin(int index);
+	
+private:
+	PluginManager();
+	
+	QList<QObject *> m_plugins;
+	
+	static PluginManager manager;
+};
+
+#endif // PLUGINMANAGER_H

libinstance/CMakeLists.txt

@@ -0,0 +1,31 @@
+project(stdinstance)
+
+ADD_DEFINITIONS(-DQT_PLUGIN)
+
+# Find Qt
+find_package(Qt5Core REQUIRED)
+find_package(Qt5Network REQUIRED)
+
+# Include Qt headers.
+include_directories(${Qt5Base_INCLUDE_DIRS})
+include_directories(${Qt5Network_INCLUDE_DIRS})
+
+# Include MultiMC's headers.
+include_directories(../../)
+
+SET(STDINST_HEADERS
+stdinstplugin.h
+stdinstancetype.h
+stdinstance.h
+)
+
+SET(STDINST_SOURCES
+stdinstplugin.cpp
+stdinstancetype.cpp
+stdinstance.cpp
+)
+
+add_library(stdinstance SHARED ${STDINST_SOURCES} ${STDINST_HEADERS})
+set_target_properties(stdinstance PROPERTIES PREFIX "")
+qt5_use_modules(stdinstance Core Network)
+target_link_libraries(stdinstance quazip patchlib)

main.cpp

@@ -18,9 +18,12 @@
 #include <QApplication>
 
 #include "data/appsettings.h"
-
 #include "data/loginresponse.h"
 
+#include "data/plugin/pluginmanager.h"
+
+#include "util/pathutils.h"
+
 int main(int argc, char *argv[])
 {
 	QApplication app(argc, argv);
@@ -32,6 +35,11 @@ int main(int argc, char *argv[])
 	// Register meta types.
 	qRegisterMetaType<LoginResponse>("LoginResponse");
 	
+	
+	// Initialize plugins.
+	PluginManager::get().loadPlugins(PathCombine(qApp->applicationDirPath(), "plugins"));
+	PluginManager::get().initInstanceTypes();
+	
 	MainWindow mainWin;
 	mainWin.show();
 	

plugins/stdinstance/CMakeLists.txt

@@ -0,0 +1,31 @@
+project(stdinstance)
+
+ADD_DEFINITIONS(-DQT_PLUGIN)
+
+# Find Qt
+find_package(Qt5Core REQUIRED)
+find_package(Qt5Network REQUIRED)
+
+# Include Qt headers.
+include_directories(${Qt5Base_INCLUDE_DIRS})
+include_directories(${Qt5Network_INCLUDE_DIRS})
+
+# Include MultiMC's headers.
+include_directories(../../)
+
+SET(STDINST_HEADERS
+stdinstplugin.h
+stdinstancetype.h
+stdinstance.h
+)
+
+SET(STDINST_SOURCES
+stdinstplugin.cpp
+stdinstancetype.cpp
+stdinstance.cpp
+)
+
+add_library(stdinstance SHARED ${STDINST_SOURCES} ${STDINST_HEADERS})
+set_target_properties(stdinstance PROPERTIES PREFIX "")
+qt5_use_modules(stdinstance Core Network)
+target_link_libraries(stdinstance quazip patchlib)

plugins/stdinstance/stdinstance.cpp

@@ -0,0 +1,53 @@
+/* Copyright 2013 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * 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
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "stdinstance.h"
+
+#include <QFileInfo>
+
+#include <java/javautils.h>
+
+StdInstance::StdInstance(const QString &rootDir, QObject *parent) :
+	Instance(rootDir, parent)
+{
+	
+}
+
+bool StdInstance::shouldUpdateCurrentVersion()
+{
+	QFileInfo jar(mcJar());
+	return jar.lastModified().toUTC().toMSecsSinceEpoch() != lastVersionUpdate();
+}
+
+void StdInstance::updateCurrentVersion(bool keepCurrent)
+{
+	QFileInfo jar(mcJar());
+	
+	if(!jar.exists())
+	{
+		setLastVersionUpdate(0);
+		setCurrentVersion("Unknown");
+		return;
+	}
+	
+	qint64 time = jar.lastModified().toUTC().toMSecsSinceEpoch();
+	
+	setLastVersionUpdate(time);
+	if (!keepCurrent)
+	{
+		QString newVersion = javautils::GetMinecraftJarVersion(jar.absoluteFilePath());
+		setCurrentVersion(newVersion);
+	}
+}

plugins/stdinstance/stdinstance.h

@@ -0,0 +1,36 @@
+/* Copyright 2013 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * 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
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef STDINSTANCE_H
+#define STDINSTANCE_H
+
+#include <data/inst/instance.h>
+
+class StdInstance : public Instance
+{
+	Q_OBJECT
+public:
+	explicit StdInstance(const QString &rootDir, QObject *parent = 0);
+	
+	virtual bool shouldUpdateCurrentVersion();
+	
+	virtual void updateCurrentVersion(bool keepCurrent);
+	
+	////// TIMESTAMPS //////
+	virtual qint64 lastVersionUpdate() { return getField("lastVersionUpdate", 0).value<qint64>(); }
+	virtual void setLastVersionUpdate(qint64 val) { setField("lastVersionUpdate", val); }
+};
+
+#endif // STDINSTANCE_H

plugins/stdinstance/stdinstance.json

@@ -0,0 +1 @@
+{}

plugins/stdinstance/stdinstancetype.cpp

@@ -0,0 +1,34 @@
+/* Copyright 2013 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * 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
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "stdinstancetype.h"
+
+StdInstanceType::StdInstanceType(QObject *parent) :
+	InstanceType(parent)
+{
+	
+}
+
+InstanceLoader::InstTypeError StdInstanceType::createInstance(Instance *inst, 
+															  const QString &instDir) const
+{
+	return InstanceLoader::NoError;
+}
+
+InstanceLoader::InstTypeError StdInstanceType::loadInstance(Instance *inst, 
+															const QString &instDir) const
+{
+	return InstanceLoader::NoError;
+}

plugins/stdinstance/stdinstancetype.h

@@ -0,0 +1,38 @@
+/* Copyright 2013 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * 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
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef STDINSTANCETYPE_H
+#define STDINSTANCETYPE_H
+
+#include <data/inst/instancetype.h>
+
+class StdInstanceType : public InstanceType
+{
+	Q_OBJECT
+public:
+	explicit StdInstanceType(QObject *parent = 0);
+	
+	virtual QString typeID() const { return "net.forkk.MultiMC.StdInstance"; }
+	
+	virtual QString displayName() const { return "Standard Instance"; }
+	
+	virtual QString description() const { return "A standard Minecraft instance."; }
+	
+	virtual InstanceLoader::InstTypeError createInstance(Instance *inst, const QString &instDir) const;
+	
+	virtual InstanceLoader::InstTypeError loadInstance(Instance *inst, const QString &instDir) const;
+};
+
+#endif // STDINSTANCETYPE_H

plugins/stdinstance/stdinstplugin.cpp

@@ -0,0 +1,27 @@
+/* Copyright 2013 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * 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
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "stdinstplugin.h"
+
+#include <QtPlugin>
+
+#include "stdinstancetype.h"
+
+QList<InstanceType *> StdInstPlugin::getInstanceTypes()
+{
+	QList<InstanceType *> types;
+	types.push_back(new StdInstanceType(this));
+	return types;
+}

plugins/stdinstance/stdinstplugin.h

@@ -0,0 +1,33 @@
+/* Copyright 2013 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * 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
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef STDINSTPLUGIN_H
+#define STDINSTPLUGIN_H
+
+#include <QObject>
+
+#include <data/plugin/instancetypeplugin.h>
+
+class StdInstPlugin : public QObject, InstanceTypePlugin
+{
+	Q_OBJECT
+	Q_INTERFACES(InstanceTypePlugin)
+	Q_PLUGIN_METADATA(IID "net.forkk.MultiMC.Plugins.StdInstance")
+	
+public:
+	virtual QList<InstanceType *> getInstanceTypes();
+};
+
+#endif // STDINSTPLUGIN_H