Merge branch 'master' of http://github.com/peterix/MultiMC5

Conflicts:
	CMakeLists.txt
	gui/mainwindow.cpp
	main.cpp

libutil/src/cmdutils.cpp

@@ -0,0 +1,434 @@
+/* Copyright 2013 MultiMC Contributors
+ *
+ * Authors: Orochimarufan <orochimarufan.x3@gmail.com>
+ *
+ * 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 "include/cmdutils.h"
+
+/**
+ * @file libutil/src/cmdutils.cpp
+ */
+
+namespace Util {
+namespace Commandline {
+
+Parser::Parser(FlagStyle flagStyle, ArgumentStyle argStyle)
+{
+    m_flagStyle = flagStyle;
+    m_argStyle = argStyle;
+}
+
+// styles setter/getter
+void Parser::setArgumentStyle(ArgumentStyle style)
+{
+    m_argStyle = style;
+}
+ArgumentStyle Parser::argumentStyle()
+{
+    return m_argStyle;
+}
+
+void Parser::setFlagStyle(FlagStyle style)
+{
+    m_flagStyle = style;
+}
+FlagStyle Parser::flagStyle()
+{
+    return m_flagStyle;
+}
+
+// setup methods
+void Parser::addSwitch(QString name, bool def)
+{
+    if (m_params.contains(name))
+        throw "Name not unique";
+
+    OptionDef *param = new OptionDef;
+    param->type = OptionType::Switch;
+    param->name = name;
+    param->metavar = QString("<%1>").arg(name);
+    param->def = def;
+
+    m_options[name] = param;
+    m_params[name] = (CommonDef *)param;
+    m_optionList.append(param);
+}
+
+void Parser::addOption(QString name, QVariant def)
+{
+    if (m_params.contains(name))
+        throw "Name not unique";
+
+    OptionDef *param = new OptionDef;
+    param->type = OptionType::Option;
+    param->name = name;
+    param->metavar = QString("<%1>").arg(name);
+    param->def = def;
+
+    m_options[name] = param;
+    m_params[name] = (CommonDef *)param;
+    m_optionList.append(param);
+}
+
+void Parser::addArgument(QString name, bool required, QVariant def)
+{
+    if (m_params.contains(name))
+        throw "Name not unique";
+
+    PositionalDef *param = new PositionalDef;
+    param->name = name;
+    param->def = def;
+    param->required = required;
+    param->metavar = name;
+
+    m_positionals.append(param);
+    m_params[name] = (CommonDef *)param;
+}
+
+void Parser::addDocumentation(QString name, QString doc, QString metavar)
+{
+    if (!m_params.contains(name))
+        throw "Name does not exist";
+
+    CommonDef *param = m_params[name];
+    param->doc = doc;
+    if (!metavar.isNull())
+        param->metavar = metavar;
+}
+
+void Parser::addShortOpt(QString name, QChar flag)
+{
+    if (!m_params.contains(name))
+        throw "Name does not exist";
+    if (!m_options.contains(name))
+        throw "Name is not an Option or Swtich";
+
+    OptionDef *param = m_options[name];
+    m_flags[flag] = param;
+    param->flag = flag;
+}
+
+// help methods
+QString Parser::compileHelp(QString progName, int helpIndent, bool useFlags)
+{
+    QStringList help;
+    help << compileUsage(progName, useFlags) << "\r\n";
+
+    // positionals
+    if (!m_positionals.isEmpty())
+    {
+        help << "\r\n";
+        help << "Positional arguments:\r\n";
+        QListIterator<PositionalDef *> it2(m_positionals);
+        while(it2.hasNext())
+        {
+            PositionalDef *param = it2.next();
+            help << "  " << param->metavar;
+            help << " " << QString(helpIndent - param->metavar.length() - 1, ' ');
+            help << param->doc << "\r\n";
+        }
+    }
+
+    // Options
+    if (!m_optionList.isEmpty())
+    {
+        help << "\r\n";
+        QString optPrefix, flagPrefix;
+        getPrefix(optPrefix, flagPrefix);
+
+        help << "Options & Switches:\r\n";
+        QListIterator<OptionDef *> it(m_optionList);
+        while(it.hasNext())
+        {
+            OptionDef *option = it.next();
+            help << "  ";
+            int nameLength = optPrefix.length() + option->name.length();
+            if (!option->flag.isNull())
+            {
+                nameLength += 3 + flagPrefix.length();
+                help << flagPrefix << option->flag << ", ";
+            }
+            help << optPrefix << option->name;
+            if (option->type == OptionType::Option)
+            {
+                QString arg = QString("%1%2").arg(((m_argStyle == ArgumentStyle::Equals) ? "=" : " "), option->metavar);
+                nameLength += arg.length();
+                help << arg;
+            }
+            help << " " << QString(helpIndent - nameLength - 1, ' ');
+            help << option->doc << "\r\n";
+        }
+    }
+
+    return help.join("");
+}
+
+QString Parser::compileUsage(QString progName, bool useFlags)
+{
+    QStringList usage;
+    usage << "Usage: " << progName;
+
+    QString optPrefix, flagPrefix;
+    getPrefix(optPrefix, flagPrefix);
+
+    // options
+    QListIterator<OptionDef *> it(m_optionList);
+    while(it.hasNext())
+    {
+        OptionDef *option = it.next();
+        usage << " [";
+        if (!option->flag.isNull() && useFlags)
+            usage << flagPrefix << option->flag;
+        else
+            usage << optPrefix << option->name;
+        if (option->type == OptionType::Option)
+            usage << ((m_argStyle == ArgumentStyle::Equals) ? "=" : " ") <<  option->metavar;
+        usage << "]";
+    }
+
+    // arguments
+    QListIterator<PositionalDef *> it2(m_positionals);
+    while(it2.hasNext())
+    {
+        PositionalDef *param = it2.next();
+        usage << " " << (param->required ? "<" : "[");
+        usage << param->metavar;
+        usage << (param->required ? ">" : "]");
+    }
+
+    return usage.join("");
+}
+
+// parsing
+QHash<QString, QVariant> Parser::parse(QStringList argv)
+{
+    QHash<QString, QVariant> map;
+
+    QStringListIterator it(argv);
+    QString programName = it.next();
+
+    QString optionPrefix;
+    QString flagPrefix;
+    QListIterator<PositionalDef *> positionals(m_positionals);
+    QStringList expecting;
+
+    getPrefix(optionPrefix, flagPrefix);
+
+    while (it.hasNext())
+    {
+        QString arg = it.next();
+
+        if (!expecting.isEmpty())
+            // we were expecting an argument
+        {
+            QString name = expecting.first();
+
+            if (map.contains(name))
+                throw ParsingError(QString("Option %2%1 was given multiple times").arg(name, optionPrefix));
+
+            map[name] = QVariant(arg);
+
+            expecting.removeFirst();
+            continue;
+        }
+
+        if (arg.startsWith(optionPrefix))
+            // we have an option
+        {
+            //qDebug("Found option %s", qPrintable(arg));
+
+            QString name = arg.mid(optionPrefix.length());
+            QString equals;
+
+            if ((m_argStyle == ArgumentStyle::Equals || m_argStyle == ArgumentStyle::SpaceAndEquals) && name.contains("="))
+            {
+                int i = name.indexOf("=");
+                equals = name.mid(i+1);
+                name = name.left(i);
+            }
+
+            if (m_options.contains(name))
+            {
+                if (map.contains(name))
+                    throw ParsingError(QString("Option %2%1 was given multiple times").arg(name, optionPrefix));
+
+                OptionDef *option = m_options[name];
+                if (option->type == OptionType::Switch)
+                    map[name] = true;
+                else //if (option->type == OptionType::Option)
+                {
+                    if (m_argStyle == ArgumentStyle::Space)
+                        expecting.append(name);
+                    else if (!equals.isNull())
+                        map[name] = equals;
+                    else if (m_argStyle == ArgumentStyle::SpaceAndEquals)
+                        expecting.append(name);
+                    else
+                        throw ParsingError(QString("Option %2%1 reqires an argument.").arg(name, optionPrefix));
+                }
+
+                continue;
+            }
+
+            throw ParsingError(QString("Unknown Option %2%1").arg(name, optionPrefix));
+        }
+
+        if (arg.startsWith(flagPrefix))
+            // we have (a) flag(s)
+        {
+            //qDebug("Found flags %s", qPrintable(arg));
+
+            QString flags = arg.mid(flagPrefix.length());
+            QString equals;
+
+            if ((m_argStyle == ArgumentStyle::Equals || m_argStyle == ArgumentStyle::SpaceAndEquals) && flags.contains("="))
+            {
+                int i = flags.indexOf("=");
+                equals = flags.mid(i+1);
+                flags = flags.left(i);
+            }
+
+            for (int i = 0; i < flags.length(); i++)
+            {
+                QChar flag = flags.at(i);
+
+                if (!m_flags.contains(flag))
+                    throw ParsingError(QString("Unknown flag %2%1").arg(flag, flagPrefix));
+
+                OptionDef *option = m_flags[flag];
+
+                if (map.contains(option->name))
+                    throw ParsingError(QString("Option %2%1 was given multiple times").arg(option->name, optionPrefix));
+
+                if (option->type == OptionType::Switch)
+                    map[option->name] = true;
+                else //if (option->type == OptionType::Option)
+                {
+                    if (m_argStyle == ArgumentStyle::Space)
+                        expecting.append(option->name);
+                    else if (!equals.isNull())
+                        if (i == flags.length()-1)
+                            map[option->name] = equals;
+                        else
+                            throw ParsingError(QString("Flag %4%2 of Argument-requiring Option %1 not last flag in %4%3").arg(option->name, flag, flags, flagPrefix));
+                    else if (m_argStyle == ArgumentStyle::SpaceAndEquals)
+                        expecting.append(option->name);
+                    else
+                        throw ParsingError(QString("Option %1 reqires an argument. (flag %3%2)").arg(option->name, flag, flagPrefix));
+                }
+            }
+
+            continue;
+        }
+
+        // must be a positional argument
+        if (!positionals.hasNext())
+            throw ParsingError(QString("Don't know what to do with '%1'").arg(arg));
+
+        PositionalDef *param = positionals.next();
+
+        map[param->name] = arg;
+    }
+
+    // check if we're missing something
+    if (!expecting.isEmpty())
+        throw ParsingError(QString("Was still expecting arguments for %2%1").arg(expecting.join(QString(", ")+optionPrefix), optionPrefix));
+
+    while (positionals.hasNext())
+    {
+        PositionalDef *param = positionals.next();
+        if (param->required)
+            throw ParsingError(QString("Missing required positional argument '%1'").arg(param->name));
+        else
+            map[param->name] = param->def;
+    }
+
+    // fill out gaps
+    QListIterator<OptionDef *> iter(m_optionList);
+    while (iter.hasNext())
+    {
+        OptionDef *option = iter.next();
+        if (!map.contains(option->name))
+            map[option->name] = option->def;
+    }
+
+    return map;
+}
+
+//clear defs
+void Parser::clear()
+{
+    m_flags.clear();
+    m_params.clear();
+    m_options.clear();
+
+    QMutableListIterator<OptionDef *> it(m_optionList);
+    while(it.hasNext())
+    {
+        OptionDef *option = it.next();
+        it.remove();
+        delete option;
+    }
+
+    QMutableListIterator<PositionalDef *> it2(m_positionals);
+    while(it2.hasNext())
+    {
+        PositionalDef *arg = it2.next();
+        it2.remove();
+        delete arg;
+    }
+}
+
+//Destructor
+Parser::~Parser()
+{
+    clear();
+}
+
+//getPrefix
+void Parser::getPrefix(QString &opt, QString &flag)
+{
+    if (m_flagStyle == FlagStyle::Windows)
+        opt = flag = "/";
+    else if (m_flagStyle == FlagStyle::Unix)
+        opt = flag = "-";
+    //else if (m_flagStyle == FlagStyle::GNU)
+    else {
+        opt = "--";
+        flag = "-";
+    }
+}
+
+// ParsingError
+ParsingError::ParsingError(const QString &what)
+{
+    m_what = what;
+}
+ParsingError::ParsingError(const ParsingError &e)
+{
+    m_what = e.m_what;
+}
+
+const char *ParsingError::what() const throw()
+{
+    return m_what.toLocal8Bit().constData();
+}
+QString ParsingError::qwhat() const
+{
+    return m_what;
+}
+
+}
+}

libutil/src/inifile.cpp

@@ -0,0 +1,86 @@
+/* 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 "include/inifile.h"
+
+#include <QFile>
+#include <QTextStream>
+#include <QStringList>
+
+INIFile::INIFile()
+{
+	
+}
+
+bool INIFile::saveFile(QString fileName)
+{
+	// TODO Handle errors.
+	QFile file(fileName);
+	file.open(QIODevice::WriteOnly);
+	QTextStream out(&file);
+	
+	for (Iterator iter = begin(); iter != end(); iter++)
+	{
+		out << iter.key() << "=" << iter.value().toString() << "\n";
+	}
+	
+	return true;
+}
+
+bool INIFile::loadFile(QString fileName)
+{
+	// TODO Handle errors.
+	QFile file(fileName);
+	file.open(QIODevice::ReadOnly);
+	QTextStream	in(&file);
+	
+	QStringList lines = in.readAll().split('\n');
+	for (int i = 0; i < lines.count(); i++)
+	{
+		QString & lineRaw = lines[i];
+		// Ignore comments.
+		QString line = lineRaw.left(lineRaw.indexOf('#')).trimmed();
+		
+		int eqPos = line.indexOf('=');
+		if(eqPos == -1)
+			continue;
+		QString key = line.left(eqPos).trimmed();
+		QString valueStr = line.right(line.length() - eqPos - 1).trimmed();
+		
+		QVariant value(valueStr);
+		/*
+		QString dbg = key;
+		dbg += " = ";
+		dbg += valueStr;
+		qDebug(dbg.toLocal8Bit());
+		*/
+		this->operator [](key) = value;
+	}
+	
+	return true;
+}
+
+QVariant INIFile::get(QString key, QVariant def) const
+{
+	if (!this->contains(key))
+		return def;
+	else
+		return this->operator [](key);
+}
+
+void INIFile::set(QString key, QVariant val)
+{
+	this->operator [](key) = val;
+}

libutil/src/osutils.cpp

@@ -0,0 +1,19 @@
+/* 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 "include/osutils.h"
+
+#include <QUrl>
+#include <QFileInfo>

libutil/src/pathutils.cpp

@@ -0,0 +1,37 @@
+/* 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 "include/pathutils.h"
+
+#include <QFileInfo>
+#include <QDir>
+
+QString PathCombine(QString path1, QString path2)
+{
+	if (!path1.endsWith('/'))
+		return path1.append('/').append(path2);
+	else
+		return path1.append(path2);
+}
+
+QString PathCombine(QString path1, QString path2, QString path3)
+{
+	return PathCombine(PathCombine(path1, path2), path3);
+}
+
+QString AbsolutePath(QString path)
+{
+	return QFileInfo(path).absolutePath();
+}

libutil/src/userutils.cpp

@@ -0,0 +1,113 @@
+#include "include/userutils.h"
+
+#include <QStandardPaths>
+#include <QFile>
+#include <QTextStream>
+
+#include "include/osutils.h"
+#include "include/pathutils.h"
+
+// Win32 crap
+#if WINDOWS
+
+#include <windows.h>
+#include <winnls.h>
+#include <shobjidl.h>
+#include <objbase.h>
+#include <objidl.h>
+#include <shlguid.h>
+#include <shlobj.h>
+
+bool called_coinit = false;
+
+HRESULT CreateLink(LPCSTR linkPath, LPCWSTR targetPath, LPCWSTR args)
+{
+    HRESULT hres;
+
+    if (!called_coinit)
+    {
+        hres = CoInitialize(NULL);
+        called_coinit = true;
+
+        if (!SUCCEEDED(hres))
+        {
+            qWarning("Failed to initialize COM. Error 0x%08X", hres);
+            return hres;
+        }
+    }
+
+
+    IShellLink* link;
+    hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (LPVOID*)&link);
+
+    if (SUCCEEDED(hres))
+    {
+        IPersistFile* persistFile;
+
+        link->SetPath(targetPath);
+        link->SetArguments(args);
+
+        hres = link->QueryInterface(IID_IPersistFile, (LPVOID*)&persistFile);
+        if (SUCCEEDED(hres))
+        {
+            WCHAR wstr[MAX_PATH];
+
+            MultiByteToWideChar(CP_ACP, 0, linkPath, -1, wstr, MAX_PATH);
+
+            hres = persistFile->Save(wstr, TRUE);
+            persistFile->Release();
+        }
+        link->Release();
+    }
+    return hres;
+}
+
+#endif
+
+QString Util::getDesktopDir()
+{
+    return QStandardPaths::writableLocation(QStandardPaths::DesktopLocation);
+}
+
+// Cross-platform Shortcut creation
+bool Util::createShortCut(QString location, QString dest, QStringList args, QString name, QString icon)
+{
+#if LINUX
+    location = PathCombine(location, name + ".desktop");
+    qDebug("location: %s", qPrintable(location));
+
+    QFile f(location);
+    f.open(QIODevice::WriteOnly | QIODevice::Text);
+    QTextStream stream(&f);
+
+    QString argstring;
+    if (!args.empty())
+        argstring = " '" + args.join("' '") + "'";
+
+    stream << "[Desktop Entry]" << "\n";
+    stream << "Type=Application" << "\n";
+    stream << "TryExec=" << dest.toLocal8Bit() << "\n";
+    stream << "Exec=" << dest.toLocal8Bit() << argstring.toLocal8Bit() << "\n";
+    stream << "Name=" << name.toLocal8Bit() << "\n";
+    stream << "Icon=" << icon.toLocal8Bit() << "\n";
+
+    stream.flush();
+    f.close();
+
+    f.setPermissions(f.permissions() | QFileDevice::ExeOwner | QFileDevice::ExeGroup | QFileDevice::ExeOther);
+
+    return true;
+#elif WINDOWS
+    QFile file(path, name + ".lnk");
+    WCHAR *file_w;
+    WCHAR *dest_w;
+    WCHAR *args_w;
+    file.fileName().toWCharArray(file_w);
+    dest.toWCharArray(dest_w);
+    args.toWCharArray(args_w);
+    return SUCCEEDED(CreateLink(file_w, dest_w, args_w));
+#else
+    qWarning("Desktop Shortcuts not supported on your platform!");
+    return false;
+#endif
+}