scroll up to load more messages

abaddon.cpp

@@ -121,7 +121,7 @@ void Abaddon::ActionMoveGuildUp(Snowflake id) {
     std::swap(*left, *target_iter);
 
     std::vector<Snowflake> new_sort;
-    for (const auto& x : order)
+    for (const auto &x : order)
         new_sort.push_back(x.first);
 
     m_discord.UpdateSettingsGuildPositions(new_sort);
@@ -156,14 +156,39 @@ void Abaddon::ActionListChannelItemClick(Snowflake id) {
     m_main_window->UpdateChatActiveChannel(id);
     if (m_channels_requested.find(id) == m_channels_requested.end()) {
         m_discord.FetchMessagesInChannel(id, [this, id](const std::vector<MessageData> &msgs) {
-            m_channels_requested.insert(id);
+            if (msgs.size() > 0) {
+                m_oldest_listed_message[id] = msgs.back().ID;
                 m_main_window->UpdateChatWindowContents();
+            }
+
+            m_channels_requested.insert(id);
         });
     } else {
         m_main_window->UpdateChatWindowContents();
     }
 }
 
+void Abaddon::ActionChatLoadHistory(Snowflake id) {
+    if (m_channels_history_loaded.find(id) != m_channels_history_loaded.end())
+        return;
+
+    if (m_channels_history_loading.find(id) != m_channels_history_loading.end())
+        return;
+
+    m_channels_history_loading.insert(id);
+
+    m_discord.FetchMessagesInChannelBefore(id, m_oldest_listed_message[id], [this, id](const std::vector<MessageData> &msgs) {
+        m_channels_history_loading.erase(id);
+
+        if (msgs.size() == 0) {
+            m_channels_history_loaded.insert(id);
+        } else {
+            m_oldest_listed_message[id] = msgs.back().ID;
+            m_main_window->UpdateChatPrependHistory(msgs);
+        }
+    });
+}
+
 void Abaddon::ActionChatInputSubmit(std::string msg, Snowflake channel) {
     m_discord.SendChatMessage(msg, channel);
 }

abaddon.hpp

@@ -26,6 +26,7 @@ public:
     void ActionCopyGuildID(Snowflake id);
     void ActionListChannelItemClick(Snowflake id);
     void ActionChatInputSubmit(std::string msg, Snowflake channel);
+    void ActionChatLoadHistory(Snowflake id);
 
     std::string GetDiscordToken() const;
     bool IsDiscordActive() const;
@@ -38,7 +39,11 @@ public:
 private:
     DiscordClient m_discord;
     std::string m_discord_token;
+    // todo make these map snowflake to attribs
     std::unordered_set<Snowflake> m_channels_requested;
+    std::unordered_set<Snowflake> m_channels_history_loaded;
+    std::unordered_map<Snowflake, Snowflake> m_oldest_listed_message;
+    std::unordered_set<Snowflake> m_channels_history_loading;
 
     mutable std::mutex m_mutex;
     Glib::RefPtr<Gtk::Application> m_gtk_app;

components/chatmessage.cpp

@@ -57,3 +57,8 @@ void ChatMessageTextItem::AppendNewContent(std::string content) {
     auto buf = m_text->get_buffer();
     buf->set_text(buf->get_text() + "\n" + content);
 }
+
+void ChatMessageTextItem::PrependNewContent(std::string content) {
+    auto buf = m_text->get_buffer();
+    buf->set_text(content + "\n" + buf->get_text());
+}

components/chatmessage.hpp

@@ -17,6 +17,7 @@ class ChatMessageTextItem : public ChatMessageItem {
 public:
     ChatMessageTextItem(const MessageData *data);
     void AppendNewContent(std::string content);
+    void PrependNewContent(std::string content);
 
 protected:
     Gtk::Box *m_main_box;

components/chatwindow.cpp

@@ -5,6 +5,7 @@
 ChatWindow::ChatWindow() {
     m_message_set_dispatch.connect(sigc::mem_fun(*this, &ChatWindow::SetMessagesInternal));
     m_new_message_dispatch.connect(sigc::mem_fun(*this, &ChatWindow::AddNewMessageInternal));
+    m_new_history_dispatch.connect(sigc::mem_fun(*this, &ChatWindow::AddNewHistoryInternal));
 
     m_main = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
     m_listbox = Gtk::manage(new Gtk::ListBox);
@@ -19,11 +20,19 @@ ChatWindow::ChatWindow() {
     m_main->set_vexpand(true);
     m_main->show();
 
+    m_scroll->signal_edge_reached().connect(sigc::mem_fun(*this, &ChatWindow::on_scroll_edge_overshot));
+
+    auto vadj = m_scroll->get_vadjustment();
+    vadj->signal_value_changed().connect([&, vadj]() {
+        m_scroll_to_bottom = vadj->get_upper() - vadj->get_page_size() <= vadj->get_value();
+    });
+
     m_scroll->set_can_focus(false);
     m_scroll->set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_ALWAYS);
     m_scroll->show();
 
     m_listbox->signal_size_allocate().connect([this](Gtk::Allocation &) {
+        if (m_scroll_to_bottom)
             ScrollToBottom();
     });
 
@@ -96,10 +105,13 @@ ChatMessageItem *ChatWindow::CreateChatEntryComponent(const MessageData *data) {
     return item;
 }
 
-void ChatWindow::ProcessMessage(const MessageData *data) {
+void ChatWindow::ProcessMessage(const MessageData *data, bool prepend) {
     auto create_new_row = [&]() {
         auto *item = CreateChatEntryComponent(data);
         if (item != nullptr) {
+            if (prepend)
+                m_listbox->prepend(*item);
+            else
                 m_listbox->add(*item);
             m_num_rows++;
         }
@@ -107,7 +119,11 @@ void ChatWindow::ProcessMessage(const MessageData *data) {
 
     // if the last row's message's author is the same as the new one's, then append the new message content to the last row
     if (m_num_rows > 0) {
-        auto *item = dynamic_cast<ChatMessageItem *>(m_listbox->get_row_at_index(m_num_rows - 1));
+        ChatMessageItem *item;
+        if (prepend)
+            item = dynamic_cast<ChatMessageItem *>(m_listbox->get_row_at_index(0));
+        else
+            item = dynamic_cast<ChatMessageItem *>(m_listbox->get_row_at_index(m_num_rows - 1));
         assert(item != nullptr);
         auto *previous_data = m_abaddon->GetDiscordClient().GetMessage(item->ID);
 
@@ -116,6 +132,9 @@ void ChatWindow::ProcessMessage(const MessageData *data) {
 
         if ((data->Author.ID == previous_data->Author.ID) && (new_type == old_type && new_type == ChatDisplayType::Text)) {
             auto *text_item = dynamic_cast<ChatMessageTextItem *>(item);
+            if (prepend)
+                text_item->PrependNewContent(data->Content);
+            else
                 text_item->AppendNewContent(data->Content);
         } else {
             create_new_row();
@@ -143,6 +162,11 @@ bool ChatWindow::on_key_press_event(GdkEventKey *e) {
     return false;
 }
 
+void ChatWindow::on_scroll_edge_overshot(Gtk::PositionType pos) {
+    if (pos == Gtk::POS_TOP)
+        m_abaddon->ActionChatLoadHistory(m_active_channel);
+}
+
 void ChatWindow::SetMessages(std::unordered_set<const MessageData *> msgs) {
     std::scoped_lock<std::mutex> guard(m_update_mutex);
     m_message_set_queue.push(msgs);
@@ -155,6 +179,15 @@ void ChatWindow::AddNewMessage(Snowflake id) {
     m_new_message_dispatch.emit();
 }
 
+void ChatWindow::AddNewHistory(const std::vector<MessageData> &msgs) {
+    std::scoped_lock<std::mutex> guard(m_update_mutex);
+    std::vector<Snowflake> x;
+    for (const auto &msg : msgs)
+        x.push_back(msg.ID);
+    m_new_history_queue.push(x);
+    m_new_history_dispatch.emit();
+}
+
 void ChatWindow::ClearMessages() {
     std::scoped_lock<std::mutex> guard(m_update_mutex);
     m_message_set_queue.push(std::unordered_set<const MessageData *>());
@@ -178,6 +211,25 @@ void ChatWindow::AddNewMessageInternal() {
     ProcessMessage(data);
 }
 
+// todo this keeps the scrollbar at the top
+void ChatWindow::AddNewHistoryInternal() {
+    std::set<Snowflake> msgs;
+    {
+        std::scoped_lock<std::mutex> guard(m_update_mutex);
+        auto vec = m_new_history_queue.front();
+        msgs = std::set<Snowflake>(vec.begin(), vec.end());
+    }
+
+    for (auto it = msgs.rbegin(); it != msgs.rend(); it++) {
+        ProcessMessage(m_abaddon->GetDiscordClient().GetMessage(*it), true);
+    }
+
+    {
+        std::scoped_lock<std::mutex> guard(m_update_mutex);
+        m_new_history_queue.pop();
+    }
+}
+
 void ChatWindow::SetMessagesInternal() {
     auto children = m_listbox->get_children();
     auto it = children.begin();

components/chatwindow.hpp

@@ -16,24 +16,31 @@ public:
     Snowflake GetActiveChannel() const;
     void SetMessages(std::unordered_set<const MessageData *> msgs);
     void AddNewMessage(Snowflake id);
+    void AddNewHistory(const std::vector<MessageData> &msgs);
     void ClearMessages();
 
 protected:
     void ScrollToBottom();
     void SetMessagesInternal();
     void AddNewMessageInternal();
+    void AddNewHistoryInternal();
     ChatDisplayType GetMessageDisplayType(const MessageData *data);
     ChatMessageItem *CreateChatEntryComponentText(const MessageData *data);
     ChatMessageItem *CreateChatEntryComponent(const MessageData *data);
-    void ProcessMessage(const MessageData *data);
+    void ProcessMessage(const MessageData *data, bool prepend = false);
     int m_num_rows = 0; // youd think thered be a Gtk::ListBox::get_row_count or something but nope
 
+    bool m_scroll_to_bottom = true;
+
     bool on_key_press_event(GdkEventKey *e);
+    void on_scroll_edge_overshot(Gtk::PositionType pos);
 
     Glib::Dispatcher m_message_set_dispatch;
     std::queue<std::unordered_set<const MessageData *>> m_message_set_queue;
     Glib::Dispatcher m_new_message_dispatch;
     std::queue<Snowflake> m_new_message_queue;
+    Glib::Dispatcher m_new_history_dispatch;
+    std::queue<std::vector<Snowflake>> m_new_history_queue;
     std::mutex m_update_mutex;
 
     Snowflake m_active_channel;

discord/discord.cpp

@@ -129,6 +129,18 @@ void DiscordClient::FetchMessagesInChannel(Snowflake id, std::function<void(cons
     });
 }
 
+void DiscordClient::FetchMessagesInChannelBefore(Snowflake channel_id, Snowflake before_id, std::function<void(const std::vector<MessageData> &)> cb) {
+    std::string path = "/channels/" + std::to_string(channel_id) + "/messages?limit=50&before=" + std::to_string(before_id);
+    m_http.MakeGET(path, [this, channel_id, cb](cpr::Response r) {
+        std::vector<MessageData> msgs;
+        nlohmann::json::parse(r.text).get_to(msgs);
+        for (const auto &msg : msgs)
+            StoreMessage(msg.ID, msg);
+
+        cb(msgs);
+    });
+}
+
 const MessageData *DiscordClient::GetMessage(Snowflake id) const {
     return &m_messages.at(id);
 }

discord/discord.hpp

@@ -476,6 +476,7 @@ public:
 
     void UpdateSettingsGuildPositions(const std::vector<Snowflake> &pos);
     void FetchMessagesInChannel(Snowflake id, std::function<void(const std::vector<MessageData> &)> cb);
+    void FetchMessagesInChannelBefore(Snowflake channel_id, Snowflake before_id, std::function<void(const std::vector<MessageData> &)> cb);
     const MessageData *GetMessage(Snowflake id) const;
 
     void SendChatMessage(std::string content, Snowflake channel);

windows/mainwindow.cpp

@@ -110,6 +110,10 @@ void MainWindow::UpdateChatNewMessage(Snowflake id) {
         m_chat.AddNewMessage(id);
 }
 
+void MainWindow::UpdateChatPrependHistory(const std::vector<MessageData> &msgs) {
+    m_chat.AddNewHistory(msgs);
+}
+
 void MainWindow::SetAbaddon(Abaddon *ptr) {
     m_abaddon = ptr;
     m_channel_list.SetAbaddon(ptr);

windows/mainwindow.hpp

@@ -16,6 +16,7 @@ public:
     void UpdateChatActiveChannel(Snowflake id);
     Snowflake GetChatActiveChannel() const;
     void UpdateChatNewMessage(Snowflake id);
+    void UpdateChatPrependHistory(const std::vector<MessageData> &msgs);
 
 protected:
     Gtk::Box m_main_box;