renamed resources to ResourceManager

src/singletons/ircmanager.cpp

@@ -3,10 +3,10 @@
 #include "channel.hpp"
 #include "debug/log.hpp"
 #include "messages/messageparseargs.hpp"
-#include "resources.hpp"
 #include "singletons/accountmanager.hpp"
 #include "singletons/channelmanager.hpp"
 #include "singletons/emotemanager.hpp"
+#include "singletons/resourcemanager.hpp"
 #include "singletons/settingsmanager.hpp"
 #include "singletons/windowmanager.hpp"
 #include "twitch/twitchmessagebuilder.hpp"
@@ -27,7 +27,7 @@ using namespace chatterino::messages;
 
 namespace chatterino {
 
-IrcManager::IrcManager(ChannelManager &_channelManager, Resources &_resources,
+IrcManager::IrcManager(ChannelManager &_channelManager, ResourceManager &_resources,
                        AccountManager &_accountManager)
     : channelManager(_channelManager)
     , resources(_resources)
@@ -70,7 +70,7 @@ IrcManager::IrcManager(ChannelManager &_channelManager, Resources &_resources,
 
 IrcManager &IrcManager::getInstance()
 {
-    static IrcManager instance(ChannelManager::getInstance(), Resources::getInstance(),
+    static IrcManager instance(ChannelManager::getInstance(), ResourceManager::getInstance(),
                                AccountManager::getInstance());
     return instance;
 }

src/singletons/ircmanager.hpp

@@ -19,14 +19,14 @@
 namespace chatterino {
 
 class ChannelManager;
-class Resources;
+class ResourceManager;
 class AccountManager;
 
 class IrcManager : public QObject
 {
     //    Q_OBJECT
 
-    IrcManager(ChannelManager &channelManager, Resources &resources,
+    IrcManager(ChannelManager &channelManager, ResourceManager &resources,
                AccountManager &accountManager);
 
 public:
@@ -55,7 +55,7 @@ public:
 
 private:
     ChannelManager &channelManager;
-    Resources &resources;
+    ResourceManager &resources;
     AccountManager &accountManager;
 
     // variables

src/singletons/resourcemanager.cpp

@@ -0,0 +1,155 @@
+#include "resourcemanager.hpp"
+//#include "singletons/emotemanager.hpp"
+//#include "singletons/windowmanager.hpp"
+#include "util/urlfetch.hpp"
+
+#include <QPixmap>
+
+namespace chatterino {
+
+namespace {
+
+inline messages::LazyLoadedImage *lli(const char *pixmapPath, qreal scale = 1)
+{
+    return new messages::LazyLoadedImage(new QPixmap(pixmapPath), scale);
+}
+
+}  // namespace
+
+ResourceManager::ResourceManager()
+    : badgeStaff(lli(":/images/staff_bg.png"))
+    , badgeAdmin(lli(":/images/admin_bg.png"))
+    , badgeGlobalModerator(lli(":/images/globalmod_bg.png"))
+    , badgeModerator(lli(":/images/moderator_bg.png"))
+    , badgeTurbo(lli(":/images/turbo_bg.png"))
+    , badgeBroadcaster(lli(":/images/broadcaster_bg.png"))
+    , badgePremium(lli(":/images/twitchprime_bg.png"))
+    , badgeVerified(lli(":/images/verified.png", 0.25))
+    , badgeSubscriber(lli(":/images/subscriber.png", 0.25))
+    , badgeCollapsed(lli(":/images/collapse.png"))
+    , cheerBadge100000(lli(":/images/cheer100000"))
+    , cheerBadge10000(lli(":/images/cheer10000"))
+    , cheerBadge5000(lli(":/images/cheer5000"))
+    , cheerBadge1000(lli(":/images/cheer1000"))
+    , cheerBadge100(lli(":/images/cheer100"))
+    , cheerBadge1(lli(":/images/cheer1"))
+    , buttonBan(lli(":/images/button_ban.png", 0.25))
+    , buttonTimeout(lli(":/images/button_timeout.png", 0.25))
+{
+    this->loadDynamicTwitchBadges();
+
+    this->loadChatterinoBadges();
+}
+
+ResourceManager &ResourceManager::getInstance()
+{
+    static ResourceManager instance;
+    return instance;
+}
+
+ResourceManager::BadgeVersion::BadgeVersion(QJsonObject &&root)
+    : badgeImage1x(new messages::LazyLoadedImage(root.value("image_url_1x").toString()))
+    , badgeImage2x(new messages::LazyLoadedImage(root.value("image_url_2x").toString()))
+    , badgeImage4x(new messages::LazyLoadedImage(root.value("image_url_4x").toString()))
+    , description(root.value("description").toString().toStdString())
+    , title(root.value("title").toString().toStdString())
+    , clickAction(root.value("clickAction").toString().toStdString())
+    , clickURL(root.value("clickURL").toString().toStdString())
+{
+}
+
+void ResourceManager::loadChannelData(const QString &roomID, bool bypassCache)
+{
+    qDebug() << "Load channel data for" << roomID;
+
+    QString url = "https://badges.twitch.tv/v1/badges/channels/" + roomID + "/display?language=en";
+
+    util::NetworkRequest req(url);
+    req.setCaller(QThread::currentThread());
+
+    req.getJSON([this, roomID](QJsonObject &root) {
+        QJsonObject sets = root.value("badge_sets").toObject();
+
+        ResourceManager::Channel &ch = this->channels[roomID];
+
+        for (QJsonObject::iterator it = sets.begin(); it != sets.end(); ++it) {
+            QJsonObject versions = it.value().toObject().value("versions").toObject();
+
+            auto &badgeSet = ch.badgeSets[it.key().toStdString()];
+            auto &versionsMap = badgeSet.versions;
+
+            for (auto versionIt = std::begin(versions); versionIt != std::end(versions);
+                 ++versionIt) {
+                std::string kkey = versionIt.key().toStdString();
+                QJsonObject versionObj = versionIt.value().toObject();
+                BadgeVersion v(std::move(versionObj));
+                versionsMap.emplace(kkey, v);
+            }
+        }
+
+        ch.loaded = true;
+    });
+}
+
+void ResourceManager::loadDynamicTwitchBadges()
+{
+    static QString url("https://badges.twitch.tv/v1/badges/global/display?language=en");
+
+    util::NetworkRequest req(url);
+    req.setCaller(QThread::currentThread());
+    req.getJSON([this](QJsonObject &root) {
+        QJsonObject sets = root.value("badge_sets").toObject();
+        qDebug() << "badges fetched";
+        for (QJsonObject::iterator it = sets.begin(); it != sets.end(); ++it) {
+            QJsonObject versions = it.value().toObject().value("versions").toObject();
+
+            auto &badgeSet = this->badgeSets[it.key().toStdString()];
+            auto &versionsMap = badgeSet.versions;
+
+            for (auto versionIt = std::begin(versions); versionIt != std::end(versions);
+                 ++versionIt) {
+                std::string kkey = versionIt.key().toStdString();
+                QJsonObject versionObj = versionIt.value().toObject();
+                BadgeVersion v(std::move(versionObj));
+                versionsMap.emplace(kkey, v);
+            }
+        }
+
+        this->dynamicBadgesLoaded = true;
+    });
+}
+
+void ResourceManager::loadChatterinoBadges()
+{
+    this->chatterinoBadges.clear();
+
+    static QString url("https://fourtf.com/chatterino/badges.json");
+
+    util::NetworkRequest req(url);
+    req.setCaller(QThread::currentThread());
+
+    req.getJSON([this](QJsonObject &root) {
+        QJsonArray badgeVariants = root.value("badges").toArray();
+        qDebug() << "chatbadges fetched";
+        for (QJsonArray::iterator it = badgeVariants.begin(); it != badgeVariants.end(); ++it) {
+            QJsonObject badgeVariant = it->toObject();
+            const std::string badgeVariantTooltip =
+                badgeVariant.value("tooltip").toString().toStdString();
+            const QString &badgeVariantImageURL = badgeVariant.value("image").toString();
+
+            auto badgeVariantPtr = std::make_shared<ChatterinoBadge>(
+                badgeVariantTooltip, new messages::LazyLoadedImage(badgeVariantImageURL));
+
+            QJsonArray badgeVariantUsers = badgeVariant.value("users").toArray();
+
+            for (QJsonArray::iterator it = badgeVariantUsers.begin(); it != badgeVariantUsers.end();
+                 ++it) {
+                const std::string username = it->toString().toStdString();
+                this->chatterinoBadges[username] =
+                    std::shared_ptr<ChatterinoBadge>(badgeVariantPtr);
+            }
+        }
+    });
+}
+
+}  // namespace chatterino

src/singletons/resourcemanager.hpp

@@ -0,0 +1,92 @@
+#pragma once
+
+#include "messages/lazyloadedimage.hpp"
+
+#include <map>
+#include <memory>
+#include <mutex>
+
+namespace chatterino {
+
+class ResourceManager
+{
+    ResourceManager();
+
+public:
+    static ResourceManager &getInstance();
+
+    messages::LazyLoadedImage *badgeStaff;
+    messages::LazyLoadedImage *badgeAdmin;
+    messages::LazyLoadedImage *badgeGlobalModerator;
+    messages::LazyLoadedImage *badgeModerator;
+    messages::LazyLoadedImage *badgeTurbo;
+    messages::LazyLoadedImage *badgeBroadcaster;
+    messages::LazyLoadedImage *badgePremium;
+    messages::LazyLoadedImage *badgeVerified;
+    messages::LazyLoadedImage *badgeSubscriber;
+    messages::LazyLoadedImage *badgeCollapsed;
+
+    messages::LazyLoadedImage *cheerBadge100000;
+    messages::LazyLoadedImage *cheerBadge10000;
+    messages::LazyLoadedImage *cheerBadge5000;
+    messages::LazyLoadedImage *cheerBadge1000;
+    messages::LazyLoadedImage *cheerBadge100;
+    messages::LazyLoadedImage *cheerBadge1;
+
+    std::map<std::string, messages::LazyLoadedImage *> cheerBadges;
+
+    struct BadgeVersion {
+        BadgeVersion() = delete;
+
+        explicit BadgeVersion(QJsonObject &&root);
+
+        messages::LazyLoadedImage *badgeImage1x;
+        messages::LazyLoadedImage *badgeImage2x;
+        messages::LazyLoadedImage *badgeImage4x;
+        std::string description;
+        std::string title;
+        std::string clickAction;
+        std::string clickURL;
+    };
+
+    struct BadgeSet {
+        std::map<std::string, BadgeVersion> versions;
+    };
+
+    std::map<std::string, BadgeSet> badgeSets;
+
+    bool dynamicBadgesLoaded = false;
+
+    messages::LazyLoadedImage *buttonBan;
+    messages::LazyLoadedImage *buttonTimeout;
+
+    struct Channel {
+        std::map<std::string, BadgeSet> badgeSets;
+
+        bool loaded = false;
+    };
+
+    //       channelId
+    std::map<QString, Channel> channels;
+
+    // Chatterino badges
+    struct ChatterinoBadge {
+        ChatterinoBadge(const std::string &_tooltip, messages::LazyLoadedImage *_image)
+            : tooltip(_tooltip)
+            , image(_image)
+        {
+        }
+
+        std::string tooltip;
+        messages::LazyLoadedImage *image;
+    };
+
+    //       username
+    std::map<std::string, std::shared_ptr<ChatterinoBadge>> chatterinoBadges;
+
+    void loadChannelData(const QString &roomID, bool bypassCache = false);
+    void loadDynamicTwitchBadges();
+    void loadChatterinoBadges();
+};
+
+}  // namespace chatterino