pull out chat list into a separate component

abaddon.cpp

@@ -93,8 +93,6 @@ int Abaddon::StartGTK() {
     m_main_window->signal_action_reload_settings().connect(sigc::mem_fun(*this, &Abaddon::ActionReloadSettings));
     m_main_window->signal_action_add_recipient().connect(sigc::mem_fun(*this, &Abaddon::ActionAddRecipient));
 
-    m_main_window->signal_action_show_user_menu().connect(sigc::mem_fun(*this, &Abaddon::ShowUserMenu));
-
     m_main_window->GetChannelList()->signal_action_channel_item_select().connect(sigc::mem_fun(*this, &Abaddon::ActionChannelOpened));
     m_main_window->GetChannelList()->signal_action_guild_leave().connect(sigc::mem_fun(*this, &Abaddon::ActionLeaveGuild));
     m_main_window->GetChannelList()->signal_action_guild_settings().connect(sigc::mem_fun(*this, &Abaddon::ActionGuildSettings));

components/chatlist.cpp

@@ -0,0 +1,278 @@
+#include "chatmessage.hpp"
+#include "chatlist.hpp"
+#include "../abaddon.hpp"
+#include "../constants.hpp"
+
+ChatList::ChatList() {
+    m_list.get_style_context()->add_class("messages");
+
+    set_can_focus(false);
+    set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_ALWAYS);
+    signal_edge_reached().connect(sigc::mem_fun(*this, &ChatList::OnScrollEdgeOvershot));
+
+    auto v = get_vadjustment();
+    v->signal_value_changed().connect([this, v] {
+        m_should_scroll_to_bottom = v->get_upper() - v->get_page_size() <= v->get_value();
+    });
+
+    m_list.signal_size_allocate().connect([this](Gtk::Allocation &) {
+        if (m_should_scroll_to_bottom)
+            ScrollToBottom();
+    });
+
+    m_list.set_focus_hadjustment(get_hadjustment());
+    m_list.set_focus_vadjustment(get_vadjustment());
+    m_list.set_selection_mode(Gtk::SELECTION_NONE);
+    m_list.set_hexpand(true);
+    m_list.set_vexpand(true);
+
+    add(m_list);
+
+    m_list.show();
+}
+
+void ChatList::Clear() {
+    auto children = m_list.get_children();
+    auto it = children.begin();
+    while (it != children.end()) {
+        delete *it;
+        it++;
+    }
+}
+
+void ChatList::SetActiveChannel(Snowflake id) {
+    m_active_channel = id;
+}
+
+void ChatList::ProcessNewMessage(Snowflake id, bool prepend) {
+    auto &discord = Abaddon::Get().GetDiscordClient();
+    if (!discord.IsStarted()) return;
+    const auto data = discord.GetMessage(id);
+    if (!data.has_value()) return;
+
+    // delete preview message when gateway sends it back
+    if (!data->IsPending && data->Nonce.has_value() && data->Author.ID == discord.GetUserData().ID) {
+        for (auto [id, widget] : m_id_to_widget) {
+            if (dynamic_cast<ChatMessageItemContainer *>(widget)->Nonce == *data->Nonce) {
+                RemoveMessageAndHeader(widget);
+                m_id_to_widget.erase(id);
+                break;
+            }
+        }
+    }
+
+    ChatMessageHeader *last_row = nullptr;
+    bool should_attach = false;
+    if (m_num_rows > 0) {
+        if (prepend)
+            last_row = dynamic_cast<ChatMessageHeader *>(m_list.get_row_at_index(0));
+        else
+            last_row = dynamic_cast<ChatMessageHeader *>(m_list.get_row_at_index(m_num_rows - 1));
+
+        if (last_row != nullptr) {
+            const uint64_t diff = std::max(id, last_row->NewestID) - std::min(id, last_row->NewestID);
+            if (last_row->UserID == data->Author.ID && (prepend || (diff < SnowflakeSplitDifference * Snowflake::SecondsInterval)))
+                should_attach = true;
+        }
+    }
+
+    m_num_messages++;
+
+    if (m_should_scroll_to_bottom && !prepend) {
+        while (m_num_messages > MaxMessagesForChatCull) {
+            auto first_it = m_id_to_widget.begin();
+            RemoveMessageAndHeader(first_it->second);
+            m_id_to_widget.erase(first_it);
+        }
+    }
+
+    ChatMessageHeader *header;
+    if (should_attach) {
+        header = last_row;
+    } else {
+        const auto guild_id = *discord.GetChannel(m_active_channel)->GuildID;
+        const auto user_id = data->Author.ID;
+        const auto user = discord.GetUser(user_id);
+        if (!user.has_value()) return;
+
+        header = Gtk::manage(new ChatMessageHeader(&*data));
+        header->signal_action_insert_mention().connect([this, user_id]() {
+            m_signal_action_insert_mention.emit(user_id);
+        });
+
+        header->signal_action_open_user_menu().connect([this, user_id, guild_id](const GdkEvent *event) {
+            m_signal_action_open_user_menu.emit(event, user_id, guild_id);
+        });
+
+        m_num_rows++;
+    }
+
+    auto *content = ChatMessageItemContainer::FromMessage(id);
+    if (content != nullptr) {
+        header->AddContent(content, prepend);
+        m_id_to_widget[id] = content;
+
+        if (!data->IsPending) {
+            content->signal_action_delete().connect([this, id] {
+                m_signal_action_message_delete.emit(m_active_channel, id);
+            });
+            content->signal_action_edit().connect([this, id] {
+                m_signal_action_message_edit.emit(m_active_channel, id);
+            });
+            content->signal_action_reaction_add().connect([this, id](const Glib::ustring &param) {
+                m_signal_action_reaction_add.emit(id, param);
+            });
+            content->signal_action_reaction_remove().connect([this, id](const Glib::ustring &param) {
+                m_signal_action_reaction_remove.emit(id, param);
+            });
+            content->signal_action_channel_click().connect([this](const Snowflake &id) {
+                m_signal_action_channel_click.emit(id);
+            });
+            content->signal_action_reply_to().connect([this](const Snowflake &id) {
+                m_signal_action_reply_to.emit(id);
+            });
+        }
+    }
+
+    header->set_margin_left(5);
+    header->show_all();
+
+    if (!should_attach) {
+        if (prepend)
+            m_list.prepend(*header);
+        else
+            m_list.add(*header);
+    }
+}
+
+void ChatList::DeleteMessage(Snowflake id) {
+    auto widget = m_id_to_widget.find(id);
+    if (widget == m_id_to_widget.end()) return;
+
+    auto *x = dynamic_cast<ChatMessageItemContainer *>(widget->second);
+    if (x != nullptr)
+        x->UpdateAttributes();
+}
+
+void ChatList::RefetchMessage(Snowflake id) {
+    auto widget = m_id_to_widget.find(id);
+    if (widget == m_id_to_widget.end()) return;
+
+    auto *x = dynamic_cast<ChatMessageItemContainer *>(widget->second);
+    if (x != nullptr) {
+        x->UpdateContent();
+        x->UpdateAttributes();
+    }
+}
+
+Snowflake ChatList::GetOldestListedMessage() {
+    return m_id_to_widget.begin()->first;
+}
+
+void ChatList::UpdateMessageReactions(Snowflake id) {
+    auto it = m_id_to_widget.find(id);
+    if (it == m_id_to_widget.end()) return;
+    auto *widget = dynamic_cast<ChatMessageItemContainer *>(it->second);
+    if (widget == nullptr) return;
+    widget->UpdateReactions();
+}
+
+void ChatList::SetFailedByNonce(const std::string &nonce) {
+    for (auto [id, widget] : m_id_to_widget) {
+        if (auto *container = dynamic_cast<ChatMessageItemContainer *>(widget); container->Nonce == nonce) {
+            container->SetFailed();
+            break;
+        }
+    }
+}
+
+std::vector<Snowflake> ChatList::GetRecentAuthors() {
+    const auto &discord = Abaddon::Get().GetDiscordClient();
+    std::vector<Snowflake> ret;
+
+    std::map<Snowflake, Gtk::Widget *> ordered(m_id_to_widget.begin(), m_id_to_widget.end());
+
+    for (auto it = ordered.crbegin(); it != ordered.crend(); it++) {
+        const auto *widget = dynamic_cast<ChatMessageItemContainer *>(it->second);
+        if (widget == nullptr) continue;
+        const auto msg = discord.GetMessage(widget->ID);
+        if (!msg.has_value()) continue;
+        if (std::find(ret.begin(), ret.end(), msg->Author.ID) == ret.end())
+            ret.push_back(msg->Author.ID);
+    }
+
+    const auto chan = discord.GetChannel(m_active_channel);
+    if (chan->GuildID.has_value()) {
+        const auto others = discord.GetUsersInGuild(*chan->GuildID);
+        for (const auto id : others)
+            if (std::find(ret.begin(), ret.end(), id) == ret.end())
+                ret.push_back(id);
+    }
+
+    return ret;
+}
+
+void ChatList::OnScrollEdgeOvershot(Gtk::PositionType pos) {
+    if (pos == Gtk::POS_TOP)
+        m_signal_action_chat_load_history.emit(m_active_channel);
+}
+
+void ChatList::ScrollToBottom() {
+    auto x = get_vadjustment();
+    x->set_value(x->get_upper());
+}
+
+void ChatList::RemoveMessageAndHeader(Gtk::Widget *widget) {
+    auto *header = dynamic_cast<ChatMessageHeader *>(widget->get_ancestor(Gtk::ListBoxRow::get_type()));
+    if (header != nullptr) {
+        if (header->GetChildContent().size() == 1) {
+            m_num_rows--;
+            delete header;
+        } else {
+            delete widget;
+        }
+    } else {
+        delete widget;
+    }
+    m_num_messages--;
+}
+
+ChatList::type_signal_action_message_delete ChatList::signal_action_message_delete() {
+    return m_signal_action_message_delete;
+}
+
+ChatList::type_signal_action_message_edit ChatList::signal_action_message_edit() {
+    return m_signal_action_message_edit;
+}
+
+ChatList::type_signal_action_chat_submit ChatList::signal_action_chat_submit() {
+    return m_signal_action_chat_submit;
+}
+
+ChatList::type_signal_action_chat_load_history ChatList::signal_action_chat_load_history() {
+    return m_signal_action_chat_load_history;
+}
+
+ChatList::type_signal_action_channel_click ChatList::signal_action_channel_click() {
+    return m_signal_action_channel_click;
+}
+
+ChatList::type_signal_action_insert_mention ChatList::signal_action_insert_mention() {
+    return m_signal_action_insert_mention;
+}
+
+ChatList::type_signal_action_open_user_menu ChatList::signal_action_open_user_menu() {
+    return m_signal_action_open_user_menu;
+}
+
+ChatList::type_signal_action_reaction_add ChatList::signal_action_reaction_add() {
+    return m_signal_action_reaction_add;
+}
+
+ChatList::type_signal_action_reaction_remove ChatList::signal_action_reaction_remove() {
+    return m_signal_action_reaction_remove;
+}
+
+ChatList::type_signal_action_reply_to ChatList::signal_action_reply_to() {
+    return m_signal_action_reply_to;
+}

components/chatlist.hpp

@@ -0,0 +1,92 @@
+#pragma once
+#include <gtkmm.h>
+#include <map>
+#include <vector>
+#include "../discord/snowflake.hpp"
+
+class ChatList : public Gtk::ScrolledWindow {
+public:
+    ChatList();
+    void Clear();
+    void SetActiveChannel(Snowflake id);
+    template<typename Iter>
+    void SetMessages(Iter begin, Iter end);
+    template<typename Iter>
+    void PrependMessages(Iter begin, Iter end);
+    void ProcessNewMessage(Snowflake id, bool prepend);
+    void DeleteMessage(Snowflake id);
+    void RefetchMessage(Snowflake id);
+    Snowflake GetOldestListedMessage();
+    void UpdateMessageReactions(Snowflake id);
+    void SetFailedByNonce(const std::string &nonce);
+    std::vector<Snowflake> GetRecentAuthors();
+
+private:
+    void OnScrollEdgeOvershot(Gtk::PositionType pos);
+    void ScrollToBottom();
+    void RemoveMessageAndHeader(Gtk::Widget *widget);
+
+    Snowflake m_active_channel;
+
+    int m_num_messages = 0;
+    int m_num_rows = 0;
+    std::map<Snowflake, Gtk::Widget *> m_id_to_widget;
+
+    bool m_should_scroll_to_bottom = true;
+    Gtk::ListBox m_list;
+
+public:
+    // these are all forwarded by the parent
+    using type_signal_action_message_delete = sigc::signal<void, Snowflake, Snowflake>;
+    using type_signal_action_message_edit = sigc::signal<void, Snowflake, Snowflake>;
+    using type_signal_action_chat_submit = sigc::signal<void, std::string, Snowflake, Snowflake>;
+    using type_signal_action_chat_load_history = sigc::signal<void, Snowflake>;
+    using type_signal_action_channel_click = sigc::signal<void, Snowflake>;
+    using type_signal_action_insert_mention = sigc::signal<void, Snowflake>;
+    using type_signal_action_open_user_menu = sigc::signal<void, const GdkEvent *, Snowflake, Snowflake>;
+    using type_signal_action_reaction_add = sigc::signal<void, Snowflake, Glib::ustring>;
+    using type_signal_action_reaction_remove = sigc::signal<void, Snowflake, Glib::ustring>;
+    using type_signal_action_reply_to = sigc::signal<void, Snowflake>;
+
+    type_signal_action_message_delete signal_action_message_delete();
+    type_signal_action_message_edit signal_action_message_edit();
+    type_signal_action_chat_submit signal_action_chat_submit();
+    type_signal_action_chat_load_history signal_action_chat_load_history();
+    type_signal_action_channel_click signal_action_channel_click();
+    type_signal_action_insert_mention signal_action_insert_mention();
+    type_signal_action_open_user_menu signal_action_open_user_menu();
+    type_signal_action_reaction_add signal_action_reaction_add();
+    type_signal_action_reaction_remove signal_action_reaction_remove();
+    type_signal_action_reply_to signal_action_reply_to();
+
+private:
+    type_signal_action_message_delete m_signal_action_message_delete;
+    type_signal_action_message_edit m_signal_action_message_edit;
+    type_signal_action_chat_submit m_signal_action_chat_submit;
+    type_signal_action_chat_load_history m_signal_action_chat_load_history;
+    type_signal_action_channel_click m_signal_action_channel_click;
+    type_signal_action_insert_mention m_signal_action_insert_mention;
+    type_signal_action_open_user_menu m_signal_action_open_user_menu;
+    type_signal_action_reaction_add m_signal_action_reaction_add;
+    type_signal_action_reaction_remove m_signal_action_reaction_remove;
+    type_signal_action_reply_to m_signal_action_reply_to;
+};
+
+template<typename Iter>
+inline void ChatList::SetMessages(Iter begin, Iter end) {
+    Clear();
+    m_num_rows = 0;
+    m_num_messages = 0;
+    m_id_to_widget.clear();
+
+    for (Iter it = begin; it != end; it++)
+        ProcessNewMessage(*it, false);
+
+    ScrollToBottom();
+}
+
+template<typename Iter>
+inline void ChatList::PrependMessages(Iter begin, Iter end) {
+    for (Iter it = begin; it != end; it++)
+        ProcessNewMessage(*it, true);
+}

components/chatmessage.cpp

@@ -1217,7 +1217,11 @@ std::vector<Gtk::Widget *> ChatMessageHeader::GetChildContent() {
 void ChatMessageHeader::AttachUserMenuHandler(Gtk::Widget &widget) {
     widget.signal_button_press_event().connect([this](GdkEventButton *ev) -> bool {
         if (ev->type == GDK_BUTTON_PRESS && ev->button == GDK_BUTTON_SECONDARY) {
-            m_signal_action_open_user_menu.emit(reinterpret_cast<GdkEvent *>(ev));
+            auto info = Abaddon::Get().GetDiscordClient().GetChannel(ChannelID);
+            Snowflake guild_id;
+            if (info.has_value() && info->GuildID.has_value())
+                guild_id = *info->GuildID;
+            Abaddon::Get().ShowUserMenu(reinterpret_cast<GdkEvent *>(ev), UserID, guild_id);
             return true;
         }
 

components/chatwindow.cpp

@@ -4,15 +4,13 @@
 #include "chatinputindicator.hpp"
 #include "ratelimitindicator.hpp"
 #include "chatinput.hpp"
-
+#include "chatlist.hpp"
-constexpr static uint64_t SnowflakeSplitDifference = 600;
 
 ChatWindow::ChatWindow() {
     Abaddon::Get().GetDiscordClient().signal_message_send_fail().connect(sigc::mem_fun(*this, &ChatWindow::OnMessageSendFail));
 
     m_main = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
-    m_list = Gtk::manage(new Gtk::ListBox);
+    m_chat = Gtk::manage(new ChatList);
-    m_scroll = Gtk::manage(new Gtk::ScrolledWindow);
     m_input = Gtk::manage(new ChatInput);
     m_input_indicator = Gtk::manage(new ChatInputIndicator);
     m_rate_limit_indicator = Gtk::manage(new RateLimitIndicator);
@@ -29,34 +27,10 @@ ChatWindow::ChatWindow() {
     m_input_indicator->show();
 
     m_main->get_style_context()->add_class("messages");
-    m_list->get_style_context()->add_class("messages");
 
     m_main->set_hexpand(true);
     m_main->set_vexpand(true);
 
-    m_scroll->signal_edge_reached().connect(sigc::mem_fun(*this, &ChatWindow::OnScrollEdgeOvershot));
-
-    auto v = m_scroll->get_vadjustment();
-    v->signal_value_changed().connect([this, v] {
-        m_should_scroll_to_bottom = v->get_upper() - v->get_page_size() <= v->get_value();
-    });
-
-    m_scroll->set_can_focus(false);
-    m_scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_ALWAYS);
-    m_scroll->show();
-
-    m_list->signal_size_allocate().connect([this](Gtk::Allocation &) {
-        if (m_should_scroll_to_bottom)
-            ScrollToBottom();
-    });
-
-    m_list->set_selection_mode(Gtk::SELECTION_NONE);
-    m_list->set_hexpand(true);
-    m_list->set_vexpand(true);
-    m_list->set_focus_hadjustment(m_scroll->get_hadjustment());
-    m_list->set_focus_vadjustment(m_scroll->get_vadjustment());
-    m_list->show();
-
     m_input->signal_submit().connect(sigc::mem_fun(*this, &ChatWindow::OnInputSubmit));
     m_input->signal_escape().connect([this]() {
         if (m_is_replying)
@@ -71,41 +45,49 @@ ChatWindow::ChatWindow() {
     });
 
     m_completer.SetGetRecentAuthors([this]() -> auto {
-        const auto &discord = Abaddon::Get().GetDiscordClient();
+        return m_chat->GetRecentAuthors();
-        std::vector<Snowflake> ret;
-
-        std::map<Snowflake, Gtk::Widget *> ordered(m_id_to_widget.begin(), m_id_to_widget.end());
-
-        for (auto it = ordered.crbegin(); it != ordered.crend(); it++) {
-            const auto *widget = dynamic_cast<ChatMessageItemContainer *>(it->second);
-            if (widget == nullptr) continue;
-            const auto msg = discord.GetMessage(widget->ID);
-            if (!msg.has_value()) continue;
-            if (std::find(ret.begin(), ret.end(), msg->Author.ID) == ret.end())
-                ret.push_back(msg->Author.ID);
-        }
-
-        const auto chan = discord.GetChannel(m_active_channel);
-        if (chan->GuildID.has_value()) {
-            const auto others = discord.GetUsersInGuild(*chan->GuildID);
-            for (const auto id : others)
-                if (std::find(ret.begin(), ret.end(), id) == ret.end())
-                    ret.push_back(id);
-        }
-
-        return ret;
     });
 
     m_completer.show();
 
+    m_chat->signal_action_channel_click().connect([this](Snowflake id) {
+        m_signal_action_channel_click.emit(id);
+    });
+    m_chat->signal_action_chat_load_history().connect([this](Snowflake id) {
+        m_signal_action_chat_load_history.emit(id);
+    });
+    m_chat->signal_action_chat_submit().connect([this](const std::string &str, Snowflake channel_id, Snowflake referenced_id) {
+        m_signal_action_chat_submit.emit(str, channel_id, referenced_id);
+    });
+    m_chat->signal_action_insert_mention().connect([this](Snowflake id) {
+        // lowkey gross
+        m_signal_action_insert_mention.emit(id);
+    });
+    m_chat->signal_action_message_delete().connect([this](Snowflake channel_id, Snowflake message_id) {
+        m_signal_action_message_delete.emit(channel_id, message_id);
+    });
+    m_chat->signal_action_message_edit().connect([this](Snowflake channel_id, Snowflake message_id) {
+        m_signal_action_message_edit.emit(channel_id, message_id);
+    });
+    m_chat->signal_action_reaction_add().connect([this](Snowflake id, const Glib::ustring &param) {
+        m_signal_action_reaction_add.emit(id, param);
+    });
+    m_chat->signal_action_reaction_remove().connect([this](Snowflake id, const Glib::ustring &param) {
+        m_signal_action_reaction_remove.emit(id, param);
+    });
+    m_chat->signal_action_reply_to().connect([this](Snowflake id) {
+        StartReplying(id);
+    });
+    m_chat->show();
+
     m_meta->set_hexpand(true);
     m_meta->set_halign(Gtk::ALIGN_FILL);
     m_meta->show();
 
     m_meta->add(*m_input_indicator);
     m_meta->add(*m_rate_limit_indicator);
-    m_scroll->add(*m_list);
+    //m_scroll->add(*m_list);
-    m_main->add(*m_scroll);
+    m_main->add(*m_chat);
     m_main->add(m_completer);
     m_main->add(*m_input);
     m_main->add(*m_meta);
@@ -121,25 +103,12 @@ void ChatWindow::Clear() {
 }
 
 void ChatWindow::SetMessages(const std::set<Snowflake> &msgs) {
-    // empty the listbox
+    m_chat->SetMessages(msgs.begin(), msgs.end());
-    auto children = m_list->get_children();
-    auto it = children.begin();
-    while (it != children.end()) {
-        delete *it;
-        it++;
-    }
-
-    m_num_rows = 0;
-    m_num_messages = 0;
-    m_id_to_widget.clear();
-
-    for (const auto &id : msgs) {
-        ProcessNewMessage(id, false);
-    }
 }
 
 void ChatWindow::SetActiveChannel(Snowflake id) {
     m_active_channel = id;
+    m_chat->SetActiveChannel(id);
     m_input_indicator->SetActiveChannel(id);
     m_rate_limit_indicator->SetActiveChannel(id);
     if (m_is_replying)
@@ -147,33 +116,19 @@ void ChatWindow::SetActiveChannel(Snowflake id) {
 }
 
 void ChatWindow::AddNewMessage(Snowflake id) {
-    ProcessNewMessage(id, false);
+    m_chat->ProcessNewMessage(id, false);
 }
 
 void ChatWindow::DeleteMessage(Snowflake id) {
-    auto widget = m_id_to_widget.find(id);
+    m_chat->DeleteMessage(id);
-    if (widget == m_id_to_widget.end()) return;
-
-    auto *x = dynamic_cast<ChatMessageItemContainer *>(widget->second);
-    if (x != nullptr)
-        x->UpdateAttributes();
 }
 
 void ChatWindow::UpdateMessage(Snowflake id) {
-    auto widget = m_id_to_widget.find(id);
+    m_chat->RefetchMessage(id);
-    if (widget == m_id_to_widget.end()) return;
-
-    auto *x = dynamic_cast<ChatMessageItemContainer *>(widget->second);
-    if (x != nullptr) {
-        x->UpdateContent();
-        x->UpdateAttributes();
-    }
 }
 
 void ChatWindow::AddNewHistory(const std::vector<Snowflake> &id) {
-    std::set<Snowflake> ids(id.begin(), id.end());
+    m_chat->PrependMessages(id.begin(), id.end());
-    for (auto it = ids.rbegin(); it != ids.rend(); it++)
-        ProcessNewMessage(*it, true);
 }
 
 void ChatWindow::InsertChatInput(std::string text) {
@@ -181,15 +136,11 @@ void ChatWindow::InsertChatInput(std::string text) {
 }
 
 Snowflake ChatWindow::GetOldestListedMessage() {
-    return m_id_to_widget.begin()->first;
+    return m_chat->GetOldestListedMessage();
 }
 
 void ChatWindow::UpdateReactions(Snowflake id) {
-    auto it = m_id_to_widget.find(id);
+    m_chat->UpdateMessageReactions(id);
-    if (it == m_id_to_widget.end()) return;
-    auto *widget = dynamic_cast<ChatMessageItemContainer *>(it->second);
-    if (widget == nullptr) return;
-    widget->UpdateReactions();
 }
 
 Snowflake ChatWindow::GetActiveChannel() const {
@@ -221,122 +172,6 @@ bool ChatWindow::OnKeyPressEvent(GdkEventKey *e) {
     return false;
 }
 
-ChatMessageItemContainer *ChatWindow::CreateMessageComponent(Snowflake id) {
-    auto *container = ChatMessageItemContainer::FromMessage(id);
-    return container;
-}
-
-void ChatWindow::RemoveMessageAndHeader(Gtk::Widget *widget) {
-    ChatMessageHeader *header = dynamic_cast<ChatMessageHeader *>(widget->get_ancestor(Gtk::ListBoxRow::get_type()));
-    if (header != nullptr) {
-        if (header->GetChildContent().size() == 1) {
-            m_num_rows--;
-            delete header;
-        } else
-            delete widget;
-    } else
-        delete widget;
-    m_num_messages--;
-}
-
-constexpr static int MaxMessagesForCull = 50; // this has to be 50 cuz that magic number is used in a couple other places and i dont feel like replacing them
-void ChatWindow::ProcessNewMessage(Snowflake id, bool prepend) {
-    const auto &client = Abaddon::Get().GetDiscordClient();
-    if (!client.IsStarted()) return; // e.g. load channel and then dc
-    const auto data = client.GetMessage(id);
-    if (!data.has_value()) return;
-
-    if (!data->IsPending && data->Nonce.has_value() && data->Author.ID == client.GetUserData().ID) {
-        for (auto [id, widget] : m_id_to_widget) {
-            if (dynamic_cast<ChatMessageItemContainer *>(widget)->Nonce == *data->Nonce) {
-                RemoveMessageAndHeader(widget);
-                m_id_to_widget.erase(id);
-                break;
-            }
-        }
-    }
-
-    ChatMessageHeader *last_row = nullptr;
-    bool should_attach = false;
-    if (m_num_rows > 0) {
-        if (prepend)
-            last_row = dynamic_cast<ChatMessageHeader *>(m_list->get_row_at_index(0));
-        else
-            last_row = dynamic_cast<ChatMessageHeader *>(m_list->get_row_at_index(m_num_rows - 1));
-
-        if (last_row != nullptr) {
-            const uint64_t diff = std::max(id, last_row->NewestID) - std::min(id, last_row->NewestID);
-            if (last_row->UserID == data->Author.ID && (prepend || (diff < SnowflakeSplitDifference * Snowflake::SecondsInterval)))
-                should_attach = true;
-        }
-    }
-
-    m_num_messages++;
-
-    if (m_should_scroll_to_bottom && !prepend)
-        while (m_num_messages > MaxMessagesForCull) {
-            auto first_it = m_id_to_widget.begin();
-            RemoveMessageAndHeader(first_it->second);
-            m_id_to_widget.erase(first_it);
-        }
-
-    ChatMessageHeader *header;
-    if (should_attach) {
-        header = last_row;
-    } else {
-        const auto guild_id = *client.GetChannel(m_active_channel)->GuildID;
-        const auto user_id = data->Author.ID;
-        const auto user = client.GetUser(user_id);
-        if (!user.has_value()) return;
-
-        header = Gtk::manage(new ChatMessageHeader(&*data));
-        header->signal_action_insert_mention().connect([this, user_id]() {
-            m_signal_action_insert_mention.emit(user_id);
-        });
-
-        header->signal_action_open_user_menu().connect([this, user_id, guild_id](const GdkEvent *event) {
-            m_signal_action_open_user_menu.emit(event, user_id, guild_id);
-        });
-
-        m_num_rows++;
-    }
-
-    auto *content = CreateMessageComponent(id);
-    if (content != nullptr) {
-        header->AddContent(content, prepend);
-        m_id_to_widget[id] = content;
-
-        if (!data->IsPending) {
-            content->signal_action_delete().connect([this, id] {
-                m_signal_action_message_delete.emit(m_active_channel, id);
-            });
-            content->signal_action_edit().connect([this, id] {
-                m_signal_action_message_edit.emit(m_active_channel, id);
-            });
-            content->signal_action_reaction_add().connect([this, id](const Glib::ustring &param) {
-                m_signal_action_reaction_add.emit(id, param);
-            });
-            content->signal_action_reaction_remove().connect([this, id](const Glib::ustring &param) {
-                m_signal_action_reaction_remove.emit(id, param);
-            });
-            content->signal_action_channel_click().connect([this](const Snowflake &id) {
-                m_signal_action_channel_click.emit(id);
-            });
-            content->signal_action_reply_to().connect(sigc::mem_fun(*this, &ChatWindow::StartReplying));
-        }
-    }
-
-    header->set_margin_left(5);
-    header->show_all();
-
-    if (!should_attach) {
-        if (prepend)
-            m_list->prepend(*header);
-        else
-            m_list->add(*header);
-    }
-}
-
 void ChatWindow::StartReplying(Snowflake message_id) {
     const auto &discord = Abaddon::Get().GetDiscordClient();
     const auto message = *discord.GetMessage(message_id);
@@ -363,18 +198,8 @@ void ChatWindow::OnScrollEdgeOvershot(Gtk::PositionType pos) {
         m_signal_action_chat_load_history.emit(m_active_channel);
 }
 
-void ChatWindow::ScrollToBottom() {
-    auto x = m_scroll->get_vadjustment();
-    x->set_value(x->get_upper());
-}
-
 void ChatWindow::OnMessageSendFail(const std::string &nonce, float retry_after) {
-    for (auto [id, widget] : m_id_to_widget) {
+    m_chat->SetFailedByNonce(nonce);
-        if (auto *container = dynamic_cast<ChatMessageItemContainer *>(widget); container->Nonce == nonce) {
-            container->SetFailed();
-            break;
-        }
-    }
 }
 
 ChatWindow::type_signal_action_message_delete ChatWindow::signal_action_message_delete() {
@@ -401,10 +226,6 @@ ChatWindow::type_signal_action_insert_mention ChatWindow::signal_action_insert_m
     return m_signal_action_insert_mention;
 }
 
-ChatWindow::type_signal_action_open_user_menu ChatWindow::signal_action_open_user_menu() {
-    return m_signal_action_open_user_menu;
-}
-
 ChatWindow::type_signal_action_reaction_add ChatWindow::signal_action_reaction_add() {
     return m_signal_action_reaction_add;
 }

components/chatwindow.hpp

@@ -10,6 +10,7 @@ class ChatMessageItemContainer;
 class ChatInput;
 class ChatInputIndicator;
 class RateLimitIndicator;
+class ChatList;
 class ChatWindow {
 public:
     ChatWindow();
@@ -29,19 +30,12 @@ public:
     void UpdateReactions(Snowflake id);
 
 protected:
-    ChatMessageItemContainer *CreateMessageComponent(Snowflake id); // to be inserted into header's content box
-    void ProcessNewMessage(Snowflake id, bool prepend);             // creates and adds components
-
     bool m_is_replying = false;
     Snowflake m_replying_to;
 
     void StartReplying(Snowflake message_id);
     void StopReplying();
 
-    int m_num_messages = 0;
-    int m_num_rows = 0;
-    std::map<Snowflake, Gtk::Widget *> m_id_to_widget;
-
     Snowflake m_active_channel;
 
     bool OnInputSubmit(const Glib::ustring &text);
@@ -49,16 +43,13 @@ protected:
     bool OnKeyPressEvent(GdkEventKey *e);
     void OnScrollEdgeOvershot(Gtk::PositionType pos);
 
-    void RemoveMessageAndHeader(Gtk::Widget *widget);
-
-    void ScrollToBottom();
-    bool m_should_scroll_to_bottom = true;
-
     void OnMessageSendFail(const std::string &nonce, float retry_after);
 
     Gtk::Box *m_main;
-    Gtk::ListBox *m_list;
+    //Gtk::ListBox *m_list;
-    Gtk::ScrolledWindow *m_scroll;
+    //Gtk::ScrolledWindow *m_scroll;
+
+    ChatList *m_chat;
 
     ChatInput *m_input;
 
@@ -74,7 +65,6 @@ public:
     typedef sigc::signal<void, Snowflake> type_signal_action_chat_load_history;
     typedef sigc::signal<void, Snowflake> type_signal_action_channel_click;
     typedef sigc::signal<void, Snowflake> type_signal_action_insert_mention;
-    typedef sigc::signal<void, const GdkEvent *, Snowflake, Snowflake> type_signal_action_open_user_menu;
     typedef sigc::signal<void, Snowflake, Glib::ustring> type_signal_action_reaction_add;
     typedef sigc::signal<void, Snowflake, Glib::ustring> type_signal_action_reaction_remove;
 
@@ -84,7 +74,6 @@ public:
     type_signal_action_chat_load_history signal_action_chat_load_history();
     type_signal_action_channel_click signal_action_channel_click();
     type_signal_action_insert_mention signal_action_insert_mention();
-    type_signal_action_open_user_menu signal_action_open_user_menu();
     type_signal_action_reaction_add signal_action_reaction_add();
     type_signal_action_reaction_remove signal_action_reaction_remove();
 
@@ -95,7 +84,6 @@ private:
     type_signal_action_chat_load_history m_signal_action_chat_load_history;
     type_signal_action_channel_click m_signal_action_channel_click;
     type_signal_action_insert_mention m_signal_action_insert_mention;
-    type_signal_action_open_user_menu m_signal_action_open_user_menu;
     type_signal_action_reaction_add m_signal_action_reaction_add;
     type_signal_action_reaction_remove m_signal_action_reaction_remove;
 };

components/memberlist.cpp

@@ -210,14 +210,10 @@ void MemberList::UpdateMemberList() {
 void MemberList::AttachUserMenuHandler(Gtk::ListBoxRow *row, Snowflake id) {
     row->signal_button_press_event().connect([this, row, id](GdkEventButton *e) -> bool {
         if (e->type == GDK_BUTTON_PRESS && e->button == GDK_BUTTON_SECONDARY) {
-            m_signal_action_show_user_menu.emit(reinterpret_cast<const GdkEvent *>(e), id, m_guild_id);
+            Abaddon::Get().ShowUserMenu(reinterpret_cast<const GdkEvent *>(e), id, m_guild_id);
             return true;
         }
 
         return false;
     });
 }
-
-MemberList::type_signal_action_show_user_menu MemberList::signal_action_show_user_menu() {
-    return m_signal_action_show_user_menu;
-}

components/memberlist.hpp

@@ -41,12 +41,4 @@ private:
     Snowflake m_chan_id;
 
     std::unordered_map<Snowflake, Gtk::ListBoxRow *> m_id_to_row;
-
-public:
-    typedef sigc::signal<void, const GdkEvent *, Snowflake, Snowflake> type_signal_action_show_user_menu;
-
-    type_signal_action_show_user_menu signal_action_show_user_menu();
-
-private:
-    type_signal_action_show_user_menu m_signal_action_show_user_menu;
 };

constants.hpp

@@ -0,0 +1,4 @@
+#include <cstdint>
+
+constexpr static uint64_t SnowflakeSplitDifference = 600;
+constexpr static int MaxMessagesForChatCull = 50; // this has to be 50 (for now) cuz that magic number is used in a couple other places and i dont feel like replacing them

windows/mainwindow.cpp

@@ -104,14 +104,6 @@ MainWindow::MainWindow()
     auto *member_list = m_members.GetRoot();
     auto *chat = m_chat.GetRoot();
 
-    m_members.signal_action_show_user_menu().connect([this](const GdkEvent *event, Snowflake id, Snowflake guild_id) {
-        m_signal_action_show_user_menu.emit(event, id, guild_id);
-    });
-
-    m_chat.signal_action_open_user_menu().connect([this](const GdkEvent *event, Snowflake id, Snowflake guild_id) {
-        m_signal_action_show_user_menu.emit(event, id, guild_id);
-    });
-
     chat->set_vexpand(true);
     chat->set_hexpand(true);
     chat->show();
@@ -318,10 +310,6 @@ MainWindow::type_signal_action_set_status MainWindow::signal_action_set_status()
     return m_signal_action_set_status;
 }
 
-MainWindow::type_signal_action_show_user_menu MainWindow::signal_action_show_user_menu() {
-    return m_signal_action_show_user_menu;
-}
-
 MainWindow::type_signal_action_reload_settings MainWindow::signal_action_reload_settings() {
     return m_signal_action_reload_settings;
 }

windows/mainwindow.hpp

@@ -41,7 +41,6 @@ public:
     typedef sigc::signal<void> type_signal_action_reload_css;
     typedef sigc::signal<void> type_signal_action_join_guild;
     typedef sigc::signal<void> type_signal_action_set_status;
-    typedef sigc::signal<void, const GdkEvent *, Snowflake, Snowflake> type_signal_action_show_user_menu;
     typedef sigc::signal<void> type_signal_action_reload_settings;
     typedef sigc::signal<void, Snowflake> type_signal_action_add_recipient; // channel id
 
@@ -51,7 +50,6 @@ public:
     type_signal_action_reload_css signal_action_reload_css();
     type_signal_action_join_guild signal_action_join_guild();
     type_signal_action_set_status signal_action_set_status();
-    type_signal_action_show_user_menu signal_action_show_user_menu();
     type_signal_action_reload_settings signal_action_reload_settings();
     type_signal_action_add_recipient signal_action_add_recipient();
 
@@ -62,7 +60,6 @@ protected:
     type_signal_action_reload_css m_signal_action_reload_css;
     type_signal_action_join_guild m_signal_action_join_guild;
     type_signal_action_set_status m_signal_action_set_status;
-    type_signal_action_show_user_menu m_signal_action_show_user_menu;
     type_signal_action_reload_settings m_signal_action_reload_settings;
     type_signal_action_add_recipient m_signal_action_add_recipient;