+ break;
+ case NetworkModel::UserCategoryItemType:
+ fmt.merge(_listItemFormats.value(NickViewItem | 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(quint32 formatType, quint32 messageLabel) const
+{
+ return _formatCache.value(formatType | ((quint64)messageLabel << 32), QTextCharFormat());
+}
+
+
+void UiStyle::setCachedFormat(const QTextCharFormat &format, quint32 formatType, quint32 messageLabel) const
+{
+ _formatCache[formatType | ((quint64)messageLabel << 32)] = format;
+}
+
+
+QFontMetricsF *UiStyle::fontMetrics(quint32 ftype, quint32 label) const
+{
+ // QFontMetricsF is not assignable, so we need to store pointers :/
+ quint64 key = ftype | ((quint64)label << 32);
+
+ 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(quint32 ftype, quint32 label_) const
+{
+ if (ftype == Invalid)
+ return QTextCharFormat();
+
+ quint64 label = (quint64)label_ << 32;
+
+ // 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 & Q_UINT64_C(0xffff000000000000));
+
+ for (quint64 mask = Q_UINT64_C(0x0000000100000000); mask <= (quint64)Selected << 32; mask <<= 1) {
+ if (label & mask)
+ mergeFormat(fmt, ftype, mask | Q_UINT64_C(0xffff000000000000));
+ }
+
+ setCachedFormat(fmt, ftype, label_);
+ return fmt;
+}
+
+
+void UiStyle::mergeFormat(QTextCharFormat &fmt, quint32 ftype, quint64 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)) { // element format
+ for (quint32 mask = 0x00100; mask <= 0x40000; mask <<= 1) {
+ if (ftype & mask) {
+ 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)
+ mergeSubElementFormat(fmt, ftype & 0x0f400000, label); // foreground
+ if (ftype & 0x00800000)
+ mergeSubElementFormat(fmt, ftype & 0xf0800000, label); // background
+ if ((ftype & 0x00c00000) == 0x00c00000)
+ mergeSubElementFormat(fmt, ftype & 0xffc00000, label); // combination
+ }
+
+ // URL
+ if (ftype & Url)
+ mergeSubElementFormat(fmt, ftype & (Url | 0x000000ff), label);
+}
+
+
+// Merge a subelement format into an existing message format
+void UiStyle::mergeSubElementFormat(QTextCharFormat &fmt, quint32 ftype, quint64 label) const
+{
+ quint64 key = ftype | label;
+ fmt.merge(format(key & Q_UINT64_C(0x0000ffffffffff00))); // label + subelement
+ fmt.merge(format(key & Q_UINT64_C(0x0000ffffffffffff))); // label + subelement + msgtype
+ fmt.merge(format(key & Q_UINT64_C(0xffffffffffffff00))); // label + subelement + nickhash
+ fmt.merge(format(key & Q_UINT64_C(0xffffffffffffffff))); // label + subelement + nickhash + msgtype
+}
+
+
+UiStyle::FormatType UiStyle::formatType(Message::Type msgType)
+{
+ switch (msgType) {
+ case Message::Plain:
+ return PlainMsg;
+ case Message::Notice:
+ return NoticeMsg;
+ case Message::Action:
+ return ActionMsg;
+ case Message::Nick:
+ return NickMsg;
+ case Message::Mode:
+ return ModeMsg;
+ case Message::Join:
+ return JoinMsg;
+ case Message::Part:
+ return PartMsg;
+ case Message::Quit:
+ return QuitMsg;
+ case Message::Kick:
+ return KickMsg;
+ case Message::Kill:
+ return KillMsg;
+ case Message::Server:
+ return ServerMsg;
+ case Message::Info:
+ return InfoMsg;
+ case Message::Error:
+ return ErrorMsg;
+ case Message::DayChange:
+ return DayChangeMsg;
+ case Message::Topic:
+ return TopicMsg;
+ case Message::NetsplitJoin:
+ return NetsplitJoinMsg;
+ case Message::NetsplitQuit:
+ return NetsplitQuitMsg;
+ case Message::Invite:
+ return InviteMsg;
+ }
+ //Q_ASSERT(false); // we need to handle all message types
+ qWarning() << Q_FUNC_INFO << "Unknown message type:" << msgType;
+ return ErrorMsg;
+}
+
+
+UiStyle::FormatType UiStyle::formatType(const QString &code)
+{
+ if (_formatCodes.contains(code)) return _formatCodes.value(code);
+ return Invalid;
+}
+
+
+QString UiStyle::formatCode(FormatType ftype)
+{
+ return _formatCodes.key(ftype);
+}
+
+
+QList<QTextLayout::FormatRange> UiStyle::toTextLayoutList(const FormatList &formatList, int textLength, quint32 messageLabel) const
+{
+ QList<QTextLayout::FormatRange> formatRanges;
+ QTextLayout::FormatRange range;
+ int i = 0;
+ for (i = 0; i < formatList.count(); i++) {
+ range.format = format(formatList.at(i).second, 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_, quint32 baseFormat)
+{
+ QString s = s_;
+ if (s.length() > 65535) {
+ qWarning() << QString("String too long to be styled: %1").arg(s);
+ return StyledString();
+ }
+ StyledString result;
+ result.formatList.append(qMakePair((quint16)0, baseFormat));
+ quint32 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 == 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.last().first)
+ result.formatList.last().second = curfmt;
+ else
+ result.formatList.append(qMakePair((quint16)pos, 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());
+ }