From c9106b9dbe6e41a0edb7c5961d51c0f722ff8203 Mon Sep 17 00:00:00 2001 From: "Robert C. Helling" Date: Fri, 21 Aug 2020 13:24:10 +0200 Subject: Interpret divelist printing templates This is a first step of an efford to get rid of the Grantlee dependency. This implements template processing for those constructs used in our divelist and statistics printing templates. It implements a template parser for loops over dives, cylinders and year and variable replacement. As the previous Grantlee code, it does not really use Qt's QObject introspection capabilities but reuses the old long chain of if-else-statements. The grantlee code is not yet removed. Signed-off-by: Robert C. Helling Signed-off-by: Dirk Hohndel --- desktop-widgets/templatelayout.cpp | 376 +++++++++++++++++++++++++++++++++++++ 1 file changed, 376 insertions(+) (limited to 'desktop-widgets/templatelayout.cpp') diff --git a/desktop-widgets/templatelayout.cpp b/desktop-widgets/templatelayout.cpp index 633d4569c..b9cd5545e 100644 --- a/desktop-widgets/templatelayout.cpp +++ b/desktop-widgets/templatelayout.cpp @@ -161,6 +161,19 @@ QString TemplateLayout::generate() /* don't use the Grantlee loader API */ QString templateContents = readTemplate(printOptions->p_template); + + QHash options; + options["print_options"] = QVariant::fromValue(*printOptions); + options["template_options"] = QVariant::fromValue(*templateOptions); + options["dives"] = QVariant::fromValue(diveList); + QList tokens = lexer(templateContents); + QString buffer; + QTextStream out(&buffer); + int pos = 0; + parser(tokens, pos, out, options); + htmlContent = out.readAll(); + return htmlContent; + QString preprocessed = preprocessTemplate(templateContents); /* create the template from QString; is this thing allocating memory? */ @@ -215,6 +228,21 @@ QString TemplateLayout::generateStatistics() qDebug() << "Can't load template"; return htmlContent; } + QString templateFile = QString("statistics") + QDir::separator() + printOptions->p_template; + QString templateContents = readTemplate(templateFile); + + QHash options; + options["print_options"] = QVariant::fromValue(*printOptions); + options["template_options"] = QVariant::fromValue(*templateOptions); + options["years"] = QVariant::fromValue(years); + QList tokens = lexer(templateContents); + QString buffer; + QTextStream out(&buffer); + int pos = 0; + parser(tokens, pos, out, options); + htmlContent = out.readAll(); + return htmlContent; + htmlContent = t->render(&c); @@ -246,3 +274,351 @@ void TemplateLayout::writeTemplate(QString template_name, QString grantlee_templ qfile.close(); } } + +struct token stringToken(QString s) +{ + struct token newtoken; + newtoken.type = LITERAL; + newtoken.contents = s; + return newtoken; +} + +static QRegularExpression keywordFor(R"(\bfor\b)"); +static QRegularExpression keywordEndfor(R"(\bendfor\b)"); +static QRegularExpression keywordBlock(R"(\bblock\b)"); +static QRegularExpression keywordEndblock(R"(\bendblock\b)"); +static QRegularExpression keywordIf(R"(\bif\b)"); +static QRegularExpression keywordEndif(R"(\bendif\b)"); + +struct token operatorToken(QString s) +{ + struct token newtoken; + + QRegularExpressionMatch match = keywordFor.match(s); + if (match.hasMatch()) { + newtoken.type = FORSTART; + newtoken.contents = s.mid(match.capturedEnd()); + return newtoken; + } + match = keywordEndfor.match(s); + if (match.hasMatch()) { + newtoken.type = FORSTOP; + newtoken.contents = ""; + return newtoken; + } + match = keywordBlock.match(s); + if (match.hasMatch()) { + newtoken.type = BLOCKSTART; + newtoken.contents = s.mid(match.capturedEnd()); + return newtoken; + } + match = keywordEndblock.match(s); + if (match.hasMatch()) { + newtoken.type = BLOCKSTOP; + newtoken.contents = ""; + return newtoken; + } + match = keywordIf.match(s); + if (match.hasMatch()) { + newtoken.type = IFSTART; + newtoken.contents = s.mid(match.capturedEnd()); + return newtoken; + } + match = keywordEndif.match(s); + if (match.hasMatch()) { + newtoken.type = IFSTOP; + newtoken.contents = ""; + return newtoken; + } + + newtoken.type = PARSERERROR; + newtoken.contents = ""; + return newtoken; +} + +static QRegularExpression op(R"(\{%([\w\s\.\|\:]+)%\})"); // Look for {% stuff %} + +QList TemplateLayout::lexer(QString input) +{ + QList tokenList; + + int last = 0; + QRegularExpressionMatch match = op.match(input); + while (match.hasMatch()) { + tokenList << stringToken(input.mid(last, match.capturedStart() - last)); + tokenList << operatorToken(match.captured(1)); + last = match.capturedEnd(); + match = op.match(input, last); + } + tokenList << stringToken(input.mid(last)); + return tokenList; +} + +static QRegularExpression var(R"(\{\{\s*(\w+)\.(\w+)\s*(\|\s*(\w+))?\s*\}\})"); // Look for {{ stuff.stuff|stuff }} + +QString TemplateLayout::translate(QString s, QHash options) +{ + QString out; + int last = 0; + QRegularExpressionMatch match = var.match(s); + while (match.hasMatch()) { + QString obname = match.captured(1); + QString memname = match.captured(2); + out += s.mid(last, match.capturedStart() - last); + QVariant value = getValue(obname, memname, options.value(obname)); + out += value.toString(); + last = match.capturedEnd(); + match = var.match(s, last); + } + out += s.mid(last); + return out; +} + +static QRegularExpression forloop(R"(\s*(\w+)\s+in\s+(\w+))"); // Look for "VAR in LISTNAME" +static QRegularExpression ifstatement(R"(forloop\.counter\|\s*divisibleby\:\s*(\d+))"); // Look for forloop.counter|divisibleby: NUMBER + +void TemplateLayout::parser(QList tokenList, int &pos, QTextStream &out, QHash options) +{ + while (pos < tokenList.length()) { + switch (tokenList[pos].type) { + case LITERAL: + out << translate(tokenList[pos].contents, options); + ++pos; + break; + case BLOCKSTART: + case BLOCKSTOP: + ++pos; + break; + case FORSTART: + { + QString argument = tokenList[pos].contents; + ++pos; + QRegularExpressionMatch match = forloop.match(argument); + if (match.hasMatch()) { + QString itemname = match.captured(1); + QString listname = match.captured(2); + QString buffer; + QTextStream capture(&buffer); + QVariantList list = options[listname].value(); + int savepos = pos; + for (int i = 0; i < list.size(); ++i) { + QVariant item = list.at(i); + QVariant olditerator = options["forloopiterator"]; + options[itemname] = item; + options["forloopiterator"] = i + 1; + pos = savepos; + if (listname == "dives") + options["cylinders"] = QVariant::fromValue(item.value().cylinderList()); + parser(tokenList, pos, capture, options); + options.remove(itemname); + options.remove("forloopiterator"); + if (listname == "dives") + options.remove("cylinders"); + if (olditerator.isValid()) + options["forloopiterator"] = olditerator; + } + out << capture.readAll(); + } else { + out << "PARSING ERROR: '" << argument << "'"; + } + } + break; + case IFSTART: + { + QString argument = tokenList[pos].contents; + ++pos; + QRegularExpressionMatch match = ifstatement.match(argument); + if (match.hasMatch()) { + int divisor = match.captured(1).toInt(); + QString buffer; + QTextStream capture(&buffer); + int counter = options["forloopiterator"].toInt(); + parser(tokenList, pos, capture, options); + if (!(counter % divisor)) + out << capture.readAll(); + } else { + out << "PARSING ERROR: '" << argument << "'"; + } + } + break; + case FORSTOP: + case IFSTOP: + ++pos; + return; + case PARSERERROR: + out << "PARSING ERROR"; + ++pos; + } + } +} + +QVariant TemplateLayout::getValue(QString list, QString property, QVariant option) +{ + if (list == "template_options") { + template_options object = option.value(); + if (property == "font") { + switch (object.font_index) { + case 0: + return "Arial, Helvetica, sans-serif"; + case 1: + return "Impact, Charcoal, sans-serif"; + case 2: + return "Georgia, serif"; + case 3: + return "Courier, monospace"; + case 4: + return "Verdana, Geneva, sans-serif"; + } + } else if (property == "borderwidth") { + return object.border_width; + } else if (property == "font_size") { + return object.font_size / 9.0; + } else if (property == "line_spacing") { + return object.line_spacing; + } else if (property == "color1") { + return object.color_palette.color1.name(); + } else if (property == "color2") { + return object.color_palette.color2.name(); + } else if (property == "color3") { + return object.color_palette.color3.name(); + } else if (property == "color4") { + return object.color_palette.color4.name(); + } else if (property == "color5") { + return object.color_palette.color5.name(); + } else if (property == "color6") { + return object.color_palette.color6.name(); + } + } else if (list == "print_options") { + print_options object = option.value(); + if (property == "grayscale") { + if (object.color_selected) { + return ""; + } else { + return "-webkit-filter: grayscale(100%)"; + } + } + } else if (list =="year") { + YearInfo object = option.value(); + if (property == "year") { + return object.year->period; + } else if (property == "dives") { + return object.year->selection_size; + } else if (property == "min_temp") { + return object.year->min_temp.mkelvin == 0 ? "0" : get_temperature_string(object.year->min_temp, true); + } else if (property == "max_temp") { + return object.year->max_temp.mkelvin == 0 ? "0" : get_temperature_string(object.year->max_temp, true); + } else if (property == "total_time") { + return get_dive_duration_string(object.year->total_time.seconds, gettextFromC::tr("h"), + gettextFromC::tr("min"), gettextFromC::tr("sec"), " "); + } else if (property == "avg_time") { + return get_minutes(object.year->total_time.seconds / object.year->selection_size); + } else if (property == "shortest_time") { + return get_minutes(object.year->shortest_time.seconds); + } else if (property == "longest_time") { + return get_minutes(object.year->longest_time.seconds); + } else if (property == "avg_depth") { + return get_depth_string(object.year->avg_depth); + } else if (property == "min_depth") { + return get_depth_string(object.year->min_depth); + } else if (property == "max_depth") { + return get_depth_string(object.year->max_depth); + } else if (property == "avg_sac") { + return get_volume_string(object.year->avg_sac); + } else if (property == "min_sac") { + return get_volume_string(object.year->min_sac); + } else if (property == "max_sac") { + return get_volume_string(object.year->max_sac); + } + } else if (list == "cylinder") { + CylinderObjectHelper object = option.value(); + if (property == "description") { + return object.description; + } else if (property == "size") { + return object.size; + } else if (property == "workingPressure") { + return object.workingPressure; + } else if (property == "startPressure") { + return object.startPressure; + } else if (property == "endPressure") { + return object.endPressure; + } else if (property == "gasMix") { + return object.gasMix; + } + } else if (list == "dive") { + DiveObjectHelperGrantlee object = option.value(); + if (property == "number") { + return object.number; + } else if (property == "id") { + return object.id; + } else if (property == "rating") { + return object.rating; + } else if (property == "visibility") { + return object.visibility; + } else if (property == "date") { + return object.date(); + } else if (property == "time") { + return object.time(); + } else if (property == "timestamp") { + return QVariant::fromValue(object.timestamp); + } else if (property == "location") { + return object.location; + } else if (property == "gps") { + return object.gps; + } else if (property == "gps_decimal") { + return object.gps_decimal; + } else if (property == "dive_site") { + return object.dive_site; + } else if (property == "duration") { + return object.duration; + } else if (property == "noDive") { + return object.noDive; + } else if (property == "depth") { + return object.depth; + } else if (property == "divemaster") { + return object.divemaster; + } else if (property == "buddy") { + return object.buddy; + } else if (property == "airTemp") { + return object.airTemp; + } else if (property == "waterTemp") { + return object.waterTemp; + } else if (property == "notes") { + return object.notes; + } else if (property == "tags") { + return object.tags; + } else if (property == "gas") { + return object.gas; + } else if (property == "sac") { + return object.sac; + } else if (property == "weightList") { + return object.weightList; + } else if (property == "weights") { + return object.weights; + } else if (property == "singleWeight") { + return object.singleWeight; + } else if (property == "suit") { + return object.suit; + } else if (property == "cylinderList") { + return object.cylinderList(); + } else if (property == "cylinders") { + return object.cylinders; + } else if (property == "cylinderObjects") { + return QVariant::fromValue(object.cylinderObjects); + } else if (property == "maxcns") { + return object.maxcns; + } else if (property == "otu") { + return object.otu; + } else if (property == "sumWeight") { + return object.sumWeight; + } else if (property == "getCylinder") { + return object.getCylinder; + } else if (property == "startPressure") { + return object.startPressure; + } else if (property == "endPressure") { + return object.endPressure; + } else if (property == "firstGas") { + return object.firstGas; + } + } + return QVariant(); +} -- cgit v1.2.3-70-g09d2