removed appbase directory

src/util/Clamp.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace chatterino {
+
+// http://en.cppreference.com/w/cpp/algorithm/clamp
+
+template <class T>
+constexpr const T &clamp(const T &v, const T &lo, const T &hi)
+{
+    return assert(!(hi < lo)), (v < lo) ? lo : (hi < v) ? hi : v;
+}
+
+}  // namespace chatterino

src/util/CombinePath.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <QDir>
+#include <QString>
+
+namespace chatterino {
+
+// https://stackoverflow.com/a/13014491
+inline QString combinePath(const QString &a, const QString &b)
+{
+    return QDir::cleanPath(a + QDir::separator() + b);
+}
+
+}  // namespace chatterino

src/util/DistanceBetweenPoints.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <QPointF>
+
+#include <cmath>
+
+namespace chatterino {
+
+inline float distanceBetweenPoints(const QPointF &p1, const QPointF &p2)
+{
+    QPointF tmp = p1 - p2;
+
+    float distance = 0.f;
+    distance += tmp.x() * tmp.x();
+    distance += tmp.y() * tmp.y();
+
+    return sqrt(distance);
+}
+
+}  // namespace chatterino

src/util/FunctionEventFilter.cpp

@@ -0,0 +1,17 @@
+#include "FunctionEventFilter.hpp"
+
+namespace chatterino {
+
+FunctionEventFilter::FunctionEventFilter(
+    QObject *parent, std::function<bool(QObject *, QEvent *)> function)
+    : QObject(parent)
+    , function_(std::move(function))
+{
+}
+
+bool FunctionEventFilter::eventFilter(QObject *watched, QEvent *event)
+{
+    return this->function_(watched, event);
+}
+
+}  // namespace chatterino

src/util/FunctionEventFilter.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <QEvent>
+#include <QObject>
+#include <functional>
+
+namespace chatterino {
+
+class FunctionEventFilter : public QObject
+{
+    Q_OBJECT
+
+public:
+    FunctionEventFilter(QObject *parent,
+                        std::function<bool(QObject *, QEvent *)> function);
+
+protected:
+    bool eventFilter(QObject *watched, QEvent *event) override;
+
+private:
+    std::function<bool(QObject *, QEvent *)> function_;
+};
+
+}  // namespace chatterino

src/util/FuzzyConvert.cpp

@@ -0,0 +1,33 @@
+#include "FuzzyConvert.hpp"
+
+#include <QRegularExpression>
+
+namespace chatterino {
+
+int fuzzyToInt(const QString &str, int default_)
+{
+    static auto intFinder = QRegularExpression("[0-9]+");
+
+    auto match = intFinder.match(str);
+    if (match.hasMatch())
+    {
+        return match.captured().toInt();
+    }
+
+    return default_;
+}
+
+float fuzzyToFloat(const QString &str, float default_)
+{
+    static auto floatFinder = QRegularExpression("[0-9]+(\\.[0-9]+)?");
+
+    auto match = floatFinder.match(str);
+    if (match.hasMatch())
+    {
+        return match.captured().toFloat();
+    }
+
+    return default_;
+}
+
+}  // namespace chatterino

src/util/FuzzyConvert.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <QString>
+
+namespace chatterino {
+
+int fuzzyToInt(const QString &str, int default_);
+float fuzzyToFloat(const QString &str, float default_);
+
+}  // namespace chatterino

src/util/Helpers.cpp

@@ -0,0 +1,38 @@
+#include "Helpers.hpp"
+
+#include <QUuid>
+
+namespace chatterino {
+
+QString generateUuid()
+{
+    auto uuid = QUuid::createUuid();
+    return uuid.toString();
+}
+
+QString formatRichLink(const QString &url, bool file)
+{
+    return QString("<a href=\"") + (file ? "file:///" : "") + url + "\">" +
+           url + "</a>";
+}
+
+QString formatRichNamedLink(const QString &url, const QString &name, bool file)
+{
+    return QString("<a href=\"") + (file ? "file:///" : "") + url + "\">" +
+           name + "</a>";
+}
+
+QString shortenString(const QString &str, unsigned maxWidth)
+{
+    auto shortened = QString(str);
+
+    if (str.size() > int(maxWidth))
+    {
+        shortened.resize(int(maxWidth));
+        shortened += "...";
+    }
+
+    return shortened;
+}
+
+}  // namespace chatterino

src/util/Helpers.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <QString>
+
+namespace chatterino {
+
+template <typename... Args>
+auto fS(Args &&... args)
+{
+    return fmt::format(std::forward<Args>(args)...);
+}
+
+QString generateUuid();
+
+QString formatRichLink(const QString &url, bool file = false);
+
+QString formatRichNamedLink(const QString &url, const QString &name,
+                            bool file = false);
+
+QString shortenString(const QString &str, unsigned maxWidth = 50);
+
+}  // namespace chatterino
+
+namespace fmt {
+
+// format_arg for QString
+inline void format_arg(BasicFormatter<char> &f, const char *&, const QString &v)
+{
+    f.writer().write("{}", v.toStdString());
+}
+
+}  // namespace fmt

src/util/LayoutHelper.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <QLayout>
+#include <QWidget>
+#include <boost/variant.hpp>
+
+namespace chatterino {
+
+using LayoutItem = boost::variant<QWidget *, QLayout *>;
+
+template <typename T>
+T *makeLayout(std::initializer_list<LayoutItem> items)
+{
+    auto t = new T;
+
+    for (auto &item : items)
+    {
+        switch (item.which())
+        {
+            case 0:
+                t->addItem(new QWidgetItem(boost::get<QWidget *>(item)));
+                break;
+            case 1:
+                t->addItem(boost::get<QLayout *>(item));
+                break;
+        }
+    }
+
+    return t;
+}
+
+template <typename T, typename With>
+T *makeWidget(With with)
+{
+    auto t = new T;
+
+    with(t);
+
+    return t;
+}
+
+}  // namespace chatterino

src/util/PostToThread.hpp

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <QCoreApplication>
+
+#include <QRunnable>
+#include <QThreadPool>
+
+#include <functional>
+
+#define async_exec(a) \
+    QThreadPool::globalInstance()->start(new LambdaRunnable(a));
+
+namespace chatterino {
+
+class LambdaRunnable : public QRunnable
+{
+public:
+    LambdaRunnable(std::function<void()> action)
+    {
+        this->action_ = action;
+    }
+
+    void run()
+    {
+        this->action_();
+    }
+
+private:
+    std::function<void()> action_;
+};
+
+// Taken from
+// https://stackoverflow.com/questions/21646467/how-to-execute-a-functor-or-a-lambda-in-a-given-thread-in-qt-gcd-style
+// Qt 5/4 - preferred, has least allocations
+template <typename F>
+static void postToThread(F &&fun, QObject *obj = qApp)
+{
+    struct Event : public QEvent {
+        using Fun = typename std::decay<F>::type;
+        Fun fun;
+        Event(Fun &&fun)
+            : QEvent(QEvent::None)
+            , fun(std::move(fun))
+        {
+        }
+        Event(const Fun &fun)
+            : QEvent(QEvent::None)
+            , fun(fun)
+        {
+        }
+        ~Event() override
+        {
+            fun();
+        }
+    };
+    QCoreApplication::postEvent(obj, new Event(std::forward<F>(fun)));
+}
+
+}  // namespace chatterino

src/util/RapidJsonSerializeQString.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <QString>
+#include <pajlada/serialize.hpp>
+
+namespace pajlada {
+
+template <>
+struct Serialize<QString> {
+    static rapidjson::Value get(const QString &value,
+                                rapidjson::Document::AllocatorType &a)
+    {
+        return rapidjson::Value(value.toUtf8(), a);
+    }
+};
+
+template <>
+struct Deserialize<QString> {
+    static QString get(const rapidjson::Value &value, bool *error = nullptr)
+    {
+        if (!value.IsString())
+        {
+            PAJLADA_REPORT_ERROR(error)
+            return QString{};
+        }
+
+        try
+        {
+            return QString::fromUtf8(value.GetString(),
+                                     value.GetStringLength());
+        }
+        catch (const std::exception &)
+        {
+            //            int x = 5;
+        }
+        catch (...)
+        {
+            //            int y = 5;
+        }
+
+        return QString{};
+    }
+};
+
+}  // namespace pajlada

src/util/Shortcut.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <QShortcut>
+#include <QWidget>
+
+namespace chatterino {
+
+template <typename WidgetType, typename Func>
+inline void createShortcut(WidgetType *w, const char *key, Func func)
+{
+    auto s = new QShortcut(QKeySequence(key), w);
+    s->setContext(Qt::WidgetWithChildrenShortcut);
+    QObject::connect(s, &QShortcut::activated, w, func);
+}
+
+template <typename WidgetType, typename Func>
+inline void createWindowShortcut(WidgetType *w, const char *key, Func func)
+{
+    auto s = new QShortcut(QKeySequence(key), w);
+    s->setContext(Qt::WindowShortcut);
+    QObject::connect(s, &QShortcut::activated, w, func);
+}
+
+}  // namespace chatterino

src/util/WindowsHelper.cpp

@@ -0,0 +1,86 @@
+#include "WindowsHelper.hpp"
+
+#include <QSettings>
+
+#ifdef USEWINSDK
+
+namespace chatterino {
+
+typedef enum MONITOR_DPI_TYPE {
+    MDT_EFFECTIVE_DPI = 0,
+    MDT_ANGULAR_DPI = 1,
+    MDT_RAW_DPI = 2,
+    MDT_DEFAULT = MDT_EFFECTIVE_DPI
+} MONITOR_DPI_TYPE;
+
+typedef HRESULT(CALLBACK *GetDpiForMonitor_)(HMONITOR, MONITOR_DPI_TYPE, UINT *,
+                                             UINT *);
+
+boost::optional<UINT> getWindowDpi(HWND hwnd)
+{
+    static HINSTANCE shcore = LoadLibrary(L"Shcore.dll");
+    if (shcore != nullptr)
+    {
+        if (auto getDpiForMonitor =
+                GetDpiForMonitor_(GetProcAddress(shcore, "GetDpiForMonitor")))
+        {
+            HMONITOR monitor =
+                MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
+
+            UINT xScale, yScale;
+
+            getDpiForMonitor(monitor, MDT_DEFAULT, &xScale, &yScale);
+
+            return xScale;
+        }
+    }
+
+    return boost::none;
+}
+
+typedef HRESULT(CALLBACK *OleFlushClipboard_)();
+
+void flushClipboard()
+{
+    static HINSTANCE ole32 = LoadLibrary(L"Ole32.dll");
+    if (ole32 != nullptr)
+    {
+        if (auto oleFlushClipboard =
+                OleFlushClipboard_(GetProcAddress(ole32, "OleFlushClipboard")))
+        {
+            oleFlushClipboard();
+        }
+    }
+}
+
+constexpr const char *runKey =
+    "HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Run";
+
+bool isRegisteredForStartup()
+{
+    QSettings settings(runKey, QSettings::NativeFormat);
+
+    return !settings.value("Chatterino").toString().isEmpty();
+}
+
+void setRegisteredForStartup(bool isRegistered)
+{
+    QSettings settings(runKey, QSettings::NativeFormat);
+
+    if (isRegistered)
+    {
+        auto exePath = QFileInfo(QCoreApplication::applicationFilePath())
+                           .absoluteFilePath()
+                           .replace('/', '\\');
+
+        settings.setValue("Chatterino", "\"" + exePath + "\" --autorun");
+    }
+    else
+    {
+        settings.remove("Chatterino");
+    }
+}
+
+}  // namespace chatterino
+
+#endif

src/util/WindowsHelper.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#ifdef USEWINSDK
+
+#    include <Windows.h>
+#    include <boost/optional.hpp>
+
+namespace chatterino {
+
+boost::optional<UINT> getWindowDpi(HWND hwnd);
+void flushClipboard();
+
+bool isRegisteredForStartup();
+void setRegisteredForStartup(bool isRegistered);
+
+}  // namespace chatterino
+
+#endif