Turn things in common into separate libs.

Took 2 hours 27 minutes

libs/utility/include/utility/card_ref.h

@@ -0,0 +1,24 @@
+#ifndef CARD_REF_H
+#define CARD_REF_H
+
+#include <QString>
+
+/**
+ * The information passed over the server that is required to identify the exact card to display.
+ *
+ * @param name The name of the card. Should not be empty, unless to indicate the lack of a card.
+ * @param providerId Determines which printing of the card to use. Can be empty, in which case Cockatrice should default
+ * to using the preferred set.
+ */
+struct CardRef
+{
+    QString name;
+    QString providerId = QString();
+
+    bool operator==(const CardRef &other) const
+    {
+        return name == other.name && providerId == other.providerId;
+    }
+};
+
+#endif // CARD_REF_H

libs/utility/include/utility/color.h

@@ -0,0 +1,35 @@
+#ifndef COLOR_H
+#define COLOR_H
+
+#ifdef QT_GUI_LIB
+#include <QColor>
+#endif
+
+#include "pb/color.pb.h"
+
+#ifdef QT_GUI_LIB
+inline QColor convertColorToQColor(const color &c)
+{
+    return QColor(c.r(), c.g(), c.b());
+}
+
+inline color convertQColorToColor(const QColor &c)
+{
+    color result;
+    result.set_r(c.red());
+    result.set_g(c.green());
+    result.set_b(c.blue());
+    return result;
+}
+#endif
+
+inline color makeColor(int r, int g, int b)
+{
+    color result;
+    result.set_r(r);
+    result.set_g(g);
+    result.set_b(b);
+    return result;
+}
+
+#endif

libs/utility/include/utility/expression.h

@@ -0,0 +1,28 @@
+#ifndef EXPRESSION_H
+#define EXPRESSION_H
+
+#include <QMap>
+#include <QString>
+#include <functional>
+
+namespace peg
+{
+template <typename Annotation> struct AstBase;
+struct EmptyType;
+typedef AstBase<EmptyType> Ast;
+} // namespace peg
+
+class Expression
+{
+public:
+    double value;
+
+    explicit Expression(double initial = 0);
+    double parse(const QString &expr);
+
+private:
+    double eval(const peg::Ast &ast);
+    QMap<QString, std::function<double(double)>> fns;
+};
+
+#endif

libs/utility/include/utility/featureset.h

@@ -0,0 +1,27 @@
+#ifndef FEATURESET_H
+#define FEATURESET_H
+
+#include <QMap>
+#include <QSet>
+#include <QString>
+
+class FeatureSet
+{
+public:
+    FeatureSet();
+    QMap<QString, bool> getDefaultFeatureList();
+    void initalizeFeatureList(QMap<QString, bool> &_featureList);
+    void enableRequiredFeature(QMap<QString, bool> &_featureList, const QString &featureName);
+    void disableRequiredFeature(QMap<QString, bool> &_featureList, const QString &featureName);
+    QMap<QString, bool>
+    addFeature(QMap<QString, bool> &_featureList, const QString &featureName, bool isFeatureRequired);
+    QMap<QString, bool> identifyMissingFeatures(const QMap<QString, bool> &featureListToCheck,
+                                                QMap<QString, bool> featureListToCompareTo);
+    bool isRequiredFeaturesMissing(const QMap<QString, bool> &featureListToCheck,
+                                   QMap<QString, bool> featureListToCompareTo);
+
+private:
+    QMap<QString, bool> featureList;
+};
+
+#endif // FEEATURESET_H

libs/utility/include/utility/key_signals.h

@@ -0,0 +1,36 @@
+/**
+ * @file key_signals.h
+ * @ingroup Core
+ * @ingroup UI
+ * @brief TODO: Document this.
+ */
+
+#ifndef KEYSIGNALS_H
+#define KEYSIGNALS_H
+
+#include <QEvent>
+#include <QObject>
+
+class KeySignals : public QObject
+{
+    Q_OBJECT
+
+signals:
+    void onEnter();
+    void onCtrlEnter();
+    void onCtrlAltEnter();
+    void onShiftLeft();
+    void onShiftRight();
+    void onDelete();
+    void onCtrlAltMinus();
+    void onCtrlAltEqual();
+    void onCtrlAltLBracket();
+    void onCtrlAltRBracket();
+    void onShiftS();
+    void onCtrlC();
+
+protected:
+    bool eventFilter(QObject *, QEvent *event) override;
+};
+
+#endif

libs/utility/include/utility/levenshtein.h

@@ -0,0 +1,14 @@
+/**
+ * @file levenshtein.h
+ * @ingroup Core
+ * @brief TODO: Document this.
+ */
+
+#ifndef LEVENSHTEIN_H
+#define LEVENSHTEIN_H
+
+#include <QString>
+
+int levenshteinDistance(const QString &s1, const QString &s2);
+
+#endif // LEVENSHTEIN_H

libs/utility/include/utility/logger.h

@@ -0,0 +1,72 @@
+/**
+ * @file logger.h
+ * @ingroup Core
+ * @brief TODO: Document this.
+ */
+
+#ifndef LOGGER_H
+#define LOGGER_H
+
+#include <QFile>
+#include <QMutex>
+#include <QString>
+#include <QTextStream>
+#include <QVector>
+
+#if defined(Q_PROCESSOR_X86_32)
+#define BUILD_ARCHITECTURE "32-bit"
+#elif defined(Q_PROCESSOR_X86_64)
+#define BUILD_ARCHITECTURE "64-bit"
+#elif defined(Q_PROCESSOR_ARM)
+#define BUILD_ARCHITECTURE "ARM"
+#else
+#define BUILD_ARCHITECTURE "unknown"
+#endif
+
+class Logger : public QObject
+{
+    Q_OBJECT
+public:
+    static Logger &getInstance()
+    {
+        static Logger instance;
+        return instance;
+    }
+
+    void logToFile(bool enabled);
+    void log(QtMsgType type, const QMessageLogContext &ctx, const QString &message);
+    QString getClientVersion();
+    QString getClientOperatingSystem();
+    QString getSystemArchitecture();
+    QString getSystemLocale();
+    QString getClientInstallInfo();
+    QList<QString> getLogBuffer()
+    {
+        return logBuffer;
+    }
+
+private:
+    Logger();
+    ~Logger() override;
+    // Singleton - Don't implement copy constructor and assign operator
+    Logger(Logger const &);
+    void operator=(Logger const &);
+
+    bool logToFileEnabled;
+    QTextStream fileStream;
+    QFile fileHandle;
+    QList<QString> logBuffer;
+    QMutex mutex;
+
+protected:
+    void openLogfileSession();
+    void closeLogfileSession();
+
+protected slots:
+    void internalLog(const QString &message);
+
+signals:
+    void logEntryAdded(const QString &message);
+};
+
+#endif

libs/utility/include/utility/macros.h

@@ -0,0 +1,17 @@
+#ifndef COCKATRICE_MACROS_H
+#define COCKATRICE_MACROS_H
+
+#include <QtGlobal>
+
+// Qt6.7 changed how stateChanged functionality
+// of QCheckBoxes work.
+// See https://doc.qt.io/qt-6/qcheckbox.html#checkStateChanged
+#if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
+#define QT_STATE_CHANGED checkStateChanged
+#define QT_STATE_CHANGED_T Qt::CheckState
+#else
+#define QT_STATE_CHANGED stateChanged
+#define QT_STATE_CHANGED_T int
+#endif
+
+#endif // COCKATRICE_MACROS_H

libs/utility/include/utility/passwordhasher.h

@@ -0,0 +1,14 @@
+#ifndef PASSWORDHASHER_H
+#define PASSWORDHASHER_H
+
+#include <QObject>
+
+class PasswordHasher
+{
+public:
+    static QString computeHash(const QString &password, const QString &salt);
+    static QString generateRandomSalt(const int len = 16);
+    static QString generateActivationToken();
+};
+
+#endif

libs/utility/include/utility/trice_limits.h

@@ -0,0 +1,32 @@
+#ifndef TRICE_LIMITS_H
+#define TRICE_LIMITS_H
+
+#include <QString>
+
+// max size for short strings, like names and things that are generally a single phrase
+constexpr int MAX_NAME_LENGTH = 0xff;
+// max size for chat messages and text contents
+constexpr int MAX_TEXT_LENGTH = 0xfff;
+// max size for deck files and pictures
+constexpr int MAX_FILE_LENGTH = 0x1fffff; // about 2 megabytes
+
+constexpr uint MINIMUM_DIE_SIDES = 2;
+constexpr uint MAXIMUM_DIE_SIDES = 1000000;
+constexpr uint MINIMUM_DICE_TO_ROLL = 1;
+constexpr uint MAXIMUM_DICE_TO_ROLL = 100;
+
+// optimized functions to get qstrings that are at most that long
+static inline QString nameFromStdString(const std::string &_string)
+{
+    return QString::fromUtf8(_string.data(), std::min(int(_string.size()), MAX_NAME_LENGTH));
+}
+static inline QString textFromStdString(const std::string &_string)
+{
+    return QString::fromUtf8(_string.data(), std::min(int(_string.size()), MAX_TEXT_LENGTH));
+}
+static inline QString fileFromStdString(const std::string &_string)
+{
+    return QString::fromUtf8(_string.data(), std::min(int(_string.size()), MAX_FILE_LENGTH));
+}
+
+#endif // TRICE_LIMITS_H