colin/abaddon
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor channel listing

Browse Source
This commit is contained in:
ouwou
2020-09-17 02:26:33 -04:00
parent b8b47b429e
commit 72d0a0d2a0
5 changed files with 295 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

438
components/channels.cpp
View File

@@ -4,6 +4,117 @@
#include <unordered_map> #include <unordered_map>
#include "../abaddon.hpp" #include "../abaddon.hpp"
ChannelListRow::type_signal_list_collapse ChannelListRow::signal_list_collapse() {
return m_signal_list_collapse;
}
ChannelListRow::type_signal_list_uncollapse ChannelListRow::signal_list_uncollapse() {
return m_signal_list_uncollapse;
}
ChannelListRowDMHeader::ChannelListRowDMHeader() {
m_ev = Gtk::manage(new Gtk::EventBox);
m_box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL));
m_lbl = Gtk::manage(new Gtk::Label);
get_style_context()->add_class("channel-row");
m_lbl->get_style_context()->add_class("channel-row-label");
m_lbl->set_use_markup(true);
m_lbl->set_markup("<b>Direct Messages</b>");
m_box->set_halign(Gtk::ALIGN_START);
m_box->pack_start(*m_lbl);
m_ev->add(*m_box);
add(*m_ev);
show_all_children();
}
ChannelListRowDMChannel::ChannelListRowDMChannel(const Channel *data) {
ID = data->ID;
m_ev = Gtk::manage(new Gtk::EventBox);
m_box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL));
m_lbl = Gtk::manage(new Gtk::Label);
get_style_context()->add_class("channel-row");
m_lbl->get_style_context()->add_class("channel-row-label");
if (data->Type == ChannelType::DM)
m_lbl->set_text(data->Recipients[0].Username);
else if (data->Type == ChannelType::GROUP_DM)
m_lbl->set_text(std::to_string(data->Recipients.size()) + " users");
m_box->set_halign(Gtk::ALIGN_START);
m_box->pack_start(*m_lbl);
m_ev->add(*m_box);
add(*m_ev);
show_all_children();
}
ChannelListRowGuild::ChannelListRowGuild(const Guild *data) {
ID = data->ID;
m_ev = Gtk::manage(new Gtk::EventBox);
m_box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL));
m_lbl = Gtk::manage(new Gtk::Label);
get_style_context()->add_class("channel-row");
get_style_context()->add_class("channel-row-guild");
m_lbl->get_style_context()->add_class("channel-row-label");
m_lbl->set_markup("<b>" + Glib::Markup::escape_text(data->Name) + "</b>");
m_box->set_halign(Gtk::ALIGN_START);
m_box->pack_start(*m_lbl);
m_ev->add(*m_box);
add(*m_ev);
show_all_children();
}
ChannelListRowCategory::ChannelListRowCategory(const Channel *data) {
ID = data->ID;
m_ev = Gtk::manage(new Gtk::EventBox);
m_box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL));
m_lbl = Gtk::manage(new Gtk::Label);
m_arrow = Gtk::manage(new Gtk::Arrow(Gtk::ARROW_DOWN, Gtk::SHADOW_NONE));
get_style_context()->add_class("channel-row");
get_style_context()->add_class("channel-row-category");
m_lbl->get_style_context()->add_class("channel-row-label");
m_signal_list_collapse.connect([this]() {
m_arrow->set(Gtk::ARROW_RIGHT, Gtk::SHADOW_NONE);
});
m_signal_list_uncollapse.connect([this]() {
m_arrow->set(Gtk::ARROW_DOWN, Gtk::SHADOW_NONE);
});
m_lbl->set_text(data->Name);
m_box->set_halign(Gtk::ALIGN_START);
m_box->pack_start(*m_arrow);
m_box->pack_start(*m_lbl);
m_ev->add(*m_box);
add(*m_ev);
show_all_children();
}
ChannelListRowChannel::ChannelListRowChannel(const Channel *data) {
ID = data->ID;
m_ev = Gtk::manage(new Gtk::EventBox);
m_box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL));
m_lbl = Gtk::manage(new Gtk::Label);
get_style_context()->add_class("channel-row");
get_style_context()->add_class("channel-row-channel");
m_lbl->get_style_context()->add_class("channel-row-label");
m_lbl->set_text("#" + data->Name);
m_box->set_halign(Gtk::ALIGN_START);
m_box->pack_start(*m_lbl);
m_ev->add(*m_box);
add(*m_ev);
show_all_children();
}
ChannelList::ChannelList() { ChannelList::ChannelList() {
m_main = Gtk::manage(new Gtk::ScrolledWindow); m_main = Gtk::manage(new Gtk::ScrolledWindow);
m_list = Gtk::manage(new Gtk::ListBox); m_list = Gtk::manage(new Gtk::ListBox);
@@ -30,54 +141,50 @@ ChannelList::ChannelList() {
m_main->add(*m_list); m_main->add(*m_list);
m_main->show_all(); m_main->show_all();
m_update_dispatcher.connect(sigc::mem_fun(*this, &ChannelList::SetListingFromGuildsInternal)); m_update_dispatcher.connect(sigc::mem_fun(*this, &ChannelList::UpdateListingInternal));
} }
Gtk::Widget *ChannelList::GetRoot() const { Gtk::Widget *ChannelList::GetRoot() const {
return m_main; return m_main;
} }
void ChannelList::SetListingFromGuilds(const DiscordClient::guilds_type &guilds) { void ChannelList::UpdateListing() {
std::scoped_lock<std::mutex> guard(m_update_mutex); //std::scoped_lock<std::mutex> guard(m_update_mutex);
m_update_queue.push(guilds);
m_update_dispatcher.emit(); m_update_dispatcher.emit();
} }
void ChannelList::Clear() { void ChannelList::Clear() {
std::scoped_lock<std::mutex> guard(m_update_mutex); //std::scoped_lock<std::mutex> guard(m_update_mutex);
m_update_queue.push(DiscordClient::guilds_type());
m_update_dispatcher.emit(); m_update_dispatcher.emit();
} }
void ChannelList::on_row_activated(Gtk::ListBoxRow *row) { void ChannelList::on_row_activated(Gtk::ListBoxRow *tmprow) {
auto &info = m_infos[row]; auto row = dynamic_cast<ChannelListRow *>(tmprow);
bool new_collapsed = !info.IsUserCollapsed; if (row == nullptr) return;
info.IsUserCollapsed = new_collapsed; bool new_collapsed = !row->IsUserCollapsed;
row->IsUserCollapsed = new_collapsed;
if (info.Type == ListItemInfo::ListItemType::Channel) { // kinda ugly
m_signal_action_channel_item_select.emit(info.ID); if (dynamic_cast<ChannelListRowChannel *>(row) != nullptr || dynamic_cast<ChannelListRowDMChannel *>(row) != nullptr)
} m_signal_action_channel_item_select.emit(row->ID);
if (info.CatArrow != nullptr)
info.CatArrow->set(new_collapsed ? Gtk::ARROW_RIGHT : Gtk::ARROW_DOWN, Gtk::SHADOW_NONE);
if (new_collapsed) { if (new_collapsed) {
std::function<void(Gtk::ListBoxRow *)> collapse_children = [&](Gtk::ListBoxRow *row) { std::function<void(ChannelListRow *)> collapse_children = [&](ChannelListRow *row) {
for (auto child : m_infos[row].Children) { row->signal_list_collapse().emit();
auto &row_info = m_infos[child]; for (auto child : row->Children) {
row_info.IsHidden = true; row->IsHidden = true;
child->hide(); child->hide();
collapse_children(child); collapse_children(child);
} }
}; };
collapse_children(row); collapse_children(row);
} else { } else {
std::function<void(Gtk::ListBoxRow *)> restore_children = [&](Gtk::ListBoxRow *row) { std::function<void(ChannelListRow *)> restore_children = [&](ChannelListRow *row) {
auto &row_info = m_infos[row]; row->signal_list_uncollapse().emit();
row->show(); row->show();
row_info.IsHidden = false; row->IsHidden = false;
if (!row_info.IsUserCollapsed) if (!row->IsUserCollapsed)
for (auto row : row_info.Children) for (auto row : row->Children)
restore_children(row); restore_children(row);
}; };
restore_children(row); restore_children(row);
@@ -87,67 +194,23 @@ void ChannelList::on_row_activated(Gtk::ListBoxRow *row) {
void ChannelList::AddPrivateChannels() { void ChannelList::AddPrivateChannels() {
auto dms = Abaddon::Get().GetDiscordClient().GetPrivateChannels(); auto dms = Abaddon::Get().GetDiscordClient().GetPrivateChannels();
auto *parent_row = Gtk::manage(new Gtk::ListBoxRow); auto *parent_row = Gtk::manage(new ChannelListRowDMHeader);
auto *parent_ev = Gtk::manage(new Gtk::EventBox);
auto *parent_box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL));
auto *parent_label = Gtk::manage(new Gtk::Label);
parent_label->set_use_markup(true);
parent_label->set_markup("<b>Direct Messages</b>");
parent_box->set_halign(Gtk::ALIGN_START);
parent_box->pack_start(*parent_label);
parent_ev->add(*parent_box);
parent_row->add(*parent_ev);
parent_row->show_all(); parent_row->show_all();
parent_row->get_style_context()->add_class("channel-row"); parent_row->IsUserCollapsed = true;
parent_label->get_style_context()->add_class("channel-row-label"); parent_row->IsHidden = false;
m_list->add(*parent_row); m_list->add(*parent_row);
ListItemInfo parent_info; for (const auto &dm : dms) {
parent_info.IsUserCollapsed = true; auto *dm_row = Gtk::manage(new ChannelListRowDMChannel(Abaddon::Get().GetDiscordClient().GetChannel(dm)));
parent_info.IsHidden = false; dm_row->IsUserCollapsed = false;
parent_info.Type = ListItemInfo::ListItemType::Guild; // good nuf dm_row->IsHidden = false;
for (const auto &dmid : dms) {
auto *data = Abaddon::Get().GetDiscordClient().GetChannel(dmid);
auto *dm_row = Gtk::manage(new Gtk::ListBoxRow);
auto *dm_ev = Gtk::manage(new Gtk::EventBox);
auto *dm_box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL));
auto *dm_label = Gtk::manage(new Gtk::Label);
dm_row->get_style_context()->add_class("channel-row");
dm_label->get_style_context()->add_class("channel-row-label");
if (data->Type == ChannelType::DM)
dm_label->set_text(data->Recipients[0].Username);
else
dm_label->set_text(std::to_string(data->Recipients.size()) + " users");
dm_box->set_halign(Gtk::ALIGN_START);
dm_box->pack_start(*dm_label);
dm_ev->add(*dm_box);
dm_row->add(*dm_ev);
dm_row->show_all_children();
m_list->add(*dm_row); m_list->add(*dm_row);
parent_row->Children.insert(dm_row);
ListItemInfo info; }
info.ID = dmid;
info.IsUserCollapsed = false;
info.IsHidden = false;
info.Type = ListItemInfo::ListItemType::Channel;
m_infos[dm_row] = std::move(info);
parent_info.Children.insert(dm_row);
} }
m_infos[parent_row] = std::move(parent_info); void ChannelList::UpdateListingInternal() {
} std::unordered_set<Snowflake> guilds = Abaddon::Get().GetDiscordClient().GetGuildsID();
void ChannelList::SetListingFromGuildsInternal() {
DiscordClient::guilds_type guilds;
{
std::scoped_lock<std::mutex> guard(m_update_mutex);
guilds = m_update_queue.front();
m_update_queue.pop();
}
auto children = m_list->get_children(); auto children = m_list->get_children();
auto it = children.begin(); auto it = children.begin();
@@ -164,22 +227,16 @@ void ChannelList::SetListingFromGuildsInternal() {
// map each category to its channels // map each category to its channels
std::unordered_map<Snowflake, std::vector<const Channel *>> cat_to_channels; std::unordered_map<Snowflake, std::vector<const Channel *>> cat_to_channels;
std::unordered_map<Snowflake, std::vector<const Channel *>> orphan_channels; std::unordered_map<Snowflake, std::map<Snowflake, const Channel *>> orphan_channels;
for (const auto &[gid, guild] : guilds) { for (const auto gid : guilds) {
for (const auto &chan : guild.Channels) { const auto *guild = Abaddon::Get().GetDiscordClient().GetGuild(gid);
for (const auto &chan : guild->Channels) {
switch (chan.Type) { switch (chan.Type) {
case ChannelType::GUILD_TEXT: { case ChannelType::GUILD_TEXT: {
if (chan.ParentID.IsValid()) { if (chan.ParentID.IsValid())
auto it = cat_to_channels.find(chan.ParentID);
if (it == cat_to_channels.end())
cat_to_channels[chan.ParentID] = std::vector<const Channel *>();
cat_to_channels[chan.ParentID].push_back(&chan); cat_to_channels[chan.ParentID].push_back(&chan);
} else { else
auto it = orphan_channels.find(gid); orphan_channels[gid][chan.Position] = &chan;
if (it == orphan_channels.end())
orphan_channels[gid] = std::vector<const Channel *>();
orphan_channels[gid].push_back(&chan);
}
} break; } break;
default: default:
break; break;
@@ -187,170 +244,95 @@ void ChannelList::SetListingFromGuildsInternal() {
} }
} }
auto add_channel = [&](const Snowflake &id, const Channel &channel) -> Gtk::ListBoxRow * { // idk why i even bother with the queue
auto *channel_row = Gtk::manage(new Gtk::ListBoxRow); auto sorted_guilds = Abaddon::Get().GetDiscordClient().GetUserSortedGuilds();
auto *channel_ev = Gtk::manage(new Gtk::EventBox); for (auto gid : sorted_guilds) {
auto *channel_box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL)); // add guild row
auto *channel_label = Gtk::manage(new Gtk::Label); const auto *guild_data = Abaddon::Get().GetDiscordClient().GetGuild(gid);
auto *guild_row = Gtk::manage(new ChannelListRowGuild(guild_data));
channel_row->get_style_context()->add_class("channel-row");
channel_row->get_style_context()->add_class("channel-row-channel");
channel_label->get_style_context()->add_class("channel-row-label");
channel_label->set_text("#" + channel.Name);
channel_box->set_halign(Gtk::ALIGN_START);
channel_box->pack_start(*channel_label);
channel_ev->add(*channel_box);
channel_row->add(*channel_ev);
channel_row->show_all_children();
m_list->add(*channel_row);
ListItemInfo info;
info.ID = id;
info.IsUserCollapsed = false;
info.IsHidden = false;
info.Type = ListItemInfo::ListItemType::Channel;
m_infos[channel_row] = std::move(info);
return channel_row;
};
auto add_category = [&](const Snowflake &id, const Channel &channel) -> Gtk::ListBoxRow * {
auto *category_row = Gtk::manage(new Gtk::ListBoxRow);
auto *category_ev = Gtk::manage(new Gtk::EventBox);
auto *category_box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL));
auto *category_label = Gtk::manage(new Gtk::Label);
auto *category_arrow = Gtk::manage(new Gtk::Arrow(Gtk::ARROW_DOWN, Gtk::SHADOW_NONE));
category_row->get_style_context()->add_class("channel-row");
category_row->get_style_context()->add_class("channel-row-category");
category_label->get_style_context()->add_class("channel-row-label");
category_label->set_text(channel.Name);
category_box->set_halign(Gtk::ALIGN_START);
category_box->pack_start(*category_arrow);
category_box->pack_start(*category_label);
category_ev->add(*category_box);
category_row->add(*category_ev);
category_row->show_all_children();
m_list->add(*category_row);
ListItemInfo info;
info.ID = id;
info.IsUserCollapsed = false;
info.IsHidden = true;
info.CatArrow = category_arrow;
info.Type = ListItemInfo::ListItemType::Category;
if (cat_to_channels.find(id) != cat_to_channels.end()) {
std::map<int, const Channel *> sorted_channels;
for (const auto channel : cat_to_channels[id]) {
assert(channel->Position != -1);
sorted_channels[channel->Position] = channel;
}
for (const auto &[pos, channel] : sorted_channels) {
auto channel_row = add_channel(channel->ID, *channel);
info.Children.insert(channel_row);
}
}
m_infos[category_row] = std::move(info);
return category_row;
};
auto add_guild = [&](const Snowflake &id, const Guild &guild) {
auto *guild_row = Gtk::manage(new Gtk::ListBoxRow);
auto *guild_ev = Gtk::manage(new Gtk::EventBox);
auto *guild_box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL));
auto *guild_label = Gtk::manage(new Gtk::Label);
guild_row->get_style_context()->add_class("channel-row");
guild_row->get_style_context()->add_class("channel-row-guild");
guild_label->get_style_context()->add_class("channel-row-label");
guild_label->set_markup("<b>" + Glib::Markup::escape_text(guild.Name) + "</b>");
guild_box->set_halign(Gtk::ALIGN_START);
guild_box->pack_start(*guild_label);
guild_ev->add(*guild_box);
guild_row->add(*guild_ev);
guild_row->show_all(); guild_row->show_all();
guild_row->IsUserCollapsed = true;
guild_row->IsHidden = false;
guild_row->GuildIndex = m_guild_count++;
m_list->add(*guild_row); m_list->add(*guild_row);
AttachMenuHandler(guild_row); AttachMenuHandler(guild_row);
ListItemInfo info; // add channels with no parent category
info.ID = id; if (orphan_channels.find(gid) != orphan_channels.end()) {
info.IsUserCollapsed = true; for (const auto &[pos, channel] : orphan_channels.at(gid)) {
info.IsHidden = false; auto *chan_row = Gtk::manage(new ChannelListRowChannel(channel));
info.GuildIndex = m_guild_count++; chan_row->IsUserCollapsed = false;
info.Type = ListItemInfo::ListItemType::Guild; chan_row->IsHidden = true;
m_list->add(*chan_row);
if (orphan_channels.find(id) != orphan_channels.end()) { guild_row->Children.insert(chan_row);
std::map<int, const Channel *> sorted_orphans;
for (const auto channel : orphan_channels[id]) {
assert(channel->Position != -1); // can this trigger?
sorted_orphans[channel->Position] = channel;
}
for (const auto &[pos, channel] : sorted_orphans) {
auto channel_row = add_channel(channel->ID, *channel);
m_infos[channel_row].IsHidden = true;
info.Children.insert(channel_row);
} }
} }
// categories
std::map<int, std::vector<const Channel *>> sorted_categories; std::map<int, std::vector<const Channel *>> sorted_categories;
for (const auto &channel : guild_data->Channels)
for (const auto &channel : guild.Channels) { if (channel.Type == ChannelType::GUILD_CATEGORY)
if (channel.Type == ChannelType::GUILD_CATEGORY) {
sorted_categories[channel.Position].push_back(&channel); sorted_categories[channel.Position].push_back(&channel);
}
}
for (auto &[pos, channelvec] : sorted_categories) { for (auto &[pos, catvec] : sorted_categories) {
std::sort(channelvec.begin(), channelvec.end(), [](const Channel *a, const Channel *b) { return a->ID < b->ID; }); std::sort(catvec.begin(), catvec.end(), [](const Channel *a, const Channel *b) { return a->ID < b->ID; });
for (const auto channel : channelvec) { for (const auto cat : catvec) {
if (channel->Type == ChannelType::GUILD_CATEGORY) { auto *cat_row = Gtk::manage(new ChannelListRowCategory(cat));
auto category_row = add_category(channel->ID, *channel); cat_row->IsUserCollapsed = false;
info.Children.insert(category_row); cat_row->IsHidden = true;
} m_list->add(*cat_row);
} guild_row->Children.insert(cat_row);
}
m_infos[guild_row] = std::move(info); // child channels
}; if (cat_to_channels.find(cat->ID) == cat_to_channels.end()) continue;
std::map<int, const Channel *> sorted_channels;
const auto &discord = Abaddon::Get().GetDiscordClient(); for (const auto channel : cat_to_channels.at(cat->ID))
const auto &sorted_guilds = discord.GetUserSortedGuilds(); sorted_channels[channel->Position] = channel;
for (const auto &id : sorted_guilds) {
add_guild(id, *discord.GetGuild(id)); for (const auto &[pos, channel] : sorted_channels) {
auto *chan_row = Gtk::manage(new ChannelListRowChannel(channel));
chan_row->IsHidden = false;
chan_row->IsUserCollapsed = false;
m_list->add(*chan_row);
cat_row->Children.insert(chan_row);
}
}
}
} }
} }
void ChannelList::on_menu_move_up() { void ChannelList::on_menu_move_up() {
auto row = m_list->get_selected_row(); auto tmp = m_list->get_selected_row();
m_signal_action_guild_move_up.emit(m_infos[row].ID); auto row = dynamic_cast<ChannelListRow *>(tmp);
if (row != nullptr)
m_signal_action_guild_move_up.emit(row->ID);
} }
void ChannelList::on_menu_move_down() { void ChannelList::on_menu_move_down() {
auto row = m_list->get_selected_row(); auto tmp = m_list->get_selected_row();
m_signal_action_guild_move_down.emit(m_infos[row].ID); auto row = dynamic_cast<ChannelListRow *>(tmp);
if (row != nullptr)
m_signal_action_guild_move_down.emit(row->ID);
} }
void ChannelList::on_menu_copyid() { void ChannelList::on_menu_copyid() {
auto row = m_list->get_selected_row(); auto tmp = m_list->get_selected_row();
m_signal_action_guild_copy_id.emit(m_infos[row].ID); auto row = dynamic_cast<ChannelListRow *>(tmp);
if (row != nullptr)
m_signal_action_guild_copy_id.emit(row->ID);
} }
void ChannelList::AttachMenuHandler(Gtk::ListBoxRow *row) { void ChannelList::AttachMenuHandler(Gtk::ListBoxRow *row) {
row->signal_button_press_event().connect([&, row](GdkEventButton *e) -> bool { row->signal_button_press_event().connect([&, row](GdkEventButton *e) -> bool {
if (e->type == GDK_BUTTON_PRESS && e->button == GDK_BUTTON_SECONDARY) { if (e->type == GDK_BUTTON_PRESS && e->button == GDK_BUTTON_SECONDARY) {
auto grow = dynamic_cast<ChannelListRowGuild *>(row);
if (grow != nullptr) {
m_list->select_row(*row); m_list->select_row(*row);
m_guild_menu_up->set_sensitive(m_infos[row].GuildIndex != 0); m_guild_menu_up->set_sensitive(grow->GuildIndex != 0);
m_guild_menu_down->set_sensitive(m_infos[row].GuildIndex != m_guild_count - 1); m_guild_menu_down->set_sensitive(grow->GuildIndex != m_guild_count - 1);
m_guild_menu.popup_at_pointer(reinterpret_cast<const GdkEvent *>(e)); m_guild_menu.popup_at_pointer(reinterpret_cast<const GdkEvent *>(e));
}
return true; return true;
} }

96
components/channels.hpp
View File

@@ -7,34 +7,88 @@
#include <sigc++/sigc++.h> #include <sigc++/sigc++.h>
#include "../discord/discord.hpp" #include "../discord/discord.hpp"
class ChannelListRow : public Gtk::ListBoxRow {
public:
bool IsUserCollapsed;
bool IsHidden;
Snowflake ID;
std::unordered_set<ChannelListRow *> Children;
typedef sigc::signal<void> type_signal_list_collapse;
typedef sigc::signal<void> type_signal_list_uncollapse;
type_signal_list_collapse signal_list_collapse();
type_signal_list_uncollapse signal_list_uncollapse();
protected:
type_signal_list_collapse m_signal_list_collapse;
type_signal_list_uncollapse m_signal_list_uncollapse;
};
class ChannelListRowDMHeader : public ChannelListRow {
public:
ChannelListRowDMHeader();
protected:
Gtk::EventBox *m_ev;
Gtk::Box *m_box;
Gtk::Label *m_lbl;
};
class ChannelListRowDMChannel : public ChannelListRow {
public:
ChannelListRowDMChannel(const Channel *data);
protected:
Gtk::EventBox *m_ev;
Gtk::Box *m_box;
Gtk::Label *m_lbl;
};
class ChannelListRowGuild : public ChannelListRow {
public:
ChannelListRowGuild(const Guild *data);
int GuildIndex;
protected:
Gtk::EventBox *m_ev;
Gtk::Box *m_box;
Gtk::Label *m_lbl;
};
class ChannelListRowCategory : public ChannelListRow {
public:
ChannelListRowCategory(const Channel *data);
protected:
Gtk::EventBox *m_ev;
Gtk::Box *m_box;
Gtk::Label *m_lbl;
Gtk::Arrow *m_arrow;
};
class ChannelListRowChannel : public ChannelListRow {
public:
ChannelListRowChannel(const Channel *data);
protected:
Gtk::EventBox *m_ev;
Gtk::Box *m_box;
Gtk::Label *m_lbl;
};
class ChannelList { class ChannelList {
public: public:
ChannelList(); ChannelList();
Gtk::Widget *GetRoot() const; Gtk::Widget *GetRoot() const;
void SetListingFromGuilds(const DiscordClient::guilds_type &guilds); void UpdateListing();
void Clear(); void Clear();
protected: protected:
Gtk::ListBox *m_list; Gtk::ListBox *m_list;
Gtk::ScrolledWindow *m_main; Gtk::ScrolledWindow *m_main;
struct ListItemInfo {
enum ListItemType {
Guild,
Category,
Channel,
};
int GuildIndex;
Snowflake ID;
std::unordered_set<Gtk::ListBoxRow *> Children;
bool IsUserCollapsed;
bool IsHidden;
ListItemType Type;
// for categories
Gtk::Arrow *CatArrow = nullptr;
};
std::unordered_map<Gtk::ListBoxRow *, ListItemInfo> m_infos;
void on_row_activated(Gtk::ListBoxRow *row); void on_row_activated(Gtk::ListBoxRow *row);
int m_guild_count; int m_guild_count;
@@ -47,10 +101,10 @@ protected:
void on_menu_copyid(); void on_menu_copyid();
Glib::Dispatcher m_update_dispatcher; Glib::Dispatcher m_update_dispatcher;
mutable std::mutex m_update_mutex; //mutable std::mutex m_update_mutex;
std::queue<DiscordClient::guilds_type> m_update_queue; //std::queue<std::unordered_set<Snowflake>> m_update_queue;
void AddPrivateChannels(); // retard moment void AddPrivateChannels(); // retard moment
void SetListingFromGuildsInternal(); void UpdateListingInternal();
void AttachMenuHandler(Gtk::ListBoxRow *row); void AttachMenuHandler(Gtk::ListBoxRow *row);
public: public:

8
discord/discord.cpp
View File

@@ -37,6 +37,14 @@ bool DiscordClient::IsStarted() const {
return m_client_connected; return m_client_connected;
} }
std::unordered_set<Snowflake> DiscordClient::GetGuildsID() const {
const auto &guilds = m_store.GetGuilds();
std::unordered_set<Snowflake> ret;
for (const auto &[gid, data] : guilds)
ret.insert(gid);
return ret;
}
const Store::guilds_type &DiscordClient::GetGuilds() const { const Store::guilds_type &DiscordClient::GetGuilds() const {
return m_store.GetGuilds(); return m_store.GetGuilds();
} }

1
discord/discord.hpp
View File

@@ -60,6 +60,7 @@ public:
using roles_type = Store::roles_type; using roles_type = Store::roles_type;
using members_type = Store::members_type; using members_type = Store::members_type;
std::unordered_set<Snowflake> GetGuildsID() const;
const guilds_type &GetGuilds() const; const guilds_type &GetGuilds() const;
const User &GetUserData() const; const User &GetUserData() const;
const UserSettings &GetUserSettings() const; const UserSettings &GetUserSettings() const;

3
windows/mainwindow.cpp
View File

@@ -105,8 +105,7 @@ void MainWindow::UpdateMembers() {
} }
void MainWindow::UpdateChannelListing() { void MainWindow::UpdateChannelListing() {
auto &discord = Abaddon::Get().GetDiscordClient(); m_channel_list.UpdateListing();
m_channel_list.SetListingFromGuilds(discord.GetGuilds());
} }
void MainWindow::UpdateChatWindowContents() { void MainWindow::UpdateChatWindowContents() {