Quassel IRC  Pre-Release
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros
qssparser.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  * Copyright (C) 2005-2015 by the Quassel Project *
3  * devel@quassel-irc.org *
4  * *
5  * This program is free software; you can redistribute it and/or modify *
6  * it under the terms of the GNU General Public License as published by *
7  * the Free Software Foundation; either version 2 of the License, or *
8  * (at your option) version 3. *
9  * *
10  * This program is distributed in the hope that it will be useful, *
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13  * GNU General Public License for more details. *
14  * *
15  * You should have received a copy of the GNU General Public License *
16  * along with this program; if not, write to the *
17  * Free Software Foundation, Inc., *
18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
19  ***************************************************************************/
20 
21 #include <QApplication>
22 
23 #include "qssparser.h"
24 
25 QssParser::QssParser()
26 {
28 
29  // Init palette color roles
30  _paletteColorRoles["alternate-base"] = QPalette::AlternateBase;
31  _paletteColorRoles["background"] = QPalette::Background;
32  _paletteColorRoles["base"] = QPalette::Base;
33  _paletteColorRoles["bright-text"] = QPalette::BrightText;
34  _paletteColorRoles["button"] = QPalette::Button;
35  _paletteColorRoles["button-text"] = QPalette::ButtonText;
36  _paletteColorRoles["dark"] = QPalette::Dark;
37  _paletteColorRoles["foreground"] = QPalette::Foreground;
38  _paletteColorRoles["highlight"] = QPalette::Highlight;
39  _paletteColorRoles["highlighted-text"] = QPalette::HighlightedText;
40  _paletteColorRoles["light"] = QPalette::Light;
41  _paletteColorRoles["link"] = QPalette::Link;
42  _paletteColorRoles["link-visited"] = QPalette::LinkVisited;
43  _paletteColorRoles["mid"] = QPalette::Mid;
44  _paletteColorRoles["midlight"] = QPalette::Midlight;
45  _paletteColorRoles["shadow"] = QPalette::Shadow;
46  _paletteColorRoles["text"] = QPalette::Text;
47  _paletteColorRoles["tooltip-base"] = QPalette::ToolTipBase;
48  _paletteColorRoles["tooltip-text"] = QPalette::ToolTipText;
49  _paletteColorRoles["window"] = QPalette::Window;
50  _paletteColorRoles["window-text"] = QPalette::WindowText;
51 
52  _uiStylePalette = QVector<QBrush>(UiStyle::NumRoles, QBrush());
53 
54  _uiStyleColorRoles["marker-line"] = UiStyle::MarkerLine;
55 }
56 
57 
59 {
60  if (ss.isEmpty())
61  return;
62 
63  // Remove C-style comments /* */ or //
64  QRegExp commentRx("(//.*(\\n|$)|/\\*.*\\*/)");
65  commentRx.setMinimal(true);
66  ss.remove(commentRx);
67 
68  // Palette definitions first, so we can apply roles later on
69  QRegExp paletterx("(Palette[^{]*)\\{([^}]+)\\}");
70  int pos = 0;
71  while ((pos = paletterx.indexIn(ss, pos)) >= 0) {
72  parsePaletteBlock(paletterx.cap(1).trimmed(), paletterx.cap(2).trimmed());
73  ss.remove(pos, paletterx.matchedLength());
74  }
75 
76  // Now we can parse the rest of our custom blocks
77  QRegExp blockrx("((?:ChatLine|ChatListItem|NickListItem)[^{]*)\\{([^}]+)\\}");
78  pos = 0;
79  while ((pos = blockrx.indexIn(ss, pos)) >= 0) {
80  //qDebug() << blockrx.cap(1) << blockrx.cap(2);
81  QString declaration = blockrx.cap(1).trimmed();
82  QString contents = blockrx.cap(2).trimmed();
83 
84  if (declaration.startsWith("ChatLine"))
85  parseChatLineBlock(declaration, contents);
86  else if (declaration.startsWith("ChatListItem") || declaration.startsWith("NickListItem"))
87  parseListItemBlock(declaration, contents);
88  //else
89  // TODO: add moar here
90 
91  ss.remove(pos, blockrx.matchedLength());
92  }
93 }
94 
95 
96 /******** Parse a whole block: declaration { contents } *******/
97 
98 void QssParser::parseChatLineBlock(const QString &decl, const QString &contents)
99 {
100  quint64 fmtType = parseFormatType(decl);
101  if (fmtType == UiStyle::Invalid)
102  return;
103 
104  _formats[fmtType].merge(parseFormat(contents));
105 }
106 
107 
108 void QssParser::parseListItemBlock(const QString &decl, const QString &contents)
109 {
110  quint32 fmtType = parseItemFormatType(decl);
111  if (fmtType == UiStyle::Invalid)
112  return;
113 
114  _listItemFormats[fmtType].merge(parseFormat(contents));
115 }
116 
117 
118 // Palette { ... } specifies the application palette
119 // ColorGroups can be specified like pseudo states, chaining is OR (contrary to normal CSS handling):
120 // Palette:inactive:disabled { ... } applies to both the Inactive and the Disabled state
121 void QssParser::parsePaletteBlock(const QString &decl, const QString &contents)
122 {
123  QList<QPalette::ColorGroup> colorGroups;
124 
125  // Check if we want to apply this palette definition for particular ColorGroups
126  QRegExp rx("Palette((:(normal|active|inactive|disabled))*)");
127  if (!rx.exactMatch(decl)) {
128  qWarning() << Q_FUNC_INFO << tr("Invalid block declaration: %1").arg(decl);
129  return;
130  }
131  if (!rx.cap(1).isEmpty()) {
132  QStringList groups = rx.cap(1).split(':', QString::SkipEmptyParts);
133  foreach(QString g, groups) {
134  if ((g == "normal" || g == "active") && !colorGroups.contains(QPalette::Active))
135  colorGroups.append(QPalette::Active);
136  else if (g == "inactive" && !colorGroups.contains(QPalette::Inactive))
137  colorGroups.append(QPalette::Inactive);
138  else if (g == "disabled" && !colorGroups.contains(QPalette::Disabled))
139  colorGroups.append(QPalette::Disabled);
140  }
141  }
142 
143  // Now let's go through the roles
144  foreach(QString line, contents.split(';', QString::SkipEmptyParts)) {
145  int idx = line.indexOf(':');
146  if (idx <= 0) {
147  qWarning() << Q_FUNC_INFO << tr("Invalid palette role assignment: %1").arg(line.trimmed());
148  continue;
149  }
150  QString rolestr = line.left(idx).trimmed();
151  QString brushstr = line.mid(idx + 1).trimmed();
152 
153  if (_paletteColorRoles.contains(rolestr)) {
154  QBrush brush = parseBrush(brushstr);
155  if (colorGroups.count()) {
156  foreach(QPalette::ColorGroup group, colorGroups)
157  _palette.setBrush(group, _paletteColorRoles.value(rolestr), brush);
158  }
159  else
160  _palette.setBrush(_paletteColorRoles.value(rolestr), brush);
161  }
162  else if (_uiStyleColorRoles.contains(rolestr)) {
163  _uiStylePalette[_uiStyleColorRoles.value(rolestr)] = parseBrush(brushstr);
164  }
165  else
166  qWarning() << Q_FUNC_INFO << tr("Unknown palette role name: %1").arg(rolestr);
167  }
168 }
169 
170 
171 /******** Determine format types from a block declaration ********/
172 
173 quint64 QssParser::parseFormatType(const QString &decl)
174 {
175  QRegExp rx("ChatLine(?:::(\\w+))?(?:#([\\w\\-]+))?(?:\\[([=-,\\\"\\w\\s]+)\\])?");
176  // $1: subelement; $2: msgtype; $3: conditionals
177  if (!rx.exactMatch(decl)) {
178  qWarning() << Q_FUNC_INFO << tr("Invalid block declaration: %1").arg(decl);
179  return UiStyle::Invalid;
180  }
181  QString subElement = rx.cap(1);
182  QString msgType = rx.cap(2);
183  QString conditions = rx.cap(3);
184 
185  quint64 fmtType = 0;
186 
187  // First determine the subelement
188  if (!subElement.isEmpty()) {
189  if (subElement == "timestamp")
190  fmtType |= UiStyle::Timestamp;
191  else if (subElement == "sender")
192  fmtType |= UiStyle::Sender;
193  else if (subElement == "nick")
194  fmtType |= UiStyle::Nick;
195  else if (subElement == "contents")
196  fmtType |= UiStyle::Contents;
197  else if (subElement == "hostmask")
198  fmtType |= UiStyle::Hostmask;
199  else if (subElement == "modeflags")
200  fmtType |= UiStyle::ModeFlags;
201  else if (subElement == "url")
202  fmtType |= UiStyle::Url;
203  else {
204  qWarning() << Q_FUNC_INFO << tr("Invalid subelement name in %1").arg(decl);
205  return UiStyle::Invalid;
206  }
207  }
208 
209  // Now, figure out the message type
210  if (!msgType.isEmpty()) {
211  if (msgType == "plain")
212  fmtType |= UiStyle::PlainMsg;
213  else if (msgType == "notice")
214  fmtType |= UiStyle::NoticeMsg;
215  else if (msgType == "action")
216  fmtType |= UiStyle::ActionMsg;
217  else if (msgType == "nick")
218  fmtType |= UiStyle::NickMsg;
219  else if (msgType == "mode")
220  fmtType |= UiStyle::ModeMsg;
221  else if (msgType == "join")
222  fmtType |= UiStyle::JoinMsg;
223  else if (msgType == "part")
224  fmtType |= UiStyle::PartMsg;
225  else if (msgType == "quit")
226  fmtType |= UiStyle::QuitMsg;
227  else if (msgType == "kick")
228  fmtType |= UiStyle::KickMsg;
229  else if (msgType == "kill")
230  fmtType |= UiStyle::KillMsg;
231  else if (msgType == "server")
232  fmtType |= UiStyle::ServerMsg;
233  else if (msgType == "info")
234  fmtType |= UiStyle::InfoMsg;
235  else if (msgType == "error")
236  fmtType |= UiStyle::ErrorMsg;
237  else if (msgType == "daychange")
238  fmtType |= UiStyle::DayChangeMsg;
239  else if (msgType == "topic")
240  fmtType |= UiStyle::TopicMsg;
241  else if (msgType == "netsplit-join")
242  fmtType |= UiStyle::NetsplitJoinMsg;
243  else if (msgType == "netsplit-quit")
244  fmtType |= UiStyle::NetsplitQuitMsg;
245  else if (msgType == "invite")
246  fmtType |= UiStyle::InviteMsg;
247  else {
248  qWarning() << Q_FUNC_INFO << tr("Invalid message type in %1").arg(decl);
249  }
250  }
251 
252  // Next up: conditional (formats, labels, nickhash)
253  QRegExp condRx("\\s*([\\w\\-]+)\\s*=\\s*\"(\\w+)\"\\s*");
254  if (!conditions.isEmpty()) {
255  foreach(const QString &cond, conditions.split(',', QString::SkipEmptyParts)) {
256  if (!condRx.exactMatch(cond)) {
257  qWarning() << Q_FUNC_INFO << tr("Invalid condition %1").arg(cond);
258  return UiStyle::Invalid;
259  }
260  QString condName = condRx.cap(1);
261  QString condValue = condRx.cap(2);
262  if (condName == "label") {
263  quint64 labeltype = 0;
264  if (condValue == "highlight")
265  labeltype = UiStyle::Highlight;
266  else if (condValue == "selected")
267  labeltype = UiStyle::Selected;
268  else {
269  qWarning() << Q_FUNC_INFO << tr("Invalid message label: %1").arg(condValue);
270  return UiStyle::Invalid;
271  }
272  fmtType |= (labeltype << 32);
273  }
274  else if (condName == "sender") {
275  if (condValue == "self")
276  fmtType |= (quint64) UiStyle::OwnMsg << 32; // sender="self" is actually treated as a label
277  else {
278  bool ok = true;
279  quint64 val = condValue.toUInt(&ok, 16);
280  if (!ok) {
281  qWarning() << Q_FUNC_INFO << tr("Invalid senderhash specification: %1").arg(condValue);
282  return UiStyle::Invalid;
283  }
284  if (val >= 16) {
285  qWarning() << Q_FUNC_INFO << tr("Senderhash can be at most \"0x0f\"!");
286  return UiStyle::Invalid;
287  }
288  fmtType |= ++val << 48;
289  }
290  }
291  else if (condName == "format") {
292  if (condValue == "bold")
293  fmtType |= UiStyle::Bold;
294  else if (condValue == "italic")
295  fmtType |= UiStyle::Italic;
296  else if (condValue == "underline")
297  fmtType |= UiStyle::Underline;
298  else if (condValue == "reverse")
299  fmtType |= UiStyle::Reverse;
300  else {
301  qWarning() << Q_FUNC_INFO << tr("Invalid format name: %1").arg(condValue);
302  return UiStyle::Invalid;
303  }
304  }
305  else if (condName == "fg-color" || condName == "bg-color") {
306  bool ok;
307  quint8 col = condValue.toUInt(&ok, 16);
308  if (!ok || col > 0x0f) {
309  qWarning() << Q_FUNC_INFO << tr("Illegal IRC color specification (must be between 00 and 0f): %1").arg(condValue);
310  return UiStyle::Invalid;
311  }
312  if (condName == "fg-color")
313  fmtType |= 0x00400000 | (quint32)(col << 24);
314  else
315  fmtType |= 0x00800000 | (quint32)(col << 28);
316  }
317  else {
318  qWarning() << Q_FUNC_INFO << tr("Unhandled condition: %1").arg(condName);
319  return UiStyle::Invalid;
320  }
321  }
322  }
323 
324  return fmtType;
325 }
326 
327 
328 // FIXME: Code duplication
329 quint32 QssParser::parseItemFormatType(const QString &decl)
330 {
331  QRegExp rx("(Chat|Nick)ListItem(?:\\[([=-,\\\"\\w\\s]+)\\])?");
332  // $1: item type; $2: properties
333  if (!rx.exactMatch(decl)) {
334  qWarning() << Q_FUNC_INFO << tr("Invalid block declaration: %1").arg(decl);
335  return UiStyle::Invalid;
336  }
337  QString mainItemType = rx.cap(1);
338  QString properties = rx.cap(2);
339 
340  quint32 fmtType = 0;
341 
342  // Next up: properties
343  QString type, state;
344  if (!properties.isEmpty()) {
345  QHash<QString, QString> props;
346  QRegExp propRx("\\s*([\\w\\-]+)\\s*=\\s*\"([\\w\\-]+)\"\\s*");
347  foreach(const QString &prop, properties.split(',', QString::SkipEmptyParts)) {
348  if (!propRx.exactMatch(prop)) {
349  qWarning() << Q_FUNC_INFO << tr("Invalid proplist %1").arg(prop);
350  return UiStyle::Invalid;
351  }
352  props[propRx.cap(1)] = propRx.cap(2);
353  }
354  type = props.value("type");
355  state = props.value("state");
356  }
357 
358  if (mainItemType == "Chat") {
359  fmtType |= UiStyle::BufferViewItem;
360  if (!type.isEmpty()) {
361  if (type == "network")
362  fmtType |= UiStyle::NetworkItem;
363  else if (type == "channel")
364  fmtType |= UiStyle::ChannelBufferItem;
365  else if (type == "query")
366  fmtType |= UiStyle::QueryBufferItem;
367  else {
368  qWarning() << Q_FUNC_INFO << tr("Invalid chatlist item type %1").arg(type);
369  return UiStyle::Invalid;
370  }
371  }
372  if (!state.isEmpty()) {
373  if (state == "inactive")
374  fmtType |= UiStyle::InactiveBuffer;
375  else if (state == "channel-event")
376  fmtType |= UiStyle::ActiveBuffer;
377  else if (state == "unread-message")
378  fmtType |= UiStyle::UnreadBuffer;
379  else if (state == "highlighted")
380  fmtType |= UiStyle::HighlightedBuffer;
381  else if (state == "away")
382  fmtType |= UiStyle::UserAway;
383  else {
384  qWarning() << Q_FUNC_INFO << tr("Invalid chatlist state %1").arg(state);
385  return UiStyle::Invalid;
386  }
387  }
388  }
389  else { // NickList
390  fmtType |= UiStyle::NickViewItem;
391  if (!type.isEmpty()) {
392  if (type == "user") {
393  fmtType |= UiStyle::IrcUserItem;
394  if (state == "away")
395  fmtType |= UiStyle::UserAway;
396  }
397  else if (type == "category")
398  fmtType |= UiStyle::UserCategoryItem;
399  }
400  }
401  return fmtType;
402 }
403 
404 
405 /******** Parse a whole format attribute block ********/
406 
407 QTextCharFormat QssParser::parseFormat(const QString &qss)
408 {
409  QTextCharFormat format;
410 
411  foreach(QString line, qss.split(';', QString::SkipEmptyParts)) {
412  int idx = line.indexOf(':');
413  if (idx <= 0) {
414  qWarning() << Q_FUNC_INFO << tr("Invalid property declaration: %1").arg(line.trimmed());
415  continue;
416  }
417  QString property = line.left(idx).trimmed();
418  QString value = line.mid(idx + 1).simplified();
419 
420  if (property == "background" || property == "background-color")
421  format.setBackground(parseBrush(value));
422  else if (property == "foreground" || property == "color")
423  format.setForeground(parseBrush(value));
424 
425  // font-related properties
426  else if (property.startsWith("font")) {
427  if (property == "font")
428  parseFont(value, &format);
429  else if (property == "font-style")
430  parseFontStyle(value, &format);
431  else if (property == "font-weight")
432  parseFontWeight(value, &format);
433  else if (property == "font-size")
434  parseFontSize(value, &format);
435  else if (property == "font-family")
436  parseFontFamily(value, &format);
437  else {
438  qWarning() << Q_FUNC_INFO << tr("Invalid font property: %1").arg(line);
439  continue;
440  }
441  }
442 
443  else {
444  qWarning() << Q_FUNC_INFO << tr("Unknown ChatLine property: %1").arg(property);
445  }
446  }
447 
448  return format;
449 }
450 
451 
452 /******** Brush ********/
453 
454 QBrush QssParser::parseBrush(const QString &str, bool *ok)
455 {
456  if (ok)
457  *ok = false;
458  QColor c = parseColor(str);
459  if (c.isValid()) {
460  if (ok)
461  *ok = true;
462  return QBrush(c);
463  }
464 
465  if (str.startsWith("palette")) { // Palette color role
466  QRegExp rx("palette\\s*\\(\\s*([a-z-]+)\\s*\\)");
467  if (!rx.exactMatch(str)) {
468  qWarning() << Q_FUNC_INFO << tr("Invalid palette color role specification: %1").arg(str);
469  return QBrush();
470  }
471  if (_paletteColorRoles.contains(rx.cap(1)))
472  return QBrush(_palette.brush(_paletteColorRoles.value(rx.cap(1))));
473  if (_uiStyleColorRoles.contains(rx.cap(1)))
474  return QBrush(_uiStylePalette.at(_uiStyleColorRoles.value(rx.cap(1))));
475  qWarning() << Q_FUNC_INFO << tr("Unknown palette color role: %1").arg(rx.cap(1));
476  return QBrush();
477  }
478  else if (str.startsWith("qlineargradient")) {
479  static QString rxFloat("\\s*(-?\\s*[0-9]*\\.?[0-9]+)\\s*");
480  QRegExp rx(QString("qlineargradient\\s*\\(\\s*x1:%1,\\s*y1:%1,\\s*x2:%1,\\s*y2:%1,(.+)\\)").arg(rxFloat));
481  if (!rx.exactMatch(str)) {
482  qWarning() << Q_FUNC_INFO << tr("Invalid gradient declaration: %1").arg(str);
483  return QBrush();
484  }
485  qreal x1 = rx.cap(1).toDouble();
486  qreal y1 = rx.cap(2).toDouble();
487  qreal x2 = rx.cap(3).toDouble();
488  qreal y2 = rx.cap(4).toDouble();
489  QGradientStops stops = parseGradientStops(rx.cap(5).trimmed());
490  if (!stops.count()) {
491  qWarning() << Q_FUNC_INFO << tr("Invalid gradient stops list: %1").arg(str);
492  return QBrush();
493  }
494  QLinearGradient gradient(x1, y1, x2, y2);
495  gradient.setCoordinateMode(QGradient::ObjectBoundingMode);
496  gradient.setStops(stops);
497  if (ok)
498  *ok = true;
499  return QBrush(gradient);
500  }
501  else if (str.startsWith("qconicalgradient")) {
502  static QString rxFloat("\\s*(-?\\s*[0-9]*\\.?[0-9]+)\\s*");
503  QRegExp rx(QString("qconicalgradient\\s*\\(\\s*cx:%1,\\s*cy:%1,\\s*angle:%1,(.+)\\)").arg(rxFloat));
504  if (!rx.exactMatch(str)) {
505  qWarning() << Q_FUNC_INFO << tr("Invalid gradient declaration: %1").arg(str);
506  return QBrush();
507  }
508  qreal cx = rx.cap(1).toDouble();
509  qreal cy = rx.cap(2).toDouble();
510  qreal angle = rx.cap(3).toDouble();
511  QGradientStops stops = parseGradientStops(rx.cap(4).trimmed());
512  if (!stops.count()) {
513  qWarning() << Q_FUNC_INFO << tr("Invalid gradient stops list: %1").arg(str);
514  return QBrush();
515  }
516  QConicalGradient gradient(cx, cy, angle);
517  gradient.setCoordinateMode(QGradient::ObjectBoundingMode);
518  gradient.setStops(stops);
519  if (ok)
520  *ok = true;
521  return QBrush(gradient);
522  }
523  else if (str.startsWith("qradialgradient")) {
524  static QString rxFloat("\\s*(-?\\s*[0-9]*\\.?[0-9]+)\\s*");
525  QRegExp rx(QString("qradialgradient\\s*\\(\\s*cx:%1,\\s*cy:%1,\\s*radius:%1,\\s*fx:%1,\\s*fy:%1,(.+)\\)").arg(rxFloat));
526  if (!rx.exactMatch(str)) {
527  qWarning() << Q_FUNC_INFO << tr("Invalid gradient declaration: %1").arg(str);
528  return QBrush();
529  }
530  qreal cx = rx.cap(1).toDouble();
531  qreal cy = rx.cap(2).toDouble();
532  qreal radius = rx.cap(3).toDouble();
533  qreal fx = rx.cap(4).toDouble();
534  qreal fy = rx.cap(5).toDouble();
535  QGradientStops stops = parseGradientStops(rx.cap(6).trimmed());
536  if (!stops.count()) {
537  qWarning() << Q_FUNC_INFO << tr("Invalid gradient stops list: %1").arg(str);
538  return QBrush();
539  }
540  QRadialGradient gradient(cx, cy, radius, fx, fy);
541  gradient.setCoordinateMode(QGradient::ObjectBoundingMode);
542  gradient.setStops(stops);
543  if (ok)
544  *ok = true;
545  return QBrush(gradient);
546  }
547 
548  return QBrush();
549 }
550 
551 
552 QColor QssParser::parseColor(const QString &str)
553 {
554  if (str.startsWith("rgba")) {
555  ColorTuple tuple = parseColorTuple(str.mid(4));
556  if (tuple.count() == 4)
557  return QColor(tuple.at(0), tuple.at(1), tuple.at(2), tuple.at(3));
558  }
559  else if (str.startsWith("rgb")) {
560  ColorTuple tuple = parseColorTuple(str.mid(3));
561  if (tuple.count() == 3)
562  return QColor(tuple.at(0), tuple.at(1), tuple.at(2));
563  }
564  else if (str.startsWith("hsva")) {
565  ColorTuple tuple = parseColorTuple(str.mid(4));
566  if (tuple.count() == 4) {
567  QColor c;
568  c.setHsvF(tuple.at(0), tuple.at(1), tuple.at(2), tuple.at(3));
569  return c;
570  }
571  }
572  else if (str.startsWith("hsv")) {
573  ColorTuple tuple = parseColorTuple(str.mid(3));
574  if (tuple.count() == 3) {
575  QColor c;
576  c.setHsvF(tuple.at(0), tuple.at(1), tuple.at(2));
577  return c;
578  }
579  }
580  else {
581  QRegExp rx("#?[0-9A-Fa-z]+");
582  if (rx.exactMatch(str))
583  return QColor(str);
584  }
585  return QColor();
586 }
587 
588 
589 // get a list of comma-separated int values or percentages (rel to 0-255)
591 {
592  ColorTuple result;
593  QRegExp rx("\\(((\\s*[0-9]{1,3}%?\\s*)(,\\s*[0-9]{1,3}%?\\s*)*)\\)");
594  if (!rx.exactMatch(str.trimmed())) {
595  return ColorTuple();
596  }
597  QStringList values = rx.cap(1).split(',');
598  foreach(QString v, values) {
599  qreal val;
600  bool perc = false;
601  bool ok;
602  v = v.trimmed();
603  if (v.endsWith('%')) {
604  perc = true;
605  v.chop(1);
606  }
607  val = (qreal)v.toUInt(&ok);
608  if (!ok)
609  return ColorTuple();
610  if (perc)
611  val = 255 * val/100;
612  result.append(val);
613  }
614  return result;
615 }
616 
617 
618 QGradientStops QssParser::parseGradientStops(const QString &str_)
619 {
620  QString str = str_;
621  QGradientStops result;
622  static QString rxFloat("(0?\\.[0-9]+|[01])"); // values between 0 and 1
623  QRegExp rx(QString("\\s*,?\\s*stop:\\s*(%1)\\s+([^:]+)(,\\s*stop:|$)").arg(rxFloat));
624  int idx;
625  while ((idx = rx.indexIn(str)) == 0) {
626  qreal x = rx.cap(1).toDouble();
627  QColor c = parseColor(rx.cap(3));
628  if (!c.isValid())
629  return QGradientStops();
630  result << QGradientStop(x, c);
631  str.remove(0, rx.matchedLength() - rx.cap(4).length());
632  }
633  if (!str.trimmed().isEmpty())
634  return QGradientStops();
635 
636  return result;
637 }
638 
639 
640 /******** Font Properties ********/
641 
642 void QssParser::parseFont(const QString &value, QTextCharFormat *format)
643 {
644  QRegExp rx("((?:(?:normal|italic|oblique|underline|bold|100|200|300|400|500|600|700|800|900) ){0,2}) ?(\\d+)(pt|px)? \"(.*)\"");
645  if (!rx.exactMatch(value)) {
646  qWarning() << Q_FUNC_INFO << tr("Invalid font specification: %1").arg(value);
647  return;
648  }
649  format->setFontItalic(false);
650  format->setFontWeight(QFont::Normal);
651  QStringList proplist = rx.cap(1).split(' ', QString::SkipEmptyParts);
652  foreach(QString prop, proplist) {
653  if (prop == "italic")
654  format->setFontItalic(true);
655  else if (prop == "underline")
656  format->setFontUnderline(true);
657  //else if(prop == "oblique")
658  // format->setStyle(QFont::StyleOblique);
659  else if (prop == "bold")
660  format->setFontWeight(QFont::Bold);
661  else { // number
662  int w = prop.toInt();
663  format->setFontWeight(qMin(w / 8, 99)); // taken from Qt's qss parser
664  }
665  }
666 
667  if (rx.cap(3) == "px")
668  format->setProperty(QTextFormat::FontPixelSize, rx.cap(2).toInt());
669  else
670  format->setFontPointSize(rx.cap(2).toInt());
671 
672  format->setFontFamily(rx.cap(4));
673 }
674 
675 
676 void QssParser::parseFontStyle(const QString &value, QTextCharFormat *format)
677 {
678  if (value == "normal")
679  format->setFontItalic(false);
680  else if (value == "italic")
681  format->setFontItalic(true);
682  else if (value == "underline")
683  format->setFontUnderline(true);
684  //else if(value == "oblique")
685  // format->setStyle(QFont::StyleOblique);
686  else {
687  qWarning() << Q_FUNC_INFO << tr("Invalid font style specification: %1").arg(value);
688  }
689 }
690 
691 
692 void QssParser::parseFontWeight(const QString &value, QTextCharFormat *format)
693 {
694  if (value == "normal")
695  format->setFontWeight(QFont::Normal);
696  else if (value == "bold")
697  format->setFontWeight(QFont::Bold);
698  else {
699  bool ok;
700  int w = value.toInt(&ok);
701  if (!ok) {
702  qWarning() << Q_FUNC_INFO << tr("Invalid font weight specification: %1").arg(value);
703  return;
704  }
705  format->setFontWeight(qMin(w / 8, 99)); // taken from Qt's qss parser
706  }
707 }
708 
709 
710 void QssParser::parseFontSize(const QString &value, QTextCharFormat *format)
711 {
712  QRegExp rx("(\\d+)(pt|px)");
713  if (!rx.exactMatch(value)) {
714  qWarning() << Q_FUNC_INFO << tr("Invalid font size specification: %1").arg(value);
715  return;
716  }
717  if (rx.cap(2) == "px")
718  format->setProperty(QTextFormat::FontPixelSize, rx.cap(1).toInt());
719  else
720  format->setFontPointSize(rx.cap(1).toInt());
721 }
722 
723 
724 void QssParser::parseFontFamily(const QString &value, QTextCharFormat *format)
725 {
726  QString family = value;
727  if (family.startsWith('"') && family.endsWith('"')) {
728  family = family.mid(1, family.length() - 2);
729  }
730  format->setFontFamily(family);
731 }