mirror-chatterino2/src/messages/MessageElement.hpp

388 lines
10 KiB
C++
Raw Normal View History

#pragma once
2018-08-07 07:55:31 +02:00
#include "common/FlagsEnum.hpp"
#include "messages/ImageSet.hpp"
2018-06-26 14:09:39 +02:00
#include "messages/Link.hpp"
#include "messages/MessageColor.hpp"
2018-06-28 19:46:45 +02:00
#include "singletons/Fonts.hpp"
#include <QRect>
#include <QString>
#include <QTime>
#include <boost/noncopyable.hpp>
#include <cstdint>
#include <memory>
#include <pajlada/signals/signalholder.hpp>
#include <vector>
namespace chatterino {
class Channel;
2018-01-28 03:29:42 +01:00
struct MessageLayoutContainer;
class MessageLayoutElement;
class Image;
using ImagePtr = std::shared_ptr<Image>;
struct Emote;
using EmotePtr = std::shared_ptr<const Emote>;
enum class MessageElementFlag : int64_t {
None = 0LL,
Misc = (1LL << 0),
Text = (1LL << 1),
2018-08-07 07:55:31 +02:00
Username = (1LL << 2),
Timestamp = (1LL << 3),
2018-08-07 07:55:31 +02:00
TwitchEmoteImage = (1LL << 4),
TwitchEmoteText = (1LL << 5),
2018-08-07 07:55:31 +02:00
TwitchEmote = TwitchEmoteImage | TwitchEmoteText,
BttvEmoteImage = (1LL << 6),
BttvEmoteText = (1LL << 7),
2018-08-07 07:55:31 +02:00
BttvEmote = BttvEmoteImage | BttvEmoteText,
ChannelPointReward = (1LL << 8),
ChannelPointRewardImage = ChannelPointReward | TwitchEmoteImage,
FfzEmoteImage = (1LL << 9),
FfzEmoteText = (1LL << 10),
2018-08-07 07:55:31 +02:00
FfzEmote = FfzEmoteImage | FfzEmoteText,
EmoteImages = TwitchEmoteImage | BttvEmoteImage | FfzEmoteImage,
EmoteText = TwitchEmoteText | BttvEmoteText | FfzEmoteText,
2018-08-07 07:55:31 +02:00
BitsStatic = (1LL << 11),
BitsAnimated = (1LL << 12),
2018-08-07 07:55:31 +02:00
// Slot 1: Twitch
// - Staff badge
// - Admin badge
// - Global Moderator badge
BadgeGlobalAuthority = (1LL << 13),
2018-08-07 07:55:31 +02:00
// Slot 2: Twitch
// - Predictions badge
BadgePredictions = (1LL << 14),
// Slot 3: Twitch
// - VIP badge
2018-08-07 07:55:31 +02:00
// - Moderator badge
// - Broadcaster badge
BadgeChannelAuthority = (1LL << 15),
2018-08-07 07:55:31 +02:00
// Slot 4: Twitch
2018-08-07 07:55:31 +02:00
// - Subscription badges
BadgeSubscription = (1LL << 16),
2018-08-07 07:55:31 +02:00
// Slot 5: Twitch
2018-08-07 07:55:31 +02:00
// - Turbo badge
// - Prime badge
// - Bit badges
// - Game badges
BadgeVanity = (1LL << 17),
2018-08-07 07:55:31 +02:00
// Slot 6: Chatterino
2018-08-07 07:55:31 +02:00
// - Chatterino developer badge
// - Chatterino contributor badge
2018-08-07 07:55:31 +02:00
// - Chatterino donator badge
// - Chatterino top donator badge
// - Chatterino special pepe badge
// - Chatterino gnome badge
BadgeChatterino = (1LL << 18),
// Slot 7: FrankerFaceZ
// - FFZ developer badge
// - FFZ bot badge
// - FFZ donator badge
BadgeFfz = (1LL << 19),
2018-08-07 07:55:31 +02:00
Badges = BadgeGlobalAuthority | BadgePredictions | BadgeChannelAuthority |
BadgeSubscription | BadgeVanity | BadgeChatterino | BadgeFfz,
2018-08-07 07:55:31 +02:00
ChannelName = (1LL << 20),
2018-08-07 07:55:31 +02:00
BitsAmount = (1LL << 21),
2018-08-07 07:55:31 +02:00
ModeratorTools = (1LL << 22),
2018-08-07 07:55:31 +02:00
EmojiImage = (1LL << 23),
EmojiText = (1LL << 24),
2018-08-07 07:55:31 +02:00
EmojiAll = EmojiImage | EmojiText,
AlwaysShow = (1LL << 25),
2018-08-07 07:55:31 +02:00
// used in the ChannelView class to make the collapse buttons visible if
// needed
Collapsed = (1LL << 26),
2018-08-07 07:55:31 +02:00
// used for dynamic bold usernames
BoldUsername = (1LL << 27),
NonBoldUsername = (1LL << 28),
2018-08-07 07:55:31 +02:00
// for links
LowercaseLink = (1LL << 29),
OriginalLink = (1LL << 30),
2018-08-07 07:55:31 +02:00
// ZeroWidthEmotes are emotes that are supposed to overlay over any pre-existing emotes
// e.g. BTTV's SoSnowy during christmas season
ZeroWidthEmote = (1LL << 31),
2018-08-07 07:55:31 +02:00
Default = Timestamp | Badges | Username | BitsStatic | FfzEmoteImage |
BttvEmoteImage | TwitchEmoteImage | BitsAmount | Text |
AlwaysShow,
};
using MessageElementFlags = FlagsEnum<MessageElementFlag>;
class MessageElement : boost::noncopyable
{
public:
enum UpdateFlags : char {
2018-08-07 07:55:31 +02:00
Update_Text = 1,
Update_Emotes = 2,
Update_Images = 4,
Update_All = Update_Text | Update_Emotes | Update_Images
};
enum ThumbnailType : char {
Link_Thumbnail = 1,
};
2018-04-06 16:37:30 +02:00
virtual ~MessageElement();
MessageElement *setLink(const Link &link);
MessageElement *setText(const QString &text);
MessageElement *setTooltip(const QString &tooltip);
MessageElement *setThumbnailType(const ThumbnailType type);
MessageElement *setThumbnail(const ImagePtr &thumbnail);
MessageElement *setTrailingSpace(bool value);
const QString &getTooltip() const;
const ImagePtr &getThumbnail() const;
const ThumbnailType &getThumbnailType() const;
const Link &getLink() const;
bool hasTrailingSpace() const;
2018-08-07 07:55:31 +02:00
MessageElementFlags getFlags() const;
MessageElement *updateLink();
2018-08-06 21:17:03 +02:00
virtual void addToContainer(MessageLayoutContainer &container,
2018-08-07 07:55:31 +02:00
MessageElementFlags flags) = 0;
pajlada::Signals::NoArgSignal linkChanged;
protected:
2018-08-07 07:55:31 +02:00
MessageElement(MessageElementFlags flags);
bool trailingSpace = true;
private:
QString text_;
2018-07-06 19:23:47 +02:00
Link link_;
QString tooltip_;
ImagePtr thumbnail_;
ThumbnailType thumbnailType_;
2018-08-07 07:55:31 +02:00
MessageElementFlags flags_;
};
// used when layout element doesn't have a creator
class EmptyElement : public MessageElement
{
public:
EmptyElement();
void addToContainer(MessageLayoutContainer &container,
MessageElementFlags flags) override;
static EmptyElement &instance();
private:
ImagePtr image_;
};
// contains a simple image
class ImageElement : public MessageElement
{
public:
2018-08-07 07:55:31 +02:00
ImageElement(ImagePtr image, MessageElementFlags flags);
2018-08-06 21:17:03 +02:00
void addToContainer(MessageLayoutContainer &container,
2018-08-07 07:55:31 +02:00
MessageElementFlags flags) override;
2018-07-06 19:23:47 +02:00
private:
2018-08-02 14:23:27 +02:00
ImagePtr image_;
};
// contains a text, it will split it into words
class TextElement : public MessageElement
{
public:
2018-08-07 07:55:31 +02:00
TextElement(const QString &text, MessageElementFlags flags,
const MessageColor &color = MessageColor::Text,
2018-05-23 04:22:17 +02:00
FontStyle style = FontStyle::ChatMedium);
~TextElement() override = default;
2018-08-06 21:17:03 +02:00
void addToContainer(MessageLayoutContainer &container,
2018-08-07 07:55:31 +02:00
MessageElementFlags flags) override;
2018-07-06 19:23:47 +02:00
private:
MessageColor color_;
FontStyle style_;
struct Word {
QString text;
int width = -1;
};
std::vector<Word> words_;
};
2018-01-22 22:38:44 +01:00
// contains emote data and will pick the emote based on :
// a) are images for the emote type enabled
// b) which size it wants
class EmoteElement : public MessageElement
{
public:
2018-08-07 07:55:31 +02:00
EmoteElement(const EmotePtr &data, MessageElementFlags flags_);
2018-01-22 22:38:44 +01:00
2018-08-06 21:17:03 +02:00
void addToContainer(MessageLayoutContainer &container,
2018-08-07 07:55:31 +02:00
MessageElementFlags flags_) override;
2018-08-02 14:23:27 +02:00
EmotePtr getEmote() const;
2018-07-06 19:23:47 +02:00
protected:
virtual MessageLayoutElement *makeImageLayoutElement(const ImagePtr &image,
const QSize &size);
2018-07-06 19:23:47 +02:00
private:
std::unique_ptr<TextElement> textElement_;
2018-08-02 14:23:27 +02:00
EmotePtr emote_;
2018-01-22 22:38:44 +01:00
};
class BadgeElement : public MessageElement
{
public:
BadgeElement(const EmotePtr &data, MessageElementFlags flags_);
void addToContainer(MessageLayoutContainer &container,
MessageElementFlags flags_) override;
2019-08-21 01:52:01 +02:00
EmotePtr getEmote() const;
protected:
virtual MessageLayoutElement *makeImageLayoutElement(const ImagePtr &image,
const QSize &size);
private:
EmotePtr emote_;
};
class ModBadgeElement : public BadgeElement
{
public:
ModBadgeElement(const EmotePtr &data, MessageElementFlags flags_);
protected:
MessageLayoutElement *makeImageLayoutElement(const ImagePtr &image,
const QSize &size) override;
};
class VipBadgeElement : public BadgeElement
{
public:
VipBadgeElement(const EmotePtr &data, MessageElementFlags flags_);
protected:
MessageLayoutElement *makeImageLayoutElement(const ImagePtr &image,
const QSize &size) override;
};
class FfzBadgeElement : public BadgeElement
{
public:
FfzBadgeElement(const EmotePtr &data, MessageElementFlags flags_,
QColor &color);
protected:
MessageLayoutElement *makeImageLayoutElement(const ImagePtr &image,
const QSize &size) override;
QColor color;
};
// contains a text, formated depending on the preferences
class TimestampElement : public MessageElement
{
public:
2018-07-06 18:29:29 +02:00
TimestampElement(QTime time_ = QTime::currentTime());
~TimestampElement() override = default;
2018-08-06 21:17:03 +02:00
void addToContainer(MessageLayoutContainer &container,
2018-08-07 07:55:31 +02:00
MessageElementFlags flags) override;
2018-07-06 19:23:47 +02:00
TextElement *formatTime(const QTime &time);
2018-07-06 18:29:29 +02:00
private:
QTime time_;
std::unique_ptr<TextElement> element_;
QString format_;
};
2018-08-06 21:17:03 +02:00
// adds all the custom moderation buttons, adds a variable amount of items
// depending on settings fourtf: implement
class TwitchModerationElement : public MessageElement
{
public:
TwitchModerationElement();
2018-08-06 21:17:03 +02:00
void addToContainer(MessageLayoutContainer &container,
2018-08-07 07:55:31 +02:00
MessageElementFlags flags) override;
};
// contains a full message string that's split into words on space and parses IRC colors that are then put into segments
// these segments are later passed to "MultiColorTextLayoutElement" elements to be rendered :)
class IrcTextElement : public MessageElement
{
public:
IrcTextElement(const QString &text, MessageElementFlags flags,
FontStyle style = FontStyle::ChatMedium);
~IrcTextElement() override = default;
void addToContainer(MessageLayoutContainer &container,
MessageElementFlags flags) override;
private:
FontStyle style_;
struct Segment {
QString text;
int fg = -1;
int bg = -1;
};
struct Word {
QString text;
int width = -1;
std::vector<Segment> segments;
};
std::vector<Word> words_;
};
// Forces a linebreak
class LinebreakElement : public MessageElement
{
public:
LinebreakElement(MessageElementFlags flags);
void addToContainer(MessageLayoutContainer &container,
MessageElementFlags flags) override;
};
// Image element which will pick the quality of the image based on ui scale
class ScalingImageElement : public MessageElement
{
public:
ScalingImageElement(ImageSet images, MessageElementFlags flags);
void addToContainer(MessageLayoutContainer &container,
MessageElementFlags flags) override;
private:
ImageSet images_;
};
} // namespace chatterino