Add custom image functionality for inline mod buttons.

src/controllers/moderationactions/ModerationAction.cpp

@@ -6,28 +6,11 @@
 #include "singletons/Resources.hpp"
 
 #include <QRegularExpression>
+#include <QUrl>
 
 namespace chatterino {
 
-// ModerationAction::ModerationAction(Image *_image, const QString &_action)
-//    : _isImage(true)
-//    , image(_image)
-//    , action(_action)
-//{
-//}
-
-// ModerationAction::ModerationAction(const QString &_line1, const QString
-// &_line2,
-//                                   const QString &_action)
-//    : _isImage(false)
-//    , image(nullptr)
-//    , line1(_line1)
-//    , line2(_line2)
-//    , action(_action)
-//{
-//}
-
-ModerationAction::ModerationAction(const QString &action)
+ModerationAction::ModerationAction(const QString &action, const QUrl &iconPath)
     : action_(action)
 {
     static QRegularExpression replaceRegex("[!/.]");
@@ -99,21 +82,14 @@ ModerationAction::ModerationAction(const QString &action)
             }
             this->line2_ = "w";
         }
-
-        // line1 = this->line1_;
-        // line2 = this->line2_;
-        // } else {
-        //     this->_moderationActions.emplace_back(getResources().buttonTimeout,
-        //     str);
-        // }
     }
     else if (action.startsWith("/ban "))
     {
-        this->imageToLoad_ = 1;
+        this->builtInImageToLoad_ = BuiltInImage::Ban;
     }
     else if (action.startsWith("/delete "))
     {
-        this->imageToLoad_ = 2;
+        this->builtInImageToLoad_ = BuiltInImage::TrashCan;
     }
     else
     {
@@ -124,6 +100,12 @@ ModerationAction::ModerationAction(const QString &action)
         this->line1_ = xD.mid(0, 2);
         this->line2_ = xD.mid(2, 2);
     }
+
+    if (!iconPath.isEmpty())
+    {
+        this->builtInImageToLoad_ = BuiltInImage::None;
+        this->iconPath_ = iconPath;
+    }
 }
 
 bool ModerationAction::operator==(const ModerationAction &other) const
@@ -140,18 +122,18 @@ const std::optional<ImagePtr> &ModerationAction::getImage() const
 {
     assertInGuiThread();
 
-    if (this->imageToLoad_ != 0)
+    if (this->builtInImageToLoad_ == BuiltInImage::Ban)
     {
-        if (this->imageToLoad_ == 1)
-        {
-            this->image_ =
-                Image::fromResourcePixmap(getResources().buttons.ban);
-        }
-        else if (this->imageToLoad_ == 2)
-        {
-            this->image_ =
-                Image::fromResourcePixmap(getResources().buttons.trashCan);
-        }
+        this->image_ = Image::fromResourcePixmap(getResources().buttons.ban);
+    }
+    else if (this->builtInImageToLoad_ == BuiltInImage::TrashCan)
+    {
+        this->image_ =
+            Image::fromResourcePixmap(getResources().buttons.trashCan);
+    }
+    else if (!this->iconPath_.isEmpty())
+    {
+        this->image_ = Image::fromUrl({this->iconPath_.toString()});
     }
 
     return this->image_;

src/controllers/moderationactions/ModerationAction.hpp

@@ -16,7 +16,7 @@ using ImagePtr = std::shared_ptr<Image>;
 class ModerationAction
 {
 public:
-    ModerationAction(const QString &action);
+    ModerationAction(const QString &action, const QUrl &iconPath = {});
 
     bool operator==(const ModerationAction &other) const;
 
@@ -26,12 +26,25 @@ class ModerationAction
     const QString &getLine2() const;
     const QString &getAction() const;
 
+    const QUrl &iconPath() const
+    {
+        return this->iconPath_;
+    };
+
 private:
     mutable std::optional<ImagePtr> image_;
     QString line1_;
     QString line2_;
     QString action_;
-    int imageToLoad_{};
+
+    enum class BuiltInImage {
+        None,
+        Ban,
+        TrashCan,
+    };
+    BuiltInImage builtInImageToLoad_{};
+
+    QUrl iconPath_;
 };
 
 }  // namespace chatterino
@@ -46,6 +59,7 @@ struct Serialize<chatterino::ModerationAction> {
         rapidjson::Value ret(rapidjson::kObjectType);
 
         chatterino::rj::set(ret, "pattern", value.getAction(), a);
+        chatterino::rj::set(ret, "icon", value.iconPath().toString(), a);
 
         return ret;
     }
@@ -63,10 +77,12 @@ struct Deserialize<chatterino::ModerationAction> {
         }
 
         QString pattern;
-
         chatterino::rj::getSafe(value, "pattern", pattern);
 
-        return chatterino::ModerationAction(pattern);
+        QString icon;
+        chatterino::rj::getSafe(value, "icon", icon);
+
+        return chatterino::ModerationAction(pattern, QUrl(icon));
     }
 };
 

src/controllers/moderationactions/ModerationActionModel.cpp

@@ -1,28 +1,89 @@
 #include "controllers/moderationactions/ModerationActionModel.hpp"
 
+#include "Application.hpp"
+#include "common/network/NetworkRequest.hpp"
+#include "common/network/NetworkResult.hpp"
+#include "common/QLogging.hpp"
 #include "controllers/moderationactions/ModerationAction.hpp"
+#include "messages/Image.hpp"
 #include "util/StandardItemHelper.hpp"
 
+#include <QIcon>
+#include <QLoggingCategory>
+#include <QPixmap>
+namespace {
+
+using namespace chatterino;
+
+// This was copied from TwitchBadges::loadEmoteImage and modified.
+void loadEmoteImage(const ImagePtr &image,
+                    std::function<void(QPixmap)> &&callback)
+{
+    auto url = image->url().string;
+    NetworkRequest(url)
+        .concurrent()
+        .cache()
+        .onSuccess(
+            [callback = std::move(callback), url](const NetworkResult &result) {
+                auto data = result.getData();
+
+                // const cast since we are only reading from it
+                QBuffer buffer(const_cast<QByteArray *>(&data));
+                buffer.open(QIODevice::ReadOnly);
+                QImageReader reader(&buffer);
+
+                if (!reader.canRead() || reader.size().isEmpty())
+                {
+                    qCWarning(chatterinoSettings)
+                        << "Can't read mod action image at" << url << ":"
+                        << reader.errorString();
+                    return;
+                }
+
+                QImage image = reader.read();
+                if (image.isNull())
+                {
+                    qCWarning(chatterinoSettings)
+                        << "Failed reading mod action image at" << url << ":"
+                        << reader.errorString();
+                    return;
+                }
+
+                callback(QPixmap::fromImage(image));
+            })
+        .execute();
+}
+}  // namespace
+
 namespace chatterino {
 
 // commandmodel
 ModerationActionModel ::ModerationActionModel(QObject *parent)
-    : SignalVectorModel<ModerationAction>(1, parent)
+    : SignalVectorModel<ModerationAction>(2, parent)
 {
 }
 
 // turn a vector item into a model row
 ModerationAction ModerationActionModel::getItemFromRow(
     std::vector<QStandardItem *> &row, const ModerationAction &original)
 {
-    return ModerationAction(row[0]->data(Qt::DisplayRole).toString());
+    return ModerationAction(
+        row[Column::Command]->data(Qt::DisplayRole).toString(),
+        row[Column::Icon]->data(Qt::UserRole).toString());
 }
 
 // turns a row in the model into a vector item
 void ModerationActionModel::getRowFromItem(const ModerationAction &item,
                                            std::vector<QStandardItem *> &row)
 {
-    setStringItem(row[0], item.getAction());
+    setStringItem(row[Column::Command], item.getAction());
+    setFilePathItem(row[Column::Icon], item.iconPath());
+    if (!item.iconPath().isEmpty())
+    {
+        loadEmoteImage(*item.getImage(), [row](const QPixmap &pixmap) {
+            row[Column::Icon]->setData(pixmap, Qt::DecorationRole);
+        });
+    }
 }
 
 }  // namespace chatterino

src/controllers/moderationactions/ModerationActionModel.hpp

@@ -13,6 +13,11 @@ class ModerationActionModel : public SignalVectorModel<ModerationAction>
 public:
     explicit ModerationActionModel(QObject *parent);
 
+    enum Column {
+        Command,
+        Icon,
+    };
+
 protected:
     // turn a vector item into a model row
     ModerationAction getItemFromRow(std::vector<QStandardItem *> &row,

src/widgets/settingspages/ModerationPage.cpp

@@ -212,6 +212,19 @@ ModerationPage::ModerationPage()
             QHeaderView::Fixed);
         view->getTableView()->horizontalHeader()->setSectionResizeMode(
             0, QHeaderView::Stretch);
+        QObject::connect(
+            view->getTableView(), &QTableView::clicked,
+            [this, view](const QModelIndex &clicked) {
+                if (clicked.column() == ModerationActionModel::Column::Icon)
+                {
+                    auto fileUrl = QFileDialog::getOpenFileUrl(
+                        this, tr("Open Image"), QUrl(),
+                        tr("Image Files (*.png)"));
+                    view->getModel()->setData(clicked, fileUrl, Qt::UserRole);
+                    view->getModel()->setData(clicked, fileUrl.fileName(),
+                                              Qt::DisplayRole);
+                }
+            });
 
         // We can safely ignore this signal connection since we own the view
         std::ignore = view->addButtonPressed.connect([] {

src/widgets/settingspages/ModerationPage.hpp

@@ -11,6 +11,7 @@ namespace chatterino {
 
 template <typename X>
 class LayoutCreator;
+class EditableModelView;
 
 class ModerationPage : public SettingsPage
 {
@@ -27,6 +28,8 @@ class ModerationPage : public SettingsPage
 
     std::vector<QLineEdit *> durationInputs_;
     std::vector<QComboBox *> unitInputs_;
+
+    void openImageDialog(const QModelIndex &clicked, EditableModelView *view);
 };
 
 }  // namespace chatterino