From 90eb5244fb07eb2371279c12266fca06d0fed23c Mon Sep 17 00:00:00 2001 From: Manuel Nickschas Date: Thu, 26 Mar 2009 10:43:10 +0100 Subject: [PATCH] Introducing QssParser This parses our extensions to Qt stylesheets. So far, we can modify the application palette as follows: Palette { base: white; text: rgb(128, 128, 255); window-text: #12ffaa33; ... } The roles and brush/color definitions follow the Qt stylesheet syntax; note that we allow for styling all of the palette roles (including things like tooltip-base, which are not included in Qt's list of stylable roles). --- src/uisupport/uistyle.cpp | 283 ++++++++++++++++++++++++++++++++++++++ src/uisupport/uistyle.h | 60 +++++++- 2 files changed, 341 insertions(+), 2 deletions(-) diff --git a/src/uisupport/uistyle.cpp b/src/uisupport/uistyle.cpp index 84da3062..1fc19dbd 100644 --- a/src/uisupport/uistyle.cpp +++ b/src/uisupport/uistyle.cpp @@ -105,6 +105,7 @@ UiStyle::UiStyle(const QString &settingsKey) : _settingsKey(settingsKey) { QTextCharFormat underline; underline.setFontUnderline(true); setFormat(Underline, underline, Settings::Default); + loadStyleSheet(); // All other formats should be defined in derived classes. } @@ -531,3 +532,285 @@ QDataStream &operator>>(QDataStream &in, UiStyle::FormatList &formatList) { } return in; } + +/***********************************************************************************/ +// Stylesheet handling +/***********************************************************************************/ + +void UiStyle::loadStyleSheet() { + QssParser parser; + parser.loadStyleSheet(qApp->styleSheet()); + + // TODO handle results + QApplication::setPalette(parser.palette()); +} + +UiStyle::QssParser::QssParser() { + _palette = QApplication::palette(); + + // Init palette color roles + _paletteColorRoles["alternate-base"] = QPalette::AlternateBase; + _paletteColorRoles["background"] = QPalette::Background; + _paletteColorRoles["base"] = QPalette::Base; + _paletteColorRoles["bright-text"] = QPalette::BrightText; + _paletteColorRoles["button"] = QPalette::Button; + _paletteColorRoles["button-text"] = QPalette::ButtonText; + _paletteColorRoles["dark"] = QPalette::Dark; + _paletteColorRoles["foreground"] = QPalette::Foreground; + _paletteColorRoles["highlight"] = QPalette::Highlight; + _paletteColorRoles["highlighted-text"] = QPalette::HighlightedText; + _paletteColorRoles["light"] = QPalette::Light; + _paletteColorRoles["link"] = QPalette::Link; + _paletteColorRoles["link-visited"] = QPalette::LinkVisited; + _paletteColorRoles["mid"] = QPalette::Mid; + _paletteColorRoles["midlight"] = QPalette::Midlight; + _paletteColorRoles["shadow"] = QPalette::Shadow; + _paletteColorRoles["text"] = QPalette::Text; + _paletteColorRoles["tooltip-base"] = QPalette::ToolTipBase; + _paletteColorRoles["tooltip-text"] = QPalette::ToolTipText; + _paletteColorRoles["window"] = QPalette::Window; + _paletteColorRoles["window-text"] = QPalette::WindowText; +} + +void UiStyle::QssParser::loadStyleSheet(const QString &styleSheet) { + QString ss = styleSheet; + ss = "file:////home/sputnick/devel/quassel/test.qss"; // FIXME + if(ss.startsWith("file:///")) { + ss.remove(0, 8); + QFile file(ss); + if(file.open(QFile::ReadOnly)) { + QTextStream stream(&file); + ss = stream.readAll(); + } else { + qWarning() << tr("Could not read stylesheet \"%1\"!").arg(file.fileName()); + return; + } + } + if(ss.isEmpty()) + return; + + // Now we have the stylesheet itself in ss, start parsing + QRegExp blockrx("((ChatLine|Palette)[^{]*)\\{([^}]+)\\}"); + int pos = 0; + while((pos = blockrx.indexIn(ss, pos)) >= 0) { + //qDebug() << blockrx.cap(1) << blockrx.cap(3); + + if(blockrx.cap(2) == "ChatLine") + parseChatLineData(blockrx.cap(1).trimmed(), blockrx.cap(3).trimmed()); + else + parsePaletteData(blockrx.cap(1).trimmed(), blockrx.cap(3).trimmed()); + + pos += blockrx.matchedLength(); + } + +} + +void UiStyle::QssParser::parseChatLineData(const QString &decl, const QString &contents) { + + +} + +// Palette { ... } specifies the application palette +// ColorGroups can be specified like pseudo states, chaining is OR (contrary to normal CSS handling): +// Palette:inactive:disabled { ... } applies to both the Inactive and the Disabled state +void UiStyle::QssParser::parsePaletteData(const QString &decl, const QString &contents) { + QList colorGroups; + + // Check if we want to apply this palette definition for particular ColorGroups + QRegExp rx("Palette((:(normal|active|inactive|disabled))*)"); + if(!rx.exactMatch(decl)) { + qWarning() << tr("Invalid block declaration: %1").arg(decl); + return; + } + if(!rx.cap(1).isEmpty()) { + QStringList groups = rx.cap(1).split(':', QString::SkipEmptyParts); + foreach(QString g, groups) { + if((g == "normal" || g == "active") && !colorGroups.contains(QPalette::Active)) + colorGroups.append(QPalette::Active); + else if(g == "inactive" && !colorGroups.contains(QPalette::Inactive)) + colorGroups.append(QPalette::Inactive); + else if(g == "disabled" && !colorGroups.contains(QPalette::Disabled)) + colorGroups.append(QPalette::Disabled); + } + } + + // Now let's go through the roles + foreach(QString line, contents.split(';', QString::SkipEmptyParts)) { + int idx = line.indexOf(':'); + if(idx <= 0) { + qWarning() << tr("Invalid palette role assignment: %1").arg(line.trimmed()); + continue; + } + QString rolestr = line.left(idx).trimmed(); + QString brushstr = line.mid(idx + 1).trimmed(); + if(!_paletteColorRoles.contains(rolestr)) { + qWarning() << tr("Unknown palette role name: %1").arg(rolestr); + continue; + } + QBrush brush = parseBrushValue(brushstr); + if(colorGroups.count()) { + foreach(QPalette::ColorGroup group, colorGroups) + _palette.setBrush(group, _paletteColorRoles.value(rolestr), brush); + } else + _palette.setBrush(_paletteColorRoles.value(rolestr), brush); + } +} + +QBrush UiStyle::QssParser::parseBrushValue(const QString &str) { + QColor c = parseColorValue(str); + if(c.isValid()) + return QBrush(c); + + if(str.startsWith("palette")) { // Palette color role + QRegExp rx("palette\\s*\\(\\s*([a-z-]+)\\s*\\)"); + if(!rx.exactMatch(str)) { + qWarning() << tr("Invalid palette color role specification: %1").arg(str); + return QBrush(); + } + if(!_paletteColorRoles.contains(rx.cap(1))) { + qWarning() << tr("Unknown palette color role: %1").arg(rx.cap(1)); + return QBrush(); + } + return QBrush(_palette.brush(_paletteColorRoles.value(rx.cap(1)))); + + } else if(str.startsWith("qlineargradient")) { + static QString rxFloat("\\s*(-?\\s*[0-9]*\\.?[0-9]+)\\s*"); + QRegExp rx(QString("qlineargradient\\s*\\(\\s*x1:%1,\\s*y1:%1,\\s*x2:%1,\\s*y2:%1,(.+)\\)").arg(rxFloat)); + if(!rx.exactMatch(str)) { + qWarning() << tr("Invalid gradient declaration: %1").arg(str); + return QBrush(); + } + qreal x1 = rx.cap(1).toDouble(); + qreal y1 = rx.cap(2).toDouble(); + qreal x2 = rx.cap(3).toDouble(); + qreal y2 = rx.cap(4).toDouble(); + QGradientStops stops = parseGradientStops(rx.cap(5).trimmed()); + if(!stops.count()) { + qWarning() << tr("Invalid gradient stops list: %1").arg(str); + return QBrush(); + } + QLinearGradient gradient(x1, y1, x2, y2); + gradient.setStops(stops); + return QBrush(gradient); + + } else if(str.startsWith("qconicalgradient")) { + static QString rxFloat("\\s*(-?\\s*[0-9]*\\.?[0-9]+)\\s*"); + QRegExp rx(QString("qconicalgradient\\s*\\(\\s*cx:%1,\\s*cy:%1,\\s*angle:%1,(.+)\\)").arg(rxFloat)); + if(!rx.exactMatch(str)) { + qWarning() << tr("Invalid gradient declaration: %1").arg(str); + return QBrush(); + } + qreal cx = rx.cap(1).toDouble(); + qreal cy = rx.cap(2).toDouble(); + qreal angle = rx.cap(3).toDouble(); + QGradientStops stops = parseGradientStops(rx.cap(4).trimmed()); + if(!stops.count()) { + qWarning() << tr("Invalid gradient stops list: %1").arg(str); + return QBrush(); + } + QConicalGradient gradient(cx, cy, angle); + gradient.setStops(stops); + return QBrush(gradient); + + } else if(str.startsWith("qradialgradient")) { + static QString rxFloat("\\s*(-?\\s*[0-9]*\\.?[0-9]+)\\s*"); + QRegExp rx(QString("qradialgradient\\s*\\(\\s*cx:%1,\\s*cy:%1,\\s*radius:%1,\\s*fx:%1,\\s*fy:%1,(.+)\\)").arg(rxFloat)); + if(!rx.exactMatch(str)) { + qWarning() << tr("Invalid gradient declaration: %1").arg(str); + return QBrush(); + } + qreal cx = rx.cap(1).toDouble(); + qreal cy = rx.cap(2).toDouble(); + qreal radius = rx.cap(3).toDouble(); + qreal fx = rx.cap(4).toDouble(); + qreal fy = rx.cap(5).toDouble(); + QGradientStops stops = parseGradientStops(rx.cap(6).trimmed()); + if(!stops.count()) { + qWarning() << tr("Invalid gradient stops list: %1").arg(str); + return QBrush(); + } + QRadialGradient gradient(cx, cy, radius, fx, fy); + gradient.setStops(stops); + return QBrush(gradient); + } + + return QBrush(); +} + +QColor UiStyle::QssParser::parseColorValue(const QString &str) { + if(str.startsWith("rgba")) { + ColorTuple tuple = parseColorTuple(str.mid(4)); + if(tuple.count() == 4) + return QColor(tuple.at(0), tuple.at(1), tuple.at(2), tuple.at(3)); + } else if(str.startsWith("rgb")) { + ColorTuple tuple = parseColorTuple(str.mid(3)); + if(tuple.count() == 3) + return QColor(tuple.at(0), tuple.at(1), tuple.at(2)); + } else if(str.startsWith("hsva")) { + ColorTuple tuple = parseColorTuple(str.mid(4)); + if(tuple.count() == 4) { + QColor c; + c.setHsvF(tuple.at(0), tuple.at(1), tuple.at(2), tuple.at(3)); + return c; + } + } else if(str.startsWith("hsv")) { + ColorTuple tuple = parseColorTuple(str.mid(3)); + if(tuple.count() == 3) { + QColor c; + c.setHsvF(tuple.at(0), tuple.at(1), tuple.at(2)); + return c; + } + } else { + QRegExp rx("#?[0-9A-Fa-z]+"); + if(rx.exactMatch(str)) + return QColor(str); + } + return QColor(); +} + +// get a list of comma-separated int values or percentages (rel to 0-255) +UiStyle::QssParser::ColorTuple UiStyle::QssParser::parseColorTuple(const QString &str) { + ColorTuple result; + QRegExp rx("\\(((\\s*[0-9]{1,3}%?\\s*)(,\\s*[0-9]{1,3}%?\\s*)*)\\)"); + if(!rx.exactMatch(str.trimmed())) { + return ColorTuple(); + } + QStringList values = rx.cap(1).split(','); + foreach(QString v, values) { + qreal val; + bool perc = false; + bool ok; + v = v.trimmed(); + if(v.endsWith('%')) { + perc = true; + v.chop(1); + } + val = (qreal)v.toUInt(&ok); + if(!ok) + return ColorTuple(); + if(perc) + val = 255 * val/100; + result.append(val); + } + return result; +} + +QGradientStops UiStyle::QssParser::parseGradientStops(const QString &str_) { + QString str = str_; + QGradientStops result; + static QString rxFloat("(0?\\.[0-9]+|[01])"); // values between 0 and 1 + QRegExp rx(QString("\\s*,?\\s*stop:\\s*(%1)\\s+([^:]+)(,\\s*stop:|$)").arg(rxFloat)); + int idx; + while((idx = rx.indexIn(str)) == 0) { + qreal x = rx.cap(1).toDouble(); + QColor c = parseColorValue(rx.cap(3)); + if(!c.isValid()) + return QGradientStops(); + result << QGradientStop(x, c); + str.remove(0, rx.matchedLength() - rx.cap(4).length()); + } + if(!str.trimmed().isEmpty()) + return QGradientStops(); + + return result; +} diff --git a/src/uisupport/uistyle.h b/src/uisupport/uistyle.h index 38d43f0d..57e8988b 100644 --- a/src/uisupport/uistyle.h +++ b/src/uisupport/uistyle.h @@ -23,9 +23,11 @@ #include #include +#include #include #include -#include +#include +#include #include "message.h" #include "settings.h" @@ -153,12 +155,13 @@ public: }; class StyledMessage; + class QssParser; StyledString styleString(const QString &); QString mircToInternal(const QString &) const; void setFormat(FormatType, QTextCharFormat, Settings::Mode mode/* = Settings::Custom*/); - void setSenderAutoColor(bool state); + void setSenderAutoColor(bool state); QTextCharFormat format(FormatType, Settings::Mode mode = Settings::Custom) const; QTextCharFormat mergedFormat(quint32 formatType); QFontMetricsF *fontMetrics(quint32 formatType); @@ -171,7 +174,10 @@ public: QList toTextLayoutList(const FormatList &, int textLength); protected: + void loadStyleSheet(); + bool _senderAutoColor; + private: QFont _defaultFont; QTextCharFormat _defaultPlainFormat; @@ -207,6 +213,56 @@ private: mutable StyledString _contents; }; +class UiStyle::QssParser { +public: + enum Column { + Any, + Timestamp, + Sender, + Contents + }; + + struct ChatLineFormat { + QVector senderColors; + QVector mircColors; + QHash formats; + + }; + + QssParser(); + + void loadStyleSheet(const QString &sheet); + + inline QPalette palette() const { return _palette; } + ChatLineFormat basicFormat() const; + QHash specialFormats() const; + +protected: + typedef QList ColorTuple; + + void parseChatLineData(const QString &decl, const QString &contents); + void parsePaletteData(const QString &decl, const QString &contents); + + QTextCharFormat parseFormat(const QString &qss); + bool parsePalette(QPalette &, const QString &qss); + + // Parse basic data types + QBrush parseBrushValue(const QString &str); + QColor parseColorValue(const QString &str); + QFont parseFont(const QString &str); + + // Parse subelements + ColorTuple parseColorTuple(const QString &str); + QGradientStops parseGradientStops(const QString &str); + + QHash _paletteColorRoles; + +private: + QPalette _palette; + ChatLineFormat _basicFormat; + QHash _specialFormats; +}; + QDataStream &operator<<(QDataStream &out, const UiStyle::FormatList &formatList); QDataStream &operator>>(QDataStream &in, UiStyle::FormatList &formatList); -- 2.20.1