CactiChameleon9/PrismLauncher
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Split MultiMC up into a few separate libraries.

Browse Source 
Fixed plugin system.

Tons of other stuff...
This commit is contained in:
Andrew
2013-02-20 19:10:09 -06:00
parent f71479ec33
commit dd2e836b4c
42 changed files with 404 additions and 300 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
libutil/include/apputils.h Normal file
View File

@ -0,0 +1,21 @@
/* 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 APPUTILS_H
#define APPUTILS_H
#define STR_VAL(val) # val
#endif // APPUTILS_H

38
libutil/include/inifile.h Normal file
View File

@ -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 INIFILE_H
#define INIFILE_H
#include <QMap>
#include <QString>
#include <QVariant>
#include "libutil_config.h"
// Sectionless INI parser (for instance config files)
class LIBMMCUTIL_EXPORT INIFile : public QMap<QString, QVariant>
{
public:
explicit INIFile();
bool loadFile(QString fileName);
bool saveFile(QString fileName);
QVariant get(QString key, QVariant def) const;
void set(QString key, QVariant val);
};
#endif // INIFILE_H

27
libutil/include/libutil_config.h Normal file
View File

@ -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.
*/
#ifndef LIBUTIL_CONFIG_H
#define LIBUTIL_CONFIG_H
#include <QtCore/QtGlobal>
#ifdef LIBMMCUTIL_LIBRARY
# define LIBMMCUTIL_EXPORT Q_DECL_EXPORT
#else
# define LIBMMCUTIL_EXPORT Q_DECL_IMPORT
#endif
#endif // LIBUTIL_CONFIG_H

29
libutil/include/osutils.h Normal file
View File

@ -0,0 +1,29 @@
/* 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 OSUTILS_H
#define OSUTILS_H
#include <QString>
#if defined _WIN32 | defined _WIN64
#define WINDOWS 1
#elif __APPLE__ & __MACH__
#define OSX 1
#elif __linux__
#define LINUX 1
#endif
#endif // OSUTILS_H

28
libutil/include/pathutils.h Normal file
View File

@ -0,0 +1,28 @@
/* 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 PATHUTILS_H
#define PATHUTILS_H
#include <QString>
#include "libutil_config.h"
LIBMMCUTIL_EXPORT QString PathCombine(QString path1, QString path2);
LIBMMCUTIL_EXPORT QString PathCombine(QString path1, QString path2, QString path3);
LIBMMCUTIL_EXPORT QString AbsolutePath(QString path);
#endif // PATHUTILS_H

130
libutil/include/siglist.h Normal file
View File

@ -0,0 +1,130 @@
/* 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 SIGLIST_H
#define SIGLIST_H
#include <QObject>
#include <QList>
// A QList that allows emitting signals when the list changes.
// Since QObject doesn't support templates, to use this class with a
// certain type, you should create a class deriving from SigList<T> and then
// call the DEFINE_SIGLIST_SIGNALS(T) and SETUP_SIGLIST_SIGNALS(T) macros.
template <typename T>
class SigList : public QList<T>
{
public:
explicit SigList() : QList<T>() {}
virtual void append(const T &value);
virtual void append(const QList<T> &other);
virtual void clear();
virtual void erase(iterator pos);
virtual void erase(iterator first, iterator last);
virtual void insert(int i, const T &t);
virtual void insert(iterator before, const T &t);
virtual void move(int from, int to);
virtual void pop_back() { takeLast(); }
virtual void pop_front() { takeFirst(); }
virtual void push_back(const T &t) { append(t); }
virtual void push_front(const T &t) { prepend(t); }
virtual void prepend(const T &t);
virtual int removeAll(const T &t);
virtual bool removeOne(const T &t);
virtual void removeAt(int i) { takeAt(i); }
virtual void removeFirst() { takeFirst(); }
virtual void removeLast() { takeLast(); }
virtual void swap(QList<T> &other);
virtual void swap(int i, int j);
virtual T takeAt(int i);
virtual T takeFirst();
virtual T takeLast();
virtual QList<T> &operator +=(const QList<T> &other) { append(other); return *this; }
virtual QList<T> &operator +=(const T &value) { append(value); return *this; }
virtual QList<T> &operator <<(const QList<T> &other) { append(other); return *this; }
virtual QList<T> &operator <<(const T &value) { append(value); return *this; }
virtual QList<T> &operator =(const QList<T> &other);
// Signal emitted after an item is added to the list.
// Contains a reference to item and the item's new index.
virtual void onItemAdded(const T &item, int index) = 0;
// Signal emitted after multiple items are added to the list at once.
// The items parameter is a const reference to a QList of the items that
// were added.
// The firstIndex parameter is the new index of the first item added.
virtual void onItemsAdded(const QList<T> &items, int firstIndex) = 0;
// Signal emitted after an item is removed to the list.
// Contains a reference to the item and the item's old index.
virtual void onItemRemoved(const T &item, int index) = 0;
// Signal emitted after multiple items are removed from the list at once.
// The items parameter is a const reference to a QList of the items that
// were added.
// The firstIndex parameter is the new index of the first item added.
virtual void onItemsRemoved(const QList<T> &items, int firstIndex) = 0;
// Signal emitted after an item is moved to another index.
// Contains the item, the old index, and the new index.
virtual void onItemMoved(const T &item, int oldIndex, int newIndex) = 0;
// Signal emitted after an operation that changes the whole list occurs.
// This signal should be treated as if all data in the entire list was cleared
// and new data added in its place.
virtual void onInvalidated() = 0;
};
// Defines the signals for a SigList
#define DEFINE_SIGLIST_SIGNALS(TYPE) \
Q_SIGNAL void itemAdded(TYPE const &item, int index);\
Q_SIGNAL void itemsAdded(const QList<TYPE> &items, int firstIndex);\
Q_SIGNAL void itemRemoved(TYPE const &item, int index);\
Q_SIGNAL void itemsRemoved(const QList<TYPE> &items, int firstIndex);\
Q_SIGNAL void itemMoved(TYPE const &item, int oldIndex, int newIndex);\
Q_SIGNAL void invalidated();
// Overrides the onItem* functions and causes them to emit their corresponding
// signals.
#define SETUP_SIGLIST_SIGNALS(TYPE) \
virtual void onItemAdded(TYPE const &item, int index)\
{ emit itemAdded(item, index); }\
virtual void onItemsAdded(const QList<TYPE> &items, int firstIndex)\
{ emit itemsAdded(items, firstIndex); }\
virtual void onItemRemoved(TYPE const &item, int index)\
{ emit itemRemoved(item, index); }\
virtual void onItemsRemoved(const QList<TYPE> &items, int firstIndex)\
{ emit itemsRemoved(items, firstIndex); }\
virtual void onItemMoved(TYPE const &item, int oldIndex, int newIndex)\
{ emit itemMoved(item, oldIndex, newIndex); }\
virtual void onInvalidated() { emit invalidated(); }
#endif // SIGLIST_H

156
libutil/include/siglist_impl.h Normal file
View File

@ -0,0 +1,156 @@
/* 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 "siglist.h"
template <typename T>
void SigList<T>::append(const T &value)
{
QList<T>::append(value);
onItemAdded(value, length() - 1);
}
template <typename T>
void SigList<T>::prepend(const T &value)
{
QList<T>::prepend(value);
onItemAdded(value, 0);
}
template <typename T>
void SigList<T>::append(const QList<T> &other)
{
int index = length();
QList<T>::append(other);
onItemsAdded(other, index);
}
template <typename T>
void SigList<T>::clear()
{
QList<T>::clear();
onInvalidated();
}
template <typename T>
void SigList<T>::erase(QList<T>::iterator pos)
{
T value = *pos;
int index = indexOf(*pos);
QList<T>::erase(pos);
onItemRemoved(value, index);
}
template <typename T>
void SigList<T>::erase(QList<T>::iterator first, QList<T>::iterator last)
{
QList<T> removedValues;
int firstIndex = indexOf(*first);
for (QList<T>::iterator iter = first; iter < last; iter++)
{
removedValues << *iter;
QList<T>::erase(iter);
}
onItemsRemoved(removedValues, firstIndex);
}
template <typename T>
void SigList<T>::insert(int i, const T &t)
{
QList<T>::insert(i, t);
onItemAdded(t, i);
}
template <typename T>
void SigList<T>::insert(QList<T>::iterator before, const T &t)
{
QList<T>::insert(before, t);
onItemAdded(t, indexOf(t));
}
template <typename T>
void SigList<T>::move(int from, int to)
{
const T &item = at(from);
QList<T>::move(from, to);
onItemMoved(item, from, to);
}
template <typename T>
int SigList<T>::removeAll(const T &t)
{
int retVal = QList<T>::removeAll(t);
onInvalidated();
return retVal;
}
template <typename T>
bool SigList<T>::removeOne(const T &t)
{
int index = indexOf(t);
if (QList<T>::removeOne(t))
{
onItemRemoved(t, index);
return true;
}
return false;
}
template <typename T>
void SigList<T>::swap(QList<T> &other)
{
QList<T>::swap(other);
onInvalidated();
}
template <typename T>
void SigList<T>::swap(int i, int j)
{
const T &item1 = at(i);
const T &item2 = at(j);
QList<T>::swap(i, j);
onItemMoved(item1, i, j);
onItemMoved(item2, j, i);
}
template <typename T>
T SigList<T>::takeAt(int i)
{
T val = QList<T>::takeAt(i);
onItemRemoved(val, i);
return val;
}
template <typename T>
T SigList<T>::takeFirst()
{
return takeAt(0);
}
template <typename T>
T SigList<T>::takeLast()
{
return takeAt(length() - 1);
}
template <typename T>
QList<T> &SigList<T>::operator =(const QList<T> &other)
{
QList<T>::operator =(other);
onInvalidated();
return *this;
}