noury/mirror-chatterino2
1
0
Fork 0
mirror of https://github.com/Chatterino/chatterino2.git synced 2024-11-21 22:24:07 +01:00
Code Issues Projects Releases Packages Wiki Activity

Refactored TwitchChannel

Browse source
This commit is contained in:
fourtf 2018-07-15 20:28:54 +02:00
parent 111853c574
commit 1614b11e42
11 changed files with 268 additions and 247 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
chatterino.pro
View file

@ -232,8 +232,7 @@ SOURCES += \
src/widgets/dialogs/UpdateDialog.cpp \
src/widgets/settingspages/IgnoresPage.cpp \
src/providers/twitch/PubsubClient.cpp \
src/providers/twitch/TwitchApi.cpp \
src/common/uniqueaccess.cpp
src/providers/twitch/TwitchApi.cpp
HEADERS += \
src/Application.hpp \
@ -416,7 +415,7 @@ HEADERS += \
src/widgets/settingspages/IgnoresPage.hpp \
src/providers/twitch/PubsubClient.hpp \
src/providers/twitch/TwitchApi.hpp \
src/common/uniqueaccess.hpp
src/common/UniqueAccess.hpp
RESOURCES += \
resources/resources.qrc \

30
src/common/uniqueaccess.hpp → src/common/UniqueAccess.hpp
View file

@ -21,16 +21,31 @@ public:
this->mutex_.unlock();
}
T *operator->() const
const T *operator->() const
{
return &this->element_;
}
T &operator*() const
T *operator->()
{
return &this->element_;
}
const T &operator*() const
{
return this->element_;
}
T &operator*()
{
return this->element_;
}
T clone() const
{
return T(this->element_);
}
private:
T &element_;
std::mutex &mutex_;
@ -40,7 +55,7 @@ template <typename T>
class UniqueAccess
{
public:
template <typename std::enable_if<std::is_default_constructible<T>::value>::type * = 0>
template <typename X = decltype(T())>
UniqueAccess()
: element_(T())
{
@ -73,9 +88,14 @@ public:
return AccessGuard<T>(this->element_, this->mutex_);
}
const AccessGuard<T> access() const
{
return AccessGuard<T>(this->element_, this->mutex_);
}
private:
T element_;
std::mutex mutex_;
mutable T element_;
mutable std::mutex mutex_;
};
} // namespace chatterino

1
src/common/uniqueaccess.cpp
View file

@ -1 +0,0 @@
#include "uniqueaccess.hpp"

6
src/controllers/commands/CommandController.cpp
View file

@ -142,7 +142,7 @@ QString CommandController::execCommand(const QString &text, ChannelPtr channel,
app->twitch.server->getWriteConnection()->sendRaw("PRIVMSG #jtv :" + text + "\r\n");
if (app->settings->inlineWhispers) {
if (getSettings()->inlineWhispers) {
app->twitch.server->forEachChannel(
[&b](ChannelPtr _channel) { _channel->addMessage(b.getMessage()); });
}
@ -163,10 +163,10 @@ QString CommandController::execCommand(const QString &text, ChannelPtr channel,
return "";
} else if (commandName == "/uptime") {
const auto &streamStatus = twitchChannel->getStreamStatus();
const auto &streamStatus = twitchChannel->accessStreamStatus();
QString messageText =
streamStatus.live ? streamStatus.uptime : "Channel is not live.";
streamStatus->live ? streamStatus->uptime : "Channel is not live.";
channel->addMessage(Message::createSystemMessage(messageText));

18
src/providers/twitch/IrcMessageHandler.cpp
View file

@ -93,31 +93,33 @@ void IrcMessageHandler::handleRoomStateMessage(Communi::IrcMessage *message)
if ((it = tags.find("room-id")) != tags.end()) {
auto roomId = it.value().toString();
twitchChannel->setRoomID(roomId);
twitchChannel->setRoomId(roomId);
app->resources->loadChannelData(roomId);
}
// Room modes
TwitchChannel::RoomModes roomModes = twitchChannel->getRoomModes();
{
auto roomModes = twitchChannel->accessRoomModes();
if ((it = tags.find("emote-only")) != tags.end()) {
roomModes.emoteOnly = it.value() == "1";
roomModes->emoteOnly = it.value() == "1";
}
if ((it = tags.find("subs-only")) != tags.end()) {
roomModes.submode = it.value() == "1";
roomModes->submode = it.value() == "1";
}
if ((it = tags.find("slow")) != tags.end()) {
roomModes.slowMode = it.value().toInt();
roomModes->slowMode = it.value().toInt();
}
if ((it = tags.find("r9k")) != tags.end()) {
roomModes.r9k = it.value() == "1";
roomModes->r9k = it.value() == "1";
}
if ((it = tags.find("broadcaster-lang")) != tags.end()) {
roomModes.broadcasterLang = it.value().toString();
roomModes->broadcasterLang = it.value().toString();
}
}
twitchChannel->setRoomModes(roomModes);
twitchChannel->roomModesChanged.invoke();
}
}

180
src/providers/twitch/TwitchChannel.cpp
View file

@ -21,31 +21,31 @@ namespace chatterino {
TwitchChannel::TwitchChannel(const QString &channelName, Communi::IrcConnection *readConnection)
: Channel(channelName, Channel::Type::Twitch)
, bttvChannelEmotes(new EmoteMap)
, ffzChannelEmotes(new EmoteMap)
, subscriptionURL("https://www.twitch.tv/subs/" + name)
, channelURL("https://twitch.tv/" + name)
, popoutPlayerURL("https://player.twitch.tv/?channel=" + name)
, bttvEmotes_(new EmoteMap)
, ffzEmotes_(new EmoteMap)
, subscriptionUrl_("https://www.twitch.tv/subs/" + name)
, channelUrl_("https://twitch.tv/" + name)
, popoutPlayerUrl_("https://player.twitch.tv/?channel=" + name)
, mod_(false)
, readConnection_(readConnection)
{
Log("[TwitchChannel:{}] Opened", this->name);
this->refreshChannelEmotes();
this->refreshViewerList();
// this->refreshViewerList();
this->managedConnect(getApp()->accounts->twitch.currentUserChanged,
[=] { this->setMod(false); });
// pubsub
this->userStateChanged.connect([=] { this->refreshPubsub(); });
this->roomIDChanged.connect([=] { this->refreshPubsub(); });
this->roomIdChanged.connect([=] { this->refreshPubsub(); });
this->managedConnect(getApp()->accounts->twitch.currentUserChanged,
[=] { this->refreshPubsub(); });
this->refreshPubsub();
// room id loaded -> refresh live status
this->roomIDChanged.connect([this]() { this->refreshLiveStatus(); });
this->roomIdChanged.connect([this]() { this->refreshLiveStatus(); });
// timers
QObject::connect(&this->chattersListTimer_, &QTimer::timeout,
@ -83,8 +83,8 @@ void TwitchChannel::refreshChannelEmotes()
Log("[TwitchChannel:{}] Reloading channel emotes", this->name);
app->emotes->bttv.loadChannelEmotes(this->name, this->bttvChannelEmotes);
app->emotes->ffz.loadChannelEmotes(this->name, this->ffzChannelEmotes);
app->emotes->bttv.loadChannelEmotes(this->name, this->bttvEmotes_);
app->emotes->ffz.loadChannelEmotes(this->name, this->ffzEmotes_);
}
void TwitchChannel::sendMessage(const QString &message)
@ -112,7 +112,7 @@ void TwitchChannel::sendMessage(const QString &message)
}
if (!this->hasModRights()) {
if (app->settings->allowDuplicateMessages) {
if (getSettings()->allowDuplicateMessages) {
if (parsedMessage == this->lastSentMessage_) {
parsedMessage.append(this->messageSuffix_);
}
@ -153,36 +153,30 @@ void TwitchChannel::addRecentChatter(const std::shared_ptr<Message> &message)
{
assert(!message->loginName.isEmpty());
std::lock_guard<std::mutex> lock(this->recentChattersMutex_);
this->recentChatters_[message->loginName] = {message->displayName, message->localizedName};
this->completionModel.addUser(message->displayName);
}
void TwitchChannel::addJoinedUser(const QString &user)
{
auto *app = getApp();
auto app = getApp();
if (user == app->accounts->twitch.getCurrent()->getUserName() ||
!app->settings->showJoins.getValue()) {
!getSettings()->showJoins.getValue()) {
return;
}
std::lock_guard<std::mutex> guard(this->joinedUserMutex_);
joinedUsers_ << user;
auto joinedUsers = this->joinedUsers_.access();
joinedUsers->append(user);
if (!this->joinedUsersMergeQueued_) {
this->joinedUsersMergeQueued_ = true;
QTimer::singleShot(500, &this->object_, [this] {
std::lock_guard<std::mutex> guard(this->joinedUserMutex_);
QTimer::singleShot(500, &this->lifetimeGuard_, [this] {
auto joinedUsers = this->joinedUsers_.access();
auto message =
Message::createSystemMessage("Users joined: " + this->joinedUsers_.join(", "));
auto message = Message::createSystemMessage("Users joined: " + joinedUsers->join(", "));
message->flags |= Message::Collapsed;
joinedUsers->clear();
this->addMessage(message);
this->joinedUsers_.clear();
this->joinedUsersMergeQueued_ = false;
});
}
@ -197,76 +191,92 @@ void TwitchChannel::addPartedUser(const QString &user)
return;
}
std::lock_guard<std::mutex> guard(this->partedUserMutex_);
this->partedUsers_ << user;
auto partedUsers = this->partedUsers_.access();
partedUsers->append(user);
if (!this->partedUsersMergeQueued_) {
this->partedUsersMergeQueued_ = true;
QTimer::singleShot(500, &this->object_, [this] {
std::lock_guard<std::mutex> guard(this->partedUserMutex_);
QTimer::singleShot(500, &this->lifetimeGuard_, [this] {
auto partedUsers = this->partedUsers_.access();
auto message =
Message::createSystemMessage("Users parted: " + this->partedUsers_.join(", "));
auto message = Message::createSystemMessage("Users parted: " + partedUsers->join(", "));
message->flags |= Message::Collapsed;
this->addMessage(message);
this->partedUsers_.clear();
partedUsers->clear();
this->partedUsersMergeQueued_ = false;
});
}
}
QString TwitchChannel::getRoomID() const
QString TwitchChannel::getRoomId() const
{
return this->roomID_.get();
}
void TwitchChannel::setRoomID(const QString &id)
void TwitchChannel::setRoomId(const QString &id)
{
this->roomID_.set(id);
this->roomIDChanged.invoke();
this->roomIdChanged.invoke();
this->loadRecentMessages();
}
TwitchChannel::RoomModes TwitchChannel::getRoomModes()
const AccessGuard<TwitchChannel::RoomModes> TwitchChannel::accessRoomModes() const
{
std::lock_guard<std::mutex> lock(this->roomModeMutex_);
return this->roomModes_;
return this->roomModes_.access();
}
void TwitchChannel::setRoomModes(const RoomModes &_roomModes)
{
{
std::lock_guard<std::mutex> lock(this->roomModeMutex_);
this->roomModes_ = _roomModes;
}
this->roomModesChanged.invoke();
}
bool TwitchChannel::isLive() const
{
std::lock_guard<std::mutex> lock(this->streamStatusMutex_);
return this->streamStatus_.live;
return this->streamStatus_.access()->live;
}
TwitchChannel::StreamStatus TwitchChannel::getStreamStatus() const
const AccessGuard<TwitchChannel::StreamStatus> TwitchChannel::accessStreamStatus() const
{
std::lock_guard<std::mutex> lock(this->streamStatusMutex_);
return this->streamStatus_;
return this->streamStatus_.access();
}
const EmoteMap &TwitchChannel::getFfzEmotes() const
{
return *this->ffzEmotes_;
}
const EmoteMap &TwitchChannel::getBttvEmotes() const
{
return *this->bttvEmotes_;
}
const QString &TwitchChannel::getSubscriptionUrl()
{
return this->subscriptionUrl_;
}
const QString &TwitchChannel::getChannelUrl()
{
return this->channelUrl_;
}
const QString &TwitchChannel::getPopoutPlayerUrl()
{
return this->popoutPlayerUrl_;
}
void TwitchChannel::setLive(bool newLiveStatus)
{
bool gotNewLiveStatus = false;
{
std::lock_guard<std::mutex> lock(this->streamStatusMutex_);
if (this->streamStatus_.live != newLiveStatus) {
auto guard = this->streamStatus_.access();
if (guard->live != newLiveStatus) {
gotNewLiveStatus = true;
this->streamStatus_.live = newLiveStatus;
guard->live = newLiveStatus;
}
}
@ -277,7 +287,7 @@ void TwitchChannel::setLive(bool newLiveStatus)
void TwitchChannel::refreshLiveStatus()
{
auto roomID = this->getRoomID();
auto roomID = this->getRoomId();
if (roomID.isEmpty()) {
Log("[TwitchChannel:{}] Refreshing live status (Missing ID)", this->name);
@ -291,38 +301,40 @@ void TwitchChannel::refreshLiveStatus()
auto request = makeGetStreamRequest(roomID, QThread::currentThread());
request.onSuccess([weak = this->weak_from_this()](auto result) {
auto d = result.parseRapidJson();
request.onSuccess([this, weak = this->weak_from_this()](auto result) {
ChannelPtr shared = weak.lock();
if (!shared) return false;
if (!shared) {
return false;
}
return this->parseLiveStatus(result.parseRapidJson());
});
TwitchChannel *channel = dynamic_cast<TwitchChannel *>(shared.get());
request.execute();
}
if (!d.IsObject()) {
bool TwitchChannel::parseLiveStatus(const rapidjson::Document &document)
{
if (!document.IsObject()) {
Log("[TwitchChannel:refreshLiveStatus] root is not an object");
return false;
}
if (!d.HasMember("stream")) {
if (!document.HasMember("stream")) {
Log("[TwitchChannel:refreshLiveStatus] Missing stream in root");
return false;
}
const auto &stream = d["stream"];
const auto &stream = document["stream"];
if (!stream.IsObject()) {
// Stream is offline (stream is most likely null)
channel->setLive(false);
this->setLive(false);
return false;
}
if (!stream.HasMember("viewers") || !stream.HasMember("game") ||
!stream.HasMember("channel") || !stream.HasMember("created_at")) {
if (!stream.HasMember("viewers") || !stream.HasMember("game") || !stream.HasMember("channel") ||
!stream.HasMember("created_at")) {
Log("[TwitchChannel:refreshLiveStatus] Missing members in stream");
channel->setLive(false);
this->setLive(false);
return false;
}
@ -336,22 +348,21 @@ void TwitchChannel::refreshLiveStatus()
// Stream is live
{
std::lock_guard<std::mutex> lock(channel->streamStatusMutex_);
StreamStatus status;
channel->streamStatus_.live = true;
channel->streamStatus_.viewerCount = stream["viewers"].GetUint();
channel->streamStatus_.game = stream["game"].GetString();
channel->streamStatus_.title = streamChannel["status"].GetString();
auto status = this->streamStatus_.access();
status->live = true;
status->viewerCount = stream["viewers"].GetUint();
status->game = stream["game"].GetString();
status->title = streamChannel["status"].GetString();
QDateTime since = QDateTime::fromString(stream["created_at"].GetString(), Qt::ISODate);
auto diff = since.secsTo(QDateTime::currentDateTime());
channel->streamStatus_.uptime =
status->uptime =
QString::number(diff / 3600) + "h " + QString::number(diff % 3600 / 60) + "m";
channel->streamStatus_.rerun = false;
status->rerun = false;
if (stream.HasMember("stream_type")) {
channel->streamStatus_.streamType = stream["stream_type"].GetString();
status->streamType = stream["stream_type"].GetString();
} else {
channel->streamStatus_.streamType = QString();
status->streamType = QString();
}
if (stream.HasMember("broadcast_platform")) {
@ -360,23 +371,16 @@ void TwitchChannel::refreshLiveStatus()
if (broadcastPlatformValue.IsString()) {
const char *broadcastPlatform = stream["broadcast_platform"].GetString();
if (strcmp(broadcastPlatform, "rerun") == 0) {
channel->streamStatus_.rerun = true;
status->rerun = true;
}
}
}
}
// Signal all listeners that the stream status has been updated
channel->liveStatusChanged.invoke();
this->liveStatusChanged.invoke();
return true;
});
request.execute();
}
void TwitchChannel::initializeLiveStatusTimer(int intervalMS)
{
}
void TwitchChannel::loadRecentMessages()
@ -384,7 +388,7 @@ void TwitchChannel::loadRecentMessages()
static QString genericURL =
"https://tmi.twitch.tv/api/rooms/%1/recent_messages?client_id=" + getDefaultClientID();
NetworkRequest request(genericURL.arg(this->getRoomID()));
NetworkRequest request(genericURL.arg(this->getRoomId()));
request.makeAuthorizedV5(getDefaultClientID());
request.setCaller(QThread::currentThread());
@ -431,7 +435,7 @@ void TwitchChannel::refreshPubsub()
{
// listen to moderation actions
if (!this->hasModRights()) return;
auto roomId = this->getRoomID();
auto roomId = this->getRoomId();
if (roomId.isEmpty()) return;
auto account = getApp()->accounts->twitch.getCurrent();
@ -441,10 +445,10 @@ void TwitchChannel::refreshPubsub()
void TwitchChannel::refreshViewerList()
{
// setting?
const auto streamStatus = this->getStreamStatus();
const auto streamStatus = this->accessStreamStatus();
if (getSettings()->onlyFetchChattersForSmallerStreamers) {
if (streamStatus.live && streamStatus.viewerCount > getSettings()->smallStreamerLimit) {
if (streamStatus->live && streamStatus->viewerCount > getSettings()->smallStreamerLimit) {
return;
}
}

93
src/providers/twitch/TwitchChannel.hpp
View file

@ -5,6 +5,7 @@
#include "common/Channel.hpp"
#include "common/Common.hpp"
#include "common/MutexValue.hpp"
#include "common/UniqueAccess.hpp"
#include "singletons/Emotes.hpp"
#include "util/ConcurrentMap.hpp"
@ -43,50 +44,53 @@ public:
QString broadcasterLang;
};
bool isEmpty() const override;
bool canSendMessage() const override;
void sendMessage(const QString &message) override;
void refreshChannelEmotes();
// Channel methods
virtual bool isEmpty() const override;
virtual bool canSendMessage() const override;
virtual void sendMessage(const QString &message) override;
// Auto completion
void addRecentChatter(const std::shared_ptr<Message> &message) final;
void addJoinedUser(const QString &user);
void addPartedUser(const QString &user);
// Twitch data
bool isLive() const;
virtual bool isMod() const override;
void setMod(bool value);
virtual bool isBroadcaster() const override;
QString getRoomID() const;
void setRoomID(const QString &id);
RoomModes getRoomModes();
QString getRoomId() const;
void setRoomId(const QString &id);
const AccessGuard<RoomModes> accessRoomModes() const;
void setRoomModes(const RoomModes &roomModes_);
StreamStatus getStreamStatus() const;
const AccessGuard<StreamStatus> accessStreamStatus() const;
void addRecentChatter(const std::shared_ptr<Message> &message) final;
void addJoinedUser(const QString &user);
void addPartedUser(const QString &user);
const EmoteMap &getFfzEmotes() const;
const EmoteMap &getBttvEmotes() const;
const QString &getSubscriptionUrl();
const QString &getChannelUrl();
const QString &getPopoutPlayerUrl();
// Signals
pajlada::Signals::NoArgSignal roomIdChanged;
pajlada::Signals::NoArgSignal liveStatusChanged;
pajlada::Signals::NoArgSignal userStateChanged;
pajlada::Signals::NoArgSignal roomModesChanged;
private:
struct NameOptions {
QString displayName;
QString localizedName;
};
void refreshChannelEmotes();
const std::shared_ptr<EmoteMap> bttvChannelEmotes;
const std::shared_ptr<EmoteMap> ffzChannelEmotes;
const QString subscriptionURL;
const QString channelURL;
const QString popoutPlayerURL;
pajlada::Signals::NoArgSignal roomIDChanged;
pajlada::Signals::NoArgSignal liveStatusChanged;
pajlada::Signals::NoArgSignal userStateChanged;
pajlada::Signals::NoArgSignal roomModesChanged;
private:
explicit TwitchChannel(const QString &channelName, Communi::IrcConnection *readConnection);
void initializeLiveStatusTimer(int intervalMS);
// Methods
void refreshLiveStatus();
bool parseLiveStatus(const rapidjson::Document &document);
void refreshPubsub();
void refreshViewerList();
bool parseViewerList(const QJsonObject &jsonRoot);
@ -95,35 +99,32 @@ private:
void setLive(bool newLiveStatus);
mutable std::mutex streamStatusMutex_;
StreamStatus streamStatus_;
// Twitch data
UniqueAccess<StreamStatus> streamStatus_;
UniqueAccess<UserState> userState_;
UniqueAccess<RoomModes> roomModes_;
mutable std::mutex userStateMutex_;
UserState userState_;
const std::shared_ptr<EmoteMap> bttvEmotes_;
const std::shared_ptr<EmoteMap> ffzEmotes_;
const QString subscriptionUrl_;
const QString channelUrl_;
const QString popoutPlayerUrl_;
bool mod_ = false;
QByteArray messageSuffix_;
QString lastSentMessage_;
RoomModes roomModes_;
std::mutex roomModeMutex_;
MutexValue<QString> roomID_;
QObject object_;
std::mutex joinedUserMutex_;
QStringList joinedUsers_;
UniqueAccess<QStringList> joinedUsers_;
bool joinedUsersMergeQueued_ = false;
std::mutex partedUserMutex_;
QStringList partedUsers_;
UniqueAccess<QStringList> partedUsers_;
bool partedUsersMergeQueued_ = false;
Communi::IrcConnection *readConnection_ = nullptr;
// Key = login name
std::map<QString, NameOptions> recentChatters_;
std::mutex recentChattersMutex_;
// --
QByteArray messageSuffix_;
QString lastSentMessage_;
QObject lifetimeGuard_;
QTimer liveStatusTimer_;
QTimer chattersListTimer_;
Communi::IrcConnection *readConnection_ = nullptr;
friend class TwitchServer;
};

8
src/providers/twitch/TwitchMessageBuilder.cpp
View file

@ -298,8 +298,8 @@ void TwitchMessageBuilder::parseRoomID()
if (iterator != std::end(this->tags)) {
this->roomID_ = iterator.value().toString();
if (this->twitchChannel->getRoomID().isEmpty()) {
this->twitchChannel->setRoomID(this->roomID_);
if (this->twitchChannel->getRoomId().isEmpty()) {
this->twitchChannel->setRoomId(this->roomID_);
}
}
}
@ -588,14 +588,14 @@ bool TwitchMessageBuilder::tryAppendEmote(QString &emoteString)
// BTTV Global Emote
return appendEmote(MessageElement::BttvEmote);
} else if (this->twitchChannel != nullptr &&
this->twitchChannel->bttvChannelEmotes->tryGet(emoteString, emoteData)) {
this->twitchChannel->getBttvEmotes().tryGet(emoteString, emoteData)) {
// BTTV Channel Emote
return appendEmote(MessageElement::BttvEmote);
} else if (app->emotes->ffz.globalEmotes.tryGet(emoteString, emoteData)) {
// FFZ Global Emote
return appendEmote(MessageElement::FfzEmote);
} else if (this->twitchChannel != nullptr &&
this->twitchChannel->ffzChannelEmotes->tryGet(emoteString, emoteData)) {
this->twitchChannel->getFfzEmotes().tryGet(emoteString, emoteData)) {
// FFZ Channel Emote
return appendEmote(MessageElement::FfzEmote);
}

4
src/providers/twitch/TwitchServer.cpp
View file

@ -155,7 +155,7 @@ void TwitchServer::forEachChannelAndSpecialChannels(std::function<void(ChannelPt
func(this->mentionsChannel);
}
std::shared_ptr<Channel> TwitchServer::getChannelOrEmptyByID(const QString &channelID)
std::shared_ptr<Channel> TwitchServer::getChannelOrEmptyByID(const QString &channelId)
{
std::lock_guard<std::mutex> lock(this->channelMutex);
@ -166,7 +166,7 @@ std::shared_ptr<Channel> TwitchServer::getChannelOrEmptyByID(const QString &chan
auto twitchChannel = std::dynamic_pointer_cast<TwitchChannel>(channel);
if (!twitchChannel) continue;
if (twitchChannel->getRoomID() == channelID) {
if (twitchChannel->getRoomId() == channelId) {
return twitchChannel;
}
}

8
src/widgets/dialogs/EmotePopup.cpp
View file

@ -56,7 +56,7 @@ void EmotePopup::loadChannel(ChannelPtr _channel)
ChannelPtr emoteChannel(new Channel("", Channel::Type::None));
auto addEmotes = [&](EmoteMap &map, const QString &title, const QString &emoteDesc) {
auto addEmotes = [&](const EmoteMap &map, const QString &title, const QString &emoteDesc) {
// TITLE
MessageBuilder builder1;
@ -120,12 +120,10 @@ void EmotePopup::loadChannel(ChannelPtr _channel)
}
addEmotes(app->emotes->bttv.globalEmotes, "BetterTTV Global Emotes", "BetterTTV Global Emote");
addEmotes(*channel->bttvChannelEmotes.get(), "BetterTTV Channel Emotes",
"BetterTTV Channel Emote");
addEmotes(channel->getBttvEmotes(), "BetterTTV Channel Emotes", "BetterTTV Channel Emote");
addEmotes(app->emotes->ffz.globalEmotes, "FrankerFaceZ Global Emotes",
"FrankerFaceZ Global Emote");
addEmotes(*channel->ffzChannelEmotes.get(), "FrankerFaceZ Channel Emotes",
"FrankerFaceZ Channel Emote");
addEmotes(channel->getFfzEmotes(), "FrankerFaceZ Channel Emotes", "FrankerFaceZ Channel Emote");
this->viewEmotes_->setChannel(emoteChannel);
}

50
src/widgets/splits/SplitHeader.cpp
View file

@ -80,9 +80,7 @@ SplitHeader::SplitHeader(Split *_split)
// dropdown->setScaleIndependantSize(23, 23);
this->addDropdownItems(dropdown.getElement());
QObject::connect(dropdown.getElement(), &RippleEffectButton::leftMousePress, this, [this] {
QTimer::singleShot(80, [&, this] {
this->dropdownMenu_.popup(QCursor::pos());
});
QTimer::singleShot(80, [&, this] { this->dropdownMenu_.popup(QCursor::pos()); });
});
}
@ -168,17 +166,17 @@ void SplitHeader::setupModeLabel(RippleEffectLabel &label)
label.setEnable(twitchChannel->hasModRights());
// set the label text
auto roomModes = twitchChannel->getRoomModes();
QString text;
if (roomModes.r9k)
text += "r9k, ";
if (roomModes.slowMode)
text += QString("slow(%1), ").arg(QString::number(roomModes.slowMode));
if (roomModes.emoteOnly)
text += "emote, ";
if (roomModes.submode)
text += "sub, ";
{
auto roomModes = twitchChannel->accessRoomModes();
if (roomModes->r9k) text += "r9k, ";
if (roomModes->slowMode)
text += QString("slow(%1), ").arg(QString::number(roomModes->slowMode));
if (roomModes->emoteOnly) text += "emote, ";
if (roomModes->submode) text += "sub, ";
}
if (text.length() > 2) {
text = text.mid(0, text.size() - 2);
@ -229,12 +227,12 @@ void SplitHeader::addModeActions(QMenu &menu)
return;
}
auto roomModes = twitchChannel->getRoomModes();
auto roomModes = twitchChannel->accessRoomModes();
setR9k->setChecked(roomModes.r9k);
setSlow->setChecked(roomModes.slowMode);
setEmote->setChecked(roomModes.emoteOnly);
setSub->setChecked(roomModes.submode);
setR9k->setChecked(roomModes->r9k);
setSlow->setChecked(roomModes->slowMode);
setEmote->setChecked(roomModes->emoteOnly);
setSub->setChecked(roomModes->submode);
}));
auto toggle = [this](const QString &_command, QAction *action) mutable {
@ -315,22 +313,22 @@ void SplitHeader::updateChannelText()
TwitchChannel *twitchChannel = dynamic_cast<TwitchChannel *>(channel.get());
if (twitchChannel != nullptr) {
const auto streamStatus = twitchChannel->getStreamStatus();
const auto streamStatus = twitchChannel->accessStreamStatus();
if (streamStatus.live) {
if (streamStatus->live) {
this->isLive_ = true;
this->tooltip_ = "<style>.center { text-align: center; }</style>"
"<p class = \"center\">" +
streamStatus.title + "<br><br>" + streamStatus.game + "<br>" +
(streamStatus.rerun ? "Vod-casting" : "Live") + " for " +
streamStatus.uptime + " with " +
QString::number(streamStatus.viewerCount) +
streamStatus->title + "<br><br>" + streamStatus->game + "<br>" +
(streamStatus->rerun ? "Vod-casting" : "Live") + " for " +
streamStatus->uptime + " with " +
QString::number(streamStatus->viewerCount) +
" viewers"
"</p>";
if (streamStatus.rerun) {
if (streamStatus->rerun) {
title += " (rerun)";
} else if (streamStatus.streamType.isEmpty()) {
title += " (" + streamStatus.streamType + ")";
} else if (streamStatus->streamType.isEmpty()) {
title += " (" + streamStatus->streamType + ")";
} else {
title += " (live)";
}