+ // 24-hour style used
+ _systemTimestampFormatString = " hh:mm:ss";
+ }
+ // Include a space to give the timestamp a small bit of padding between the border of the chat
+ // buffer window and the numbers. Helps with readability.
+ // If you change this to include brackets, e.g. "[hh:mm:ss]", also update
+ // ChatScene::updateTimestampHasBrackets() to true or false as needed!
+}
+
+
+// FIXME The following should trigger a reload/refresh of the chat view.
+void UiStyle::setUseCustomTimestampFormat(bool enabled)
+{
+ if (_useCustomTimestampFormat != enabled) {
+ _useCustomTimestampFormat = enabled;
+ }
+}
+
+void UiStyle::setTimestampFormatString(const QString &format)
+{
+ if (_timestampFormatString != format) {
+ _timestampFormatString = format;
+ }
+}
+
+void UiStyle::enableSenderPrefixes(bool enabled)
+{
+ if (_showSenderPrefixes != enabled) {
+ _showSenderPrefixes = enabled;
+ }
+}
+
+void UiStyle::enableSenderBrackets(bool enabled)
+{
+ if (_showSenderBrackets != enabled) {
+ _showSenderBrackets = enabled;
+ }
+}
+
+
+void UiStyle::allowMircColorsChanged(const QVariant &v)
+{
+ _allowMircColors = v.toBool();
+ emit changed();
+}
+
+
+/******** ItemView Styling *******/
+
+void UiStyle::showItemViewIconsChanged(const QVariant &v)
+{
+ _showBufferViewIcons = _showNickViewIcons = v.toBool();
+}
+
+
+QVariant UiStyle::bufferViewItemData(const QModelIndex &index, int role) const
+{
+ BufferInfo::Type type = (BufferInfo::Type)index.data(NetworkModel::BufferTypeRole).toInt();
+ bool isActive = index.data(NetworkModel::ItemActiveRole).toBool();
+
+ if (role == Qt::DecorationRole) {
+ if (!_showBufferViewIcons)
+ return QVariant();
+
+ switch (type) {
+ case BufferInfo::ChannelBuffer:
+ if (isActive)
+ return _channelJoinedIcon;
+ else
+ return _channelPartedIcon;
+ case BufferInfo::QueryBuffer:
+ if (!isActive)
+ return _userOfflineIcon;
+ if (index.data(NetworkModel::UserAwayRole).toBool())
+ return _userAwayIcon;
+ else
+ return _userOnlineIcon;
+ default:
+ return QVariant();
+ }
+ }
+
+ ItemFormatType fmtType = ItemFormatType::BufferViewItem;
+ switch (type) {
+ case BufferInfo::StatusBuffer:
+ fmtType |= ItemFormatType::NetworkItem;
+ break;
+ case BufferInfo::ChannelBuffer:
+ fmtType |= ItemFormatType::ChannelBufferItem;
+ break;
+ case BufferInfo::QueryBuffer:
+ fmtType |= ItemFormatType::QueryBufferItem;
+ break;
+ default:
+ return QVariant();
+ }
+
+ QTextCharFormat fmt = _listItemFormats.value(ItemFormatType::BufferViewItem);
+ fmt.merge(_listItemFormats.value(fmtType));
+
+ BufferInfo::ActivityLevel activity = (BufferInfo::ActivityLevel)index.data(NetworkModel::BufferActivityRole).toInt();
+ if (activity & BufferInfo::Highlight) {
+ fmt.merge(_listItemFormats.value(ItemFormatType::BufferViewItem | ItemFormatType::HighlightedBuffer));
+ fmt.merge(_listItemFormats.value(fmtType | ItemFormatType::HighlightedBuffer));
+ }
+ else if (activity & BufferInfo::NewMessage) {
+ fmt.merge(_listItemFormats.value(ItemFormatType::BufferViewItem | ItemFormatType::UnreadBuffer));
+ fmt.merge(_listItemFormats.value(fmtType | ItemFormatType::UnreadBuffer));
+ }
+ else if (activity & BufferInfo::OtherActivity) {
+ fmt.merge(_listItemFormats.value(ItemFormatType::BufferViewItem | ItemFormatType::ActiveBuffer));
+ fmt.merge(_listItemFormats.value(fmtType | ItemFormatType::ActiveBuffer));
+ }
+ else if (!isActive) {
+ fmt.merge(_listItemFormats.value(ItemFormatType::BufferViewItem | ItemFormatType::InactiveBuffer));
+ fmt.merge(_listItemFormats.value(fmtType | ItemFormatType::InactiveBuffer));
+ }
+ else if (index.data(NetworkModel::UserAwayRole).toBool()) {
+ fmt.merge(_listItemFormats.value(ItemFormatType::BufferViewItem | ItemFormatType::UserAway));
+ fmt.merge(_listItemFormats.value(fmtType | ItemFormatType::UserAway));
+ }
+
+ return itemData(role, fmt);
+}
+
+
+QVariant UiStyle::nickViewItemData(const QModelIndex &index, int role) const
+{
+ NetworkModel::ItemType type = (NetworkModel::ItemType)index.data(NetworkModel::ItemTypeRole).toInt();
+
+ if (role == Qt::DecorationRole) {
+ if (!_showNickViewIcons)
+ return QVariant();
+
+ switch (type) {
+ case NetworkModel::UserCategoryItemType:
+ {
+ int categoryId = index.data(TreeModel::SortRole).toInt();
+ if (categoryId <= _opIconLimit)
+ return _categoryOpIcon;
+ if (categoryId <= _voiceIconLimit)
+ return _categoryVoiceIcon;
+ return _userOnlineIcon;
+ }
+ case NetworkModel::IrcUserItemType:
+ if (index.data(NetworkModel::ItemActiveRole).toBool())
+ return _userOnlineIcon;
+ else
+ return _userAwayIcon;
+ default:
+ return QVariant();
+ }
+ }
+
+ QTextCharFormat fmt = _listItemFormats.value(ItemFormatType::NickViewItem);
+
+ switch (type) {
+ case NetworkModel::IrcUserItemType:
+ fmt.merge(_listItemFormats.value(ItemFormatType::NickViewItem | ItemFormatType::IrcUserItem));
+ if (!index.data(NetworkModel::ItemActiveRole).toBool()) {
+ fmt.merge(_listItemFormats.value(ItemFormatType::NickViewItem | ItemFormatType::UserAway));
+ fmt.merge(_listItemFormats.value(ItemFormatType::NickViewItem | ItemFormatType::IrcUserItem | ItemFormatType::UserAway));
+ }
+ break;
+ case NetworkModel::UserCategoryItemType:
+ fmt.merge(_listItemFormats.value(ItemFormatType::NickViewItem | ItemFormatType::UserCategoryItem));
+ break;
+ default:
+ return QVariant();
+ }
+
+ return itemData(role, fmt);
+}
+
+
+QVariant UiStyle::itemData(int role, const QTextCharFormat &format) const
+{
+ switch (role) {
+ case Qt::FontRole:
+ return format.font();
+ case Qt::ForegroundRole:
+ return format.property(QTextFormat::ForegroundBrush);
+ case Qt::BackgroundRole:
+ return format.property(QTextFormat::BackgroundBrush);
+ default:
+ return QVariant();
+ }
+}
+
+
+/******** Caching *******/
+
+QTextCharFormat UiStyle::format(quint64 key) const
+{
+ return _formats.value(key, QTextCharFormat());
+}
+
+
+QTextCharFormat UiStyle::cachedFormat(FormatType formatType, MessageLabel messageLabel) const
+{
+ return _formatCache.value(formatType | messageLabel, QTextCharFormat());
+}
+
+
+void UiStyle::setCachedFormat(const QTextCharFormat &format, FormatType formatType, MessageLabel messageLabel) const
+{
+ _formatCache[formatType | messageLabel] = format;
+}
+
+
+QFontMetricsF *UiStyle::fontMetrics(FormatType ftype, MessageLabel label) const
+{
+ // QFontMetricsF is not assignable, so we need to store pointers :/
+ quint64 key = ftype | label;
+
+ if (_metricsCache.contains(key))
+ return _metricsCache.value(key);
+
+ return (_metricsCache[key] = new QFontMetricsF(format(ftype, label).font()));
+}
+
+
+/******** Generate formats ********/
+
+// NOTE: This and the following functions are intimately tied to the values in FormatType. Don't change this
+// until you _really_ know what you do!
+QTextCharFormat UiStyle::format(FormatType ftype, MessageLabel label) const
+{
+ if (ftype == FormatType::Invalid)
+ return {};
+
+ // check if we have exactly this format readily cached already
+ QTextCharFormat fmt = cachedFormat(ftype, label);
+ if (fmt.properties().count())
+ return fmt;
+
+ mergeFormat(fmt, ftype, label & 0xffff0000); // keep nickhash in label
+
+ for (quint32 mask = 0x00000001; mask <= static_cast<quint32>(MessageLabel::Selected); mask <<= 1) {
+ if (static_cast<quint32>(label) & mask)
+ mergeFormat(fmt, ftype, label & (mask | 0xffff0000));
+ }
+
+ setCachedFormat(fmt, ftype, label);
+ return fmt;
+}
+
+
+void UiStyle::mergeFormat(QTextCharFormat &fmt, FormatType ftype, MessageLabel label) const
+{
+ mergeSubElementFormat(fmt, ftype & 0x00ff, label);
+
+ // TODO: allow combinations for mirc formats and colors (each), e.g. setting a special format for "bold and italic"
+ // or "foreground 01 and background 03"
+ if ((ftype & 0xfff00) != FormatType::Base) { // element format
+ for (quint32 mask = 0x00100; mask <= 0x40000; mask <<= 1) {
+ if ((ftype & mask) != FormatType::Base) {
+ mergeSubElementFormat(fmt, ftype & (mask | 0xff), label);
+ }
+ }
+ }
+
+ // Now we handle color codes
+ // We assume that those can't be combined with subelement and message types.
+ if (_allowMircColors) {
+ if ((ftype & 0x00400000) != FormatType::Base)
+ mergeSubElementFormat(fmt, ftype & 0x0f400000, label); // foreground
+ if ((ftype & 0x00800000) != FormatType::Base)
+ mergeSubElementFormat(fmt, ftype & 0xf0800000, label); // background
+ if ((ftype & 0x00c00000) == static_cast<FormatType>(0x00c00000))
+ mergeSubElementFormat(fmt, ftype & 0xffc00000, label); // combination
+ }
+
+ // URL
+ if ((ftype & FormatType::Url) != FormatType::Base)
+ mergeSubElementFormat(fmt, ftype & (FormatType::Url | static_cast<FormatType>(0x000000ff)), label);
+}
+
+
+// Merge a subelement format into an existing message format
+void UiStyle::mergeSubElementFormat(QTextCharFormat &fmt, FormatType ftype, MessageLabel label) const
+{
+ quint64 key = ftype | label;
+ fmt.merge(format(key & 0x0000ffffffffff00ull)); // label + subelement
+ fmt.merge(format(key & 0x0000ffffffffffffull)); // label + subelement + msgtype
+ fmt.merge(format(key & 0xffffffffffffff00ull)); // label + subelement + nickhash
+ fmt.merge(format(key & 0xffffffffffffffffull)); // label + subelement + nickhash + msgtype
+}
+
+
+UiStyle::FormatType UiStyle::formatType(Message::Type msgType)
+{
+ switch (msgType) {
+ case Message::Plain:
+ return FormatType::PlainMsg;
+ case Message::Notice:
+ return FormatType::NoticeMsg;
+ case Message::Action:
+ return FormatType::ActionMsg;
+ case Message::Nick:
+ return FormatType::NickMsg;
+ case Message::Mode:
+ return FormatType::ModeMsg;
+ case Message::Join:
+ return FormatType::JoinMsg;
+ case Message::Part:
+ return FormatType::PartMsg;
+ case Message::Quit:
+ return FormatType::QuitMsg;
+ case Message::Kick:
+ return FormatType::KickMsg;
+ case Message::Kill:
+ return FormatType::KillMsg;
+ case Message::Server:
+ return FormatType::ServerMsg;
+ case Message::Info:
+ return FormatType::InfoMsg;
+ case Message::Error:
+ return FormatType::ErrorMsg;
+ case Message::DayChange:
+ return FormatType::DayChangeMsg;
+ case Message::Topic:
+ return FormatType::TopicMsg;
+ case Message::NetsplitJoin:
+ return FormatType::NetsplitJoinMsg;
+ case Message::NetsplitQuit:
+ return FormatType::NetsplitQuitMsg;
+ case Message::Invite:
+ return FormatType::InviteMsg;
+ }
+ //Q_ASSERT(false); // we need to handle all message types
+ qWarning() << Q_FUNC_INFO << "Unknown message type:" << msgType;
+ return FormatType::ErrorMsg;
+}
+
+
+UiStyle::FormatType UiStyle::formatType(const QString &code)
+{
+ if (_formatCodes.contains(code))
+ return _formatCodes.value(code);
+ return FormatType::Invalid;
+}
+
+
+QString UiStyle::formatCode(FormatType ftype)
+{
+ return _formatCodes.key(ftype);
+}
+
+
+QList<QTextLayout::FormatRange> UiStyle::toTextLayoutList(const FormatList &formatList, int textLength, MessageLabel messageLabel) const
+{
+ QList<QTextLayout::FormatRange> formatRanges;
+ QTextLayout::FormatRange range;
+ size_t i = 0;
+ for (i = 0; i < formatList.size(); i++) {
+ range.format = format(formatList.at(i).second.type, messageLabel);
+ range.start = formatList.at(i).first;
+ if (i > 0)
+ formatRanges.last().length = range.start - formatRanges.last().start;
+ formatRanges.append(range);
+ }
+ if (i > 0)
+ formatRanges.last().length = textLength - formatRanges.last().start;
+ return formatRanges;
+}
+
+
+// This method expects a well-formatted string, there is no error checking!
+// Since we create those ourselves, we should be pretty safe that nobody does something crappy here.
+UiStyle::StyledString UiStyle::styleString(const QString &s_, FormatType baseFormat)
+{
+ QString s = s_;
+ StyledString result;
+ result.formatList.emplace_back(std::make_pair(quint16{0}, Format{baseFormat}));
+
+ if (s.length() > 65535) {
+ // We use quint16 for indexes
+ qWarning() << QString("String too long to be styled: %1").arg(s);
+ result.plainText = s;
+ return result;
+ }
+
+ FormatType curfmt = baseFormat;
+
+ int pos = 0; quint16 length = 0;
+ for (;;) {
+ pos = s.indexOf('%', pos);
+ if (pos < 0) break;
+ if (s[pos+1] == '%') { // escaped %, we just remove one and continue
+ s.remove(pos, 1);
+ pos++;
+ continue;
+ }
+ if (s[pos+1] == 'D' && s[pos+2] == 'c') { // color code
+ if (s[pos+3] == '-') { // color off
+ curfmt &= 0x003fffff;
+ length = 4;
+ }
+ else {
+ int color = 10 * s[pos+4].digitValue() + s[pos+5].digitValue();
+ //TODO: use 99 as transparent color (re mirc color "standard")
+ color &= 0x0f;
+ if (s[pos+3] == 'f') {
+ curfmt &= 0xf0ffffff;
+ curfmt |= (quint32)(color << 24) | 0x00400000;
+ }
+ else {
+ curfmt &= 0x0fffffff;
+ curfmt |= (quint32)(color << 28) | 0x00800000;
+ }
+ length = 6;
+ }
+ }
+ else if (s[pos+1] == 'O') { // reset formatting
+ curfmt &= 0x000000ff; // we keep message type-specific formatting
+ length = 2;
+ }
+ else if (s[pos+1] == 'R') { // reverse
+ // TODO: implement reverse formatting
+
+ length = 2;
+ }
+ else { // all others are toggles
+ QString code = QString("%") + s[pos+1];
+ if (s[pos+1] == 'D') code += s[pos+2];
+ FormatType ftype = formatType(code);
+ if (ftype == FormatType::Invalid) {
+ pos++;
+ qWarning() << (QString("Invalid format code in string: %1").arg(s));
+ continue;
+ }
+ curfmt ^= ftype;
+ length = code.length();
+ }
+ s.remove(pos, length);
+ if (pos == result.formatList.back().first)
+ result.formatList.back().second.type = curfmt;
+ else
+ result.formatList.emplace_back(std::make_pair(pos, Format{curfmt}));
+ }
+ result.plainText = s;
+ return result;
+}
+
+
+QString UiStyle::mircToInternal(const QString &mirc_)
+{
+ QString mirc;
+ mirc.reserve(mirc_.size());
+ foreach (const QChar &c, mirc_) {
+ if ((c < '\x20' || c == '\x7f') && c != '\x03') {
+ switch (c.unicode()) {
+ case '\x02':
+ mirc += "%B";
+ break;
+ case '\x0f':
+ mirc += "%O";
+ break;
+ case '\x09':
+ mirc += " ";
+ break;
+ case '\x12':
+ case '\x16':
+ mirc += "%R";
+ break;
+ case '\x1d':
+ mirc += "%S";
+ break;
+ case '\x1f':
+ mirc += "%U";
+ break;
+ case '\x7f':
+ mirc += QChar(0x2421);
+ break;
+ default:
+ mirc += QChar(0x2400 + c.unicode());
+ }