0xf8/pollymc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixed a lot of MSVC problems

Browse Source
This commit is contained in:
Andrew 2013-02-25 14:44:36 -06:00
parent b56b819c35
commit 4ca35a760d
14 changed files with 651 additions and 599 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
data/appsettings.cpp
View File

@ -20,8 +20,6 @@
#include <QPoint> #include <QPoint>
#include <QColor> #include <QColor>
AppSettings *settings;
AppSettings::AppSettings(QObject *parent) : AppSettings::AppSettings(QObject *parent) :
BasicSettingsObject(parent) BasicSettingsObject(parent)
{ {

2
data/appsettings.h
View File

@ -27,6 +27,4 @@ public:
explicit AppSettings(QObject *parent = 0); explicit AppSettings(QObject *parent = 0);
}; };
extern AppSettings *settings;
#endif // APPSETTINGS_H #endif // APPSETTINGS_H

324
data/minecraftprocess.cpp
View File

@ -34,213 +34,215 @@
// commandline splitter // commandline splitter
QStringList MinecraftProcess::splitArgs(QString args) QStringList MinecraftProcess::splitArgs(QString args)
{ {
QStringList argv; QStringList argv;
QString current; QString current;
bool escape = false; bool escape = false;
QChar inquotes; QChar inquotes;
for (int i=0; i<args.length(); i++) for (int i=0; i<args.length(); i++)
{ {
QChar cchar = args.at(i); QChar cchar = args.at(i);
// \ escaped // \ escaped
if (escape) { if (escape) {
current += cchar; current += cchar;
escape = false; escape = false;
// in "quotes" // in "quotes"
} else if (!inquotes.isNull()) { } else if (!inquotes.isNull()) {
if (cchar == 0x5C) if (cchar == 0x5C)
escape = true; escape = true;
else if (cchar == inquotes) else if (cchar == inquotes)
inquotes = 0; inquotes = 0;
else else
current += cchar; current += cchar;
// otherwise // otherwise
} else { } else {
if (cchar == 0x20) { if (cchar == 0x20) {
if (!current.isEmpty()) { if (!current.isEmpty()) {
argv << current; argv << current;
current.clear(); current.clear();
} }
} else if (cchar == 0x22 || cchar == 0x27) } else if (cchar == 0x22 || cchar == 0x27)
inquotes = cchar; inquotes = cchar;
else else
current += cchar; current += cchar;
} }
} }
if (!current.isEmpty()) if (!current.isEmpty())
argv << current; argv << current;
return argv; return argv;
} }
// prepare tools // prepare tools
inline void MinecraftProcess::extractIcon(InstancePtr inst, QString destination) inline void MinecraftProcess::extractIcon(InstancePtr inst, QString destination)
{ {
QImage(":/icons/instances/" + inst->iconKey()).save(destination); QImage(":/icons/instances/" + inst->iconKey()).save(destination);
} }
inline void MinecraftProcess::extractLauncher(QString destination) inline void MinecraftProcess::extractLauncher(QString destination)
{ {
QFile(":/launcher/launcher.jar").copy(destination); QFile(":/launcher/launcher.jar").copy(destination);
} }
void MinecraftProcess::prepare(InstancePtr inst) void MinecraftProcess::prepare(InstancePtr inst)
{ {
extractLauncher(PathCombine(inst->minecraftDir(), LAUNCHER_FILE)); extractLauncher(PathCombine(inst->minecraftDir(), LAUNCHER_FILE));
extractIcon(inst, PathCombine(inst->minecraftDir(), "icon.png")); extractIcon(inst, PathCombine(inst->minecraftDir(), "icon.png"));
} }
// constructor // constructor
MinecraftProcess::MinecraftProcess(InstancePtr inst, QString user, QString session, ConsoleWindow *console) : MinecraftProcess::MinecraftProcess(InstancePtr inst, QString user, QString session, ConsoleWindow *console) :
m_instance(inst), m_user(user), m_session(session), m_console(console) m_instance(inst), m_user(user), m_session(session), m_console(console)
{ {
connect(this, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(finish(int, QProcess::ExitStatus))); connect(this, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(finish(int, QProcess::ExitStatus)));
// prepare the process environment // prepare the process environment
QProcessEnvironment env = QProcessEnvironment::systemEnvironment(); QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
#ifdef LINUX #ifdef LINUX
// Strip IBus // Strip IBus
if (env.value("XMODIFIERS").contains(IBUS)) if (env.value("XMODIFIERS").contains(IBUS))
env.insert("XMODIFIERS", env.value("XMODIFIERS").replace(IBUS, "")); env.insert("XMODIFIERS", env.value("XMODIFIERS").replace(IBUS, ""));
#endif #endif
// export some infos // export some infos
env.insert("INST_NAME", inst->name()); env.insert("INST_NAME", inst->name());
env.insert("INST_ID", inst->id()); env.insert("INST_ID", inst->id());
env.insert("INST_DIR", QDir(inst->rootDir()).absolutePath()); env.insert("INST_DIR", QDir(inst->rootDir()).absolutePath());
this->setProcessEnvironment(env); this->setProcessEnvironment(env);
m_prepostlaunchprocess.setProcessEnvironment(env); m_prepostlaunchprocess.setProcessEnvironment(env);
// set the cwd // set the cwd
QDir mcDir(inst->minecraftDir()); QDir mcDir(inst->minecraftDir());
this->setWorkingDirectory(mcDir.absolutePath()); this->setWorkingDirectory(mcDir.absolutePath());
m_prepostlaunchprocess.setWorkingDirectory(mcDir.absolutePath()); m_prepostlaunchprocess.setWorkingDirectory(mcDir.absolutePath());
// std channels // std channels
connect(this, SIGNAL(readyReadStandardError()), SLOT(on_stdErr())); connect(this, SIGNAL(readyReadStandardError()), SLOT(on_stdErr()));
connect(this, SIGNAL(readyReadStandardOutput()), SLOT(on_stdOut())); connect(this, SIGNAL(readyReadStandardOutput()), SLOT(on_stdOut()));
} }
// console window // console window
void MinecraftProcess::on_stdErr() void MinecraftProcess::on_stdErr()
{ {
if (m_console != nullptr) if (m_console != nullptr)
m_console->write(readAllStandardError(), ConsoleWindow::ERROR); m_console->write(readAllStandardError(), ConsoleWindow::ERROR);
} }
void MinecraftProcess::on_stdOut() void MinecraftProcess::on_stdOut()
{ {
if (m_console != nullptr) if (m_console != nullptr)
m_console->write(readAllStandardOutput(), ConsoleWindow::DEFAULT); m_console->write(readAllStandardOutput(), ConsoleWindow::DEFAULT);
} }
void MinecraftProcess::log(QString text) void MinecraftProcess::log(QString text)
{ {
if (m_console != nullptr) if (m_console != nullptr)
m_console->write(text); m_console->write(text);
else else
qDebug(qPrintable(text)); qDebug(qPrintable(text));
} }
// exit handler // exit handler
void MinecraftProcess::finish(int code, ExitStatus status) void MinecraftProcess::finish(int code, ExitStatus status)
{ {
if (status != NormalExit) if (status != NormalExit)
{ {
//TODO: error handling //TODO: error handling
} }
log("Minecraft exited."); log("Minecraft exited.");
m_prepostlaunchprocess.processEnvironment().insert("INST_EXITCODE", QString(code)); m_prepostlaunchprocess.processEnvironment().insert("INST_EXITCODE", QString(code));
// run post-exit // run post-exit
if (!m_instance->getPostExitCommand().isEmpty()) if (!m_instance->settings().get("PostExitCommand").toString().isEmpty())
{ {
m_prepostlaunchprocess.start(m_instance->getPostExitCommand()); m_prepostlaunchprocess.start(m_instance->settings().get("PostExitCommand").toString());
m_prepostlaunchprocess.waitForFinished(); m_prepostlaunchprocess.waitForFinished();
if (m_prepostlaunchprocess.exitStatus() != NormalExit) if (m_prepostlaunchprocess.exitStatus() != NormalExit)
{ {
//TODO: error handling //TODO: error handling
} }
} }
if (m_console != nullptr) if (m_console != nullptr)
m_console->setMayClose(true); m_console->setMayClose(true);
emit ended(); emit ended();
} }
void MinecraftProcess::launch() void MinecraftProcess::launch()
{ {
if (!m_instance->getPreLaunchCommand().isEmpty()) if (!m_instance->settings().get("PreLaunchCommand").toString().isEmpty())
{ {
m_prepostlaunchprocess.start(m_instance->getPreLaunchCommand()); m_prepostlaunchprocess.start(m_instance->settings().get("PreLaunchCommand").toString());
m_prepostlaunchprocess.waitForFinished(); m_prepostlaunchprocess.waitForFinished();
if (m_prepostlaunchprocess.exitStatus() != NormalExit) if (m_prepostlaunchprocess.exitStatus() != NormalExit)
{ {
//TODO: error handling //TODO: error handling
return; return;
} }
} }
m_instance->setLastLaunch(); m_instance->setLastLaunch();
prepare(m_instance); prepare(m_instance);
genArgs(); genArgs();
log(QString("Minecraft folder is: '%1'").arg(workingDirectory())); log(QString("Minecraft folder is: '%1'").arg(workingDirectory()));
log(QString("Instance launched with arguments: '%1'").arg(m_arguments.join("' '"))); log(QString("Instance launched with arguments: '%1'").arg(m_arguments.join("' '")));
start(m_instance->getJavaPath(), m_arguments); start(m_instance->settings().get("JavaPath").toString(), m_arguments);
if (!waitForStarted()) if (!waitForStarted())
{ {
//TODO: error handling //TODO: error handling
} }
if(m_console != nullptr) if(m_console != nullptr)
m_console->setMayClose(false); m_console->setMayClose(false);
} }
void MinecraftProcess::genArgs() void MinecraftProcess::genArgs()
{ {
// start fresh // start fresh
m_arguments.clear(); m_arguments.clear();
// window size // window size
QString windowSize; QString windowSize;
if (m_instance->getLaunchMaximized()) if (m_instance->settings().get("LaunchMaximized").toBool())
windowSize = "max"; windowSize = "max";
else else
windowSize = QString("%1x%2").arg(m_instance->getMinecraftWinWidth()).arg(m_instance->getMinecraftWinHeight()); windowSize = QString("%1x%2").
arg(m_instance->settings().get("MinecraftWinWidth").toInt()).
// window title arg(m_instance->settings().get("MinecraftWinHeight").toInt());
QString windowTitle;
windowTitle.append("MultiMC: ").append(m_instance->name()); // window title
QString windowTitle;
// Java arguments windowTitle.append("MultiMC: ").append(m_instance->name());
m_arguments.append(splitArgs(m_instance->getJvmArgs()));
// Java arguments
m_arguments.append(splitArgs(m_instance->settings().get("JvmArgs").toString()));
#ifdef OSX #ifdef OSX
// OSX dock icon and name // OSX dock icon and name
m_arguments << "-Xdock:icon=icon.png"; m_arguments << "-Xdock:icon=icon.png";
m_arguments << QString("-Xdock:name=\"%1\"").arg(windowTitle); m_arguments << QString("-Xdock:name=\"%1\"").arg(windowTitle);
#endif #endif
// lwjgl // lwjgl
QString lwjgl = m_instance->lwjglVersion(); QString lwjgl = m_instance->lwjglVersion();
if (lwjgl != "Mojang") if (lwjgl != "Mojang")
lwjgl = QDir(settings->getLWJGLDir() + "/" + lwjgl).absolutePath(); lwjgl = QDir(globalSettings->get("LWJGLDir").toString() + "/" + lwjgl).absolutePath();
// launcher arguments // launcher arguments
m_arguments << QString("-Xms%1m").arg(m_instance->getMinMemAlloc()); m_arguments << QString("-Xms%1m").arg(m_instance->settings().get("MinMemAlloc").toInt());
m_arguments << QString("-Xmx%1m").arg(m_instance->getMaxMemAlloc()); m_arguments << QString("-Xmx%1m").arg(m_instance->settings().get("MaxMemAlloc").toInt());
m_arguments << "-jar" << LAUNCHER_FILE; m_arguments << "-jar" << LAUNCHER_FILE;
m_arguments << m_user; m_arguments << m_user;
m_arguments << m_session; m_arguments << m_session;
m_arguments << windowTitle; m_arguments << windowTitle;
m_arguments << windowSize; m_arguments << windowSize;
m_arguments << lwjgl; m_arguments << lwjgl;
} }

6
gui/mainwindow.cpp
View File

@ -53,7 +53,7 @@ void openInDefaultProgram(QString filename);
MainWindow::MainWindow(QWidget *parent) : MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent), QMainWindow(parent),
ui(new Ui::MainWindow), ui(new Ui::MainWindow),
instList(settings->get("InstanceDir").toString()) instList(globalSettings->get("InstanceDir").toString())
{ {
ui->setupUi(this); ui->setupUi(this);
@ -78,7 +78,7 @@ void MainWindow::on_actionAddInstance_triggered()
void MainWindow::on_actionViewInstanceFolder_triggered() void MainWindow::on_actionViewInstanceFolder_triggered()
{ {
openInDefaultProgram(settings->get("InstanceDir").toString()); openInDefaultProgram(globalSettings->get("InstanceDir").toString());
} }
void MainWindow::on_actionRefresh_triggered() void MainWindow::on_actionRefresh_triggered()
@ -88,7 +88,7 @@ void MainWindow::on_actionRefresh_triggered()
void MainWindow::on_actionViewCentralModsFolder_triggered() void MainWindow::on_actionViewCentralModsFolder_triggered()
{ {
openInDefaultProgram(settings->get("CentralModsDir").toString()); openInDefaultProgram(globalSettings->get("CentralModsDir").toString());
} }
void MainWindow::on_actionCheckUpdate_triggered() void MainWindow::on_actionCheckUpdate_triggered()

4
gui/settingsdialog.cpp
View File

@ -27,7 +27,7 @@ SettingsDialog::SettingsDialog(QWidget *parent) :
{ {
ui->setupUi(this); ui->setupUi(this);
loadSettings(settings); loadSettings(globalSettings);
updateCheckboxStuff(); updateCheckboxStuff();
} }
@ -84,7 +84,7 @@ void SettingsDialog::on_maximizedCheckBox_clicked(bool checked)
void SettingsDialog::on_buttonBox_accepted() void SettingsDialog::on_buttonBox_accepted()
{ {
applySettings(settings); applySettings(globalSettings);
} }
void SettingsDialog::applySettings(SettingsObject *s) void SettingsDialog::applySettings(SettingsObject *s)

12
libinstance/include/instance.h
View File

@ -19,6 +19,8 @@
#include <QObject> #include <QObject>
#include <QDateTime> #include <QDateTime>
#include <settingsobject.h>
#include "inifile.h" #include "inifile.h"
#include "libinstance_config.h" #include "libinstance_config.h"
@ -280,6 +282,16 @@ public:
*/ */
virtual void updateCurrentVersion(bool keepCurrent = false) = 0; virtual void updateCurrentVersion(bool keepCurrent = false) = 0;
//// Settings System ////
/*!
* \brief Gets this instance's settings object.
* This settings object stores instance-specific settings.
* \return A pointer to this instance's settings object.
*/
virtual SettingsObject &settings();
protected: protected:
/*! /*!
* \brief Gets the value of the given field in the instance's config file. * \brief Gets the value of the given field in the instance's config file.

7
libinstance/src/instance.cpp
View File

@ -17,6 +17,8 @@
#include <QFileInfo> #include <QFileInfo>
#include "settingsobject.h"
#include "pathutils.h" #include "pathutils.h"
Instance::Instance(const QString &rootDir, QObject *parent) : Instance::Instance(const QString &rootDir, QObject *parent) :
@ -104,3 +106,8 @@ void Instance::setField(const QString &name, QVariant val)
{ {
config.set(name, val); config.set(name, val);
} }
SettingsObject &Instance::settings()
{
return *globalSettings;
}

5
libsettings/include/settingsobject.h
View File

@ -162,4 +162,9 @@ private:
QMap<QString, Setting *> m_settings; QMap<QString, Setting *> m_settings;
}; };
/*!
* \brief A global settings object.
*/
LIBMMCSETTINGS_EXPORT extern SettingsObject *globalSettings;
#endif // SETTINGSOBJECT_H #endif // SETTINGSOBJECT_H

2
libsettings/src/settingsobject.cpp
View File

@ -18,6 +18,8 @@
#include <QVariant> #include <QVariant>
SettingsObject *globalSettings;
SettingsObject::SettingsObject(QObject *parent) : SettingsObject::SettingsObject(QObject *parent) :
QObject(parent) QObject(parent)
{ {

62
libutil/include/cmdutils.h
View File

@ -25,6 +25,8 @@
#include <QHash> #include <QHash>
#include <QStringList> #include <QStringList>
#include "libutil_config.h"
/** /**
* @file libutil/include/cmdutils.h * @file libutil/include/cmdutils.h
* @brief commandline parsing utilities * @brief commandline parsing utilities
@ -37,7 +39,11 @@ namespace Commandline {
* @brief The FlagStyle enum * @brief The FlagStyle enum
* Specifies how flags are decorated * Specifies how flags are decorated
*/ */
enum class FlagStyle {
namespace FlagStyle
{
enum LIBMMCUTIL_EXPORT Enum
{
GNU, /**< --option and -o (GNU Style) */ GNU, /**< --option and -o (GNU Style) */
Unix, /**< -option and -o (Unix Style) */ Unix, /**< -option and -o (Unix Style) */
Windows, /**< /option and /o (Windows Style) */ Windows, /**< /option and /o (Windows Style) */
@ -47,11 +53,15 @@ enum class FlagStyle {
Default = GNU Default = GNU
#endif #endif
}; };
}
/** /**
* @brief The ArgumentStyle enum * @brief The ArgumentStyle enum
*/ */
enum class ArgumentStyle { namespace ArgumentStyle
{
enum LIBMMCUTIL_EXPORT Enum
{
Space, /**< --option=value */ Space, /**< --option=value */
Equals, /**< --option value */ Equals, /**< --option value */
SpaceAndEquals, /**< --option[= ]value */ SpaceAndEquals, /**< --option[= ]value */
@ -61,11 +71,21 @@ enum class ArgumentStyle {
Default = SpaceAndEquals Default = SpaceAndEquals
#endif #endif
}; };
}
namespace OptionType
{
enum LIBMMCUTIL_EXPORT Enum
{
Switch,
Option
};
}
/** /**
* @brief The ParsingError class * @brief The ParsingError class
*/ */
class ParsingError : public std::exception class LIBMMCUTIL_EXPORT ParsingError : public std::exception
{ {
public: public:
ParsingError(const QString &what); ParsingError(const QString &what);
@ -80,7 +100,7 @@ private:
/** /**
* @brief The Parser class * @brief The Parser class
*/ */
class Parser class LIBMMCUTIL_EXPORT Parser
{ {
public: public:
/** /**
@ -88,45 +108,46 @@ public:
* @param flagStyle the FlagStyle to use in this Parser * @param flagStyle the FlagStyle to use in this Parser
* @param argStyle the ArgumentStyle to use in this Parser * @param argStyle the ArgumentStyle to use in this Parser
*/ */
Parser(FlagStyle flagStyle=FlagStyle::Default, ArgumentStyle argStyle=ArgumentStyle::Default); Parser(FlagStyle::Enum flagStyle = FlagStyle::Default,
ArgumentStyle::Enum argStyle = ArgumentStyle::Default);
/** /**
* @brief set the flag style * @brief set the flag style
* @param style * @param style
*/ */
void setFlagStyle(FlagStyle style); void setFlagStyle(FlagStyle::Enum style);
/** /**
* @brief get the flag style * @brief get the flag style
* @return * @return
*/ */
FlagStyle flagStyle(); FlagStyle::Enum flagStyle();
/** /**
* @brief set the argument style * @brief set the argument style
* @param style * @param style
*/ */
void setArgumentStyle(ArgumentStyle style); void setArgumentStyle(ArgumentStyle::Enum style);
/** /**
* @brief get the argument style * @brief get the argument style
* @return * @return
*/ */
ArgumentStyle argumentStyle(); ArgumentStyle::Enum argumentStyle();
/** /**
* @brief define a boolean switch * @brief define a boolean switch
* @param name the parameter name * @param name the parameter name
* @param def the default value * @param def the default value
*/ */
void addSwitch(QString name, bool def=false); void addSwitch(QString name, bool def = false);
/** /**
* @brief define an option that takes an additional argument * @brief define an option that takes an additional argument
* @param name the parameter name * @param name the parameter name
* @param def the default value * @param def the default value
*/ */
void addOption(QString name, QVariant def=QVariant()); void addOption(QString name, QVariant def = QVariant());
/** /**
* @brief define a positional argument * @brief define a positional argument
@ -134,7 +155,7 @@ public:
* @param required wether this argument is required * @param required wether this argument is required
* @param def the default value * @param def the default value
*/ */
void addArgument(QString name, bool required=true, QVariant def=QVariant()); void addArgument(QString name, bool required = true, QVariant def = QVariant());
/** /**
* @brief adds a flag to an existing parameter * @brief adds a flag to an existing parameter
@ -153,7 +174,7 @@ public:
* Note: on positional arguments, metavar replaces the name as displayed. * Note: on positional arguments, metavar replaces the name as displayed.
* on options , metavar replaces the value placeholder * on options , metavar replaces the value placeholder
*/ */
void addDocumentation(QString name, QString doc, QString metavar=QString()); void addDocumentation(QString name, QString doc, QString metavar = QString());
/** /**
* @brief generate a help message * @brief generate a help message
@ -162,7 +183,7 @@ public:
* @param flagsInUsage whether we should use flags instead of options in the usage * @param flagsInUsage whether we should use flags instead of options in the usage
* @return a help message * @return a help message
*/ */
QString compileHelp(QString progName, int helpIndent=22, bool flagsInUsage=true); QString compileHelp(QString progName, int helpIndent = 22, bool flagsInUsage = true);
/** /**
* @brief generate a short usage message * @brief generate a short usage message
@ -170,7 +191,7 @@ public:
* @param useFlags whether we should use flags instead of options * @param useFlags whether we should use flags instead of options
* @return a usage message * @return a usage message
*/ */
QString compileUsage(QString progName, bool useFlags=true); QString compileUsage(QString progName, bool useFlags = true);
/** /**
* @brief parse * @brief parse
@ -187,13 +208,8 @@ public:
~Parser(); ~Parser();
private: private:
FlagStyle m_flagStyle; FlagStyle::Enum m_flagStyle;
ArgumentStyle m_argStyle; ArgumentStyle::Enum m_argStyle;
enum class OptionType {
Switch,
Option
};
// Important: the common part MUST BE COMMON ON ALL THREE structs // Important: the common part MUST BE COMMON ON ALL THREE structs
struct CommonDef { struct CommonDef {
@ -210,7 +226,7 @@ private:
QString metavar; QString metavar;
QVariant def; QVariant def;
// option // option
OptionType type; OptionType::Enum type;
QChar flag; QChar flag;
}; };

6
libutil/include/userutils.h
View File

@ -3,15 +3,17 @@
#include <QString> #include <QString>
#include "libutil_config.h"
namespace Util namespace Util
{ {
// Get the Directory representing the User's Desktop // Get the Directory representing the User's Desktop
QString getDesktopDir(); LIBMMCUTIL_EXPORT QString getDesktopDir();
// Create a shortcut at *location*, pointing to *dest* called with the arguments *args* // Create a shortcut at *location*, pointing to *dest* called with the arguments *args*
// call it *name* and assign it the icon *icon* // call it *name* and assign it the icon *icon*
// return true if operation succeeded // return true if operation succeeded
bool createShortCut(QString location, QString dest, QStringList args, QString name, QString iconLocation); LIBMMCUTIL_EXPORT bool createShortCut(QString location, QString dest, QStringList args, QString name, QString iconLocation);
} }
#endif // USERUTILS_H #endif // USERUTILS_H

654
libutil/src/cmdutils.cpp
View File

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

158
libutil/src/userutils.cpp
View File

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

6
main.cpp
View File

@ -52,7 +52,7 @@ private:
MinecraftProcess *proc; MinecraftProcess *proc;
ConsoleWindow *console; ConsoleWindow *console;
public: public:
InstanceLauncher(QString instId) : QObject(), instances(settings->get("InstanceDir").toString()) InstanceLauncher(QString instId) : QObject(), instances(globalSettings->get("InstanceDir").toString())
{ {
this->instId = instId; this->instId = instId;
} }
@ -85,7 +85,7 @@ private slots:
{ {
// TODO: console // TODO: console
console = new ConsoleWindow(); console = new ConsoleWindow();
proc = new MinecraftProcess(instance, response.getUsername(), response.getSessionID(), console); proc = new MinecraftProcess(instance, response.username(), response.sessionID(), console);
//if (instance->getShowConsole()) //if (instance->getShowConsole())
console->show(); console->show();
connect(proc, SIGNAL(ended()), SLOT(onTerminated())); connect(proc, SIGNAL(ended()), SLOT(onTerminated()));
@ -217,7 +217,7 @@ int main(int argc, char *argv[])
QDir::setCurrent(args["dir"].toString()); QDir::setCurrent(args["dir"].toString());
// load settings // load settings
settings = new AppSettings(&app); globalSettings = new AppSettings(&app);
// Register meta types. // Register meta types.
qRegisterMetaType<LoginResponse>("LoginResponse"); qRegisterMetaType<LoginResponse>("LoginResponse");