QString TemplateLayout::generate() { int progress = 0; int totalWork = getTotalWork(PrintOptions); QString templateName; QString htmlContent; m_engine = new Grantlee::Engine(this); QSharedPointer<Grantlee::FileSystemTemplateLoader> m_templateLoader = QSharedPointer<Grantlee::FileSystemTemplateLoader>(new Grantlee::FileSystemTemplateLoader()); m_templateLoader->setTemplateDirs(QStringList() << getSubsurfaceDataPath("printing_templates")); m_engine->addTemplateLoader(m_templateLoader); Grantlee::registerMetaType<Dive>(); Grantlee::registerMetaType<template_options>(); Grantlee::registerMetaType<print_options>(); QVariantHash mapping; QVariantList diveList; struct dive *dive; int i; for_each_dive (i, dive) { //TODO check for exporting selected dives only if (!dive->selected && PrintOptions->print_selected) continue; Dive d(dive); diveList.append(QVariant::fromValue(d)); progress++; emit progressUpdated(progress * 100.0 / totalWork); } mapping.insert("dives", diveList); mapping.insert("template_options", QVariant::fromValue(*templateOptions)); mapping.insert("print_options", QVariant::fromValue(*PrintOptions)); Grantlee::Context c(mapping); if (PrintOptions->p_template == print_options::ONE_DIVE) { templateName = "one_dive.html"; } else if (PrintOptions->p_template == print_options::TWO_DIVE) { templateName = "two_dives.html"; } else if (PrintOptions->p_template == print_options::CUSTOM) { templateName = "custom.html"; } Grantlee::Template t = m_engine->loadByName(templateName); if (!t || t->error()) { qDebug() << "Can't load template"; return htmlContent; } htmlContent = t->render(&c); if (t->error()) { qDebug() << "Can't render template"; return htmlContent; } return htmlContent; }
Grantlee::Template Templates::getTemplate(const QString& name) { Grantlee::Template t = self()->engine->loadByName(name); qDebug() << name << t->nodeList().size(); if (t->error() != Grantlee::NoError) { qDebug() << t->errorString(); } return t; }
void PublicServerSystem::Web::View::render(const QString &templateName, QTextStream &stream, Grantlee::Engine *templateEngine, Grantlee::Context *requestContext) { Grantlee::OutputStream out(&stream); Grantlee::Template tem = templateEngine->loadByName(templateName); if ( tem->error() != Grantlee::NoError ) { qDebug() << tem->errorString(); } tem->render(&out, requestContext); }
QString ApplicationPGPKeyFormatter::render(const PgpKeyMessagePart &mp) const { GrantleeTheme::Engine engine; engine.localizer()->setApplicationDomain(QByteArrayLiteral("messageviewer_application_gnupgwks_plugin")); engine.addTemplateLoader(QSharedPointer<GrantleeTheme::QtResourceTemplateLoader>::create()); Grantlee::Template tpl = engine.loadByName(QStringLiteral(":/pgpkeymessagepart.html")); Grantlee::Context ctx; ctx.setLocalizer(engine.localizer()); QObject block; block.setProperty("showKeyDetails", mp.source()->showSignatureDetails()); block.setProperty("error", mp.error()); block.setProperty("importUrl", mp.part()->makeLink(QStringLiteral("pgpkey?action=import"))); const auto key = mp.key(); if (key.isNull()) { block.setProperty("uid", mp.userID()); block.setProperty("fingerprint", mp.fingerprint()); block.setProperty("created", mp.keyDate().toString(Qt::SystemLocaleDate)); } else { const auto uid = key.userID(0); block.setProperty("hasKey", true); if (uid.email() && *uid.email() && uid.name() && *uid.name()) { block.setProperty("uid", QStringLiteral("%1 <%2>").arg(QString::fromUtf8(uid.name()), QString::fromUtf8(uid.email()))); } else if (uid.name() && *uid.name()) { block.setProperty("uid", QString::fromUtf8(uid.name())); } else if (uid.email() && *uid.email()) { block.setProperty("uid", QString::fromUtf8(uid.email())); } else { block.setProperty("uid", i18n("Unknown identity")); } block.setProperty("created", QDateTime::fromTime_t(key.subkey(0).creationTime()).toString(Qt::SystemLocaleDate)); block.setProperty("fingerprint", QString::fromLatin1(key.primaryFingerprint())); block.setProperty("keyUrl", QStringLiteral("kmail:showCertificate#GpgME ### gpgme ### %1").arg(QString::fromLatin1(key.keyID()))); } QObject style; const auto bgColor = QApplication::palette().color(QPalette::Base); if (bgColor.value() < 128) { // HSV value (brightness): 0 = darkest, 255 = brightest style.setProperty("borderColor", QColor(Qt::white).name()); style.setProperty("frameTextColor", QColor(Qt::black).name()); } else { style.setProperty("borderColor", QColor(Qt::black).name()); style.setProperty("frameTextColor", QColor(Qt::white).name()); } ctx.insert(QStringLiteral("block"), &block); ctx.insert(QStringLiteral("style"), &style); return tpl->render(&ctx); }
QString TemplateLayout::generate() { int progress = 0; int totalWork = getTotalWork(PrintOptions); QString htmlContent; delete m_engine; m_engine = new Grantlee::Engine(this); QSharedPointer<Grantlee::FileSystemTemplateLoader> m_templateLoader = QSharedPointer<Grantlee::FileSystemTemplateLoader>(new Grantlee::FileSystemTemplateLoader()); m_templateLoader->setTemplateDirs(QStringList() << getPrintingTemplatePathUser()); m_engine->addTemplateLoader(m_templateLoader); Grantlee::registerMetaType<template_options>(); Grantlee::registerMetaType<print_options>(); QVariantList diveList; struct dive *dive; int i; for_each_dive (i, dive) { //TODO check for exporting selected dives only if (!dive->selected && PrintOptions->print_selected) continue; DiveObjectHelper *d = new DiveObjectHelper(dive); diveList.append(QVariant::fromValue(d)); progress++; emit progressUpdated(progress * 100.0 / totalWork); } Grantlee::Context c; c.insert("dives", diveList); c.insert("template_options", QVariant::fromValue(*templateOptions)); c.insert("print_options", QVariant::fromValue(*PrintOptions)); Grantlee::Template t = m_engine->loadByName(PrintOptions->p_template); if (!t || t->error()) { qDebug() << "Can't load template"; return htmlContent; } htmlContent = t->render(&c); if (t->error()) { qDebug() << "Can't render template"; } return htmlContent; }
QString TemplateLayout::generate() { int progress = 0; int totalWork = getTotalWork(PrintOptions); QString htmlContent; delete m_engine; m_engine = new Grantlee::Engine(this); Grantlee::registerMetaType<template_options>(); Grantlee::registerMetaType<print_options>(); QVariantList diveList; struct dive *dive; int i; for_each_dive (i, dive) { //TODO check for exporting selected dives only if (!dive->selected && PrintOptions->print_selected) continue; DiveObjectHelper *d = new DiveObjectHelper(dive); diveList.append(QVariant::fromValue(d)); progress++; emit progressUpdated(lrint(progress * 100.0 / totalWork)); } Grantlee::Context c; c.insert("dives", diveList); c.insert("template_options", QVariant::fromValue(*templateOptions)); c.insert("print_options", QVariant::fromValue(*PrintOptions)); /* don't use the Grantlee loader API */ QString templateContents = readTemplate(PrintOptions->p_template); QString preprocessed = preprocessTemplate(templateContents); /* create the template from QString; is this thing allocating memory? */ Grantlee::Template t = m_engine->newTemplate(preprocessed, PrintOptions->p_template); if (!t || t->error()) { qDebug() << "Can't load template"; return htmlContent; } htmlContent = t->render(&c); if (t->error()) { qDebug() << "Can't render template"; } return htmlContent; }
QString TemplateLayout::generateStatistics() { QString htmlContent; delete m_engine; m_engine = new Grantlee::Engine(this); QSharedPointer<Grantlee::FileSystemTemplateLoader> m_templateLoader = QSharedPointer<Grantlee::FileSystemTemplateLoader>(new Grantlee::FileSystemTemplateLoader()); m_templateLoader->setTemplateDirs(QStringList() << getPrintingTemplatePathUser() + QDir::separator() + QString("statistics")); m_engine->addTemplateLoader(m_templateLoader); Grantlee::registerMetaType<YearInfo>(); Grantlee::registerMetaType<template_options>(); Grantlee::registerMetaType<print_options>(); QVariantList years; int i = 0; while (stats_yearly != NULL && stats_yearly[i].period) { YearInfo year(stats_yearly[i]); years.append(QVariant::fromValue(year)); i++; } Grantlee::Context c; c.insert("years", years); c.insert("template_options", QVariant::fromValue(*templateOptions)); c.insert("print_options", QVariant::fromValue(*PrintOptions)); Grantlee::Template t = m_engine->loadByName(PrintOptions->p_template); if (!t || t->error()) { qDebug() << "Can't load template"; return htmlContent; } htmlContent = t->render(&c); if (t->error()) { qDebug() << "Can't render template"; return htmlContent; } emit progressUpdated(100); return htmlContent; }
QString TemplateEngine::render(const string& file) { Grantlee::Template t = m_engine->loadByName(QString::fromStdString(file)); if (!t) { qDebug() << "Unable to load template" << QString("Error loading template: %1").arg(QString::fromStdString(file)); return QString(); } if (t->error()) { qDebug() << "Unable to load template" << QString("Error loading template: %1").arg(t->errorString()); return QString(); } QString content = t->render(&c); if (t->error()) { qDebug() << "Unable render template" << QString("Error rendering template: %1").arg(t->errorString()); return QString(); } content.replace("\n\n", "\n"); LogDebug << content.toStdString(); return content; }
void BookWindow::renderBooks() const { int rows = model->rowCount(); QVariantHash mapping; QVariantList bookList; for (int row = 0; row < rows; ++row) { QString title = model->index(row, 1).data().toString(); QString author = model->index(row, 2).data().toString(); QString genre = model->index(row, 3).data().toString(); int rating = model->index(row, 5).data().toInt(); QObject *book = new BookWrapper(author, title, genre, rating, this); QVariant var = QVariant::fromValue(book); bookList.append(var); } mapping.insert("books", bookList); QString themeName = ui.exportTheme->currentText(); Grantlee::Context c(mapping); Grantlee::Template t = m_engine->loadByName( themeName + ".html" ); if (!t) { QMessageBox::critical(this, "Unable to load template", QString( "Error loading template: %1" ).arg( themeName + ".html" ) ); return; } if ( t->error() ) { QMessageBox::critical(this, "Unable to load template", QString( "Error loading template: %1" ).arg( t->errorString() ) ); return; } bool ok; QString text = QInputDialog::getText(this, tr("Export Location"), tr("file name:"), QLineEdit::Normal, QDir::home().absolutePath() + "/book_export.html", &ok); if (!ok || text.isEmpty()) return; QFile file( text ); if ( !file.open( QIODevice::WriteOnly | QIODevice::Text ) ) return; QString content = t->render(&c); if ( t->error() ) { QMessageBox::critical(this, "Unable render template", QString( "Error rendering template: %1" ).arg( t->errorString() ) ); return; } file.write(content.toLocal8Bit()); file.close(); }
void MainWindow::generateOutput() { m_tabWidget->clear(); QString outputType = m_designWidget->outputType(); m_loader->setTheme(outputType); if (outputType == "cpp") return generateCpp(); Grantlee::Template classTemplate = m_engine->loadByName("class." + outputType); if (classTemplate->error()) { createOutputTab("Class", classTemplate->errorString()); return; } Grantlee::Context c = m_designWidget->getContext(); QString output; QTextStream textStream(&output); NoEscapeOutputStream stream(&textStream); classTemplate->render(&stream, &c); createOutputTab("Class", classTemplate->error() ? classTemplate->errorString() : output); }
static void renderTemplate( Grantlee::Engine *engine, const QString &templateName ) { Grantlee::Template t = engine->loadByName( templateName ); if ( t->error() ) { qDebug() << t->errorString(); Q_ASSERT( !"Failed to get template" ); } Grantlee::Context c; QString result = t->render( &c ); if ( t->error() ) { qDebug() << t->errorString(); Q_ASSERT( !"Failed to render template" ); } qDebug() << result; }
void MainWindow::generateCpp() { Grantlee::Template headerTemplate = m_engine->loadByName("header.h"); if (headerTemplate->error()) { createOutputTab("Header", headerTemplate->errorString()); return; } Grantlee::Context c = m_designWidget->getContext(); QString output; QTextStream textStream(&output); NoEscapeOutputStream stream(&textStream); headerTemplate->render(&stream, &c); createOutputTab("Header", headerTemplate->error() ? headerTemplate->errorString() : output); if (headerTemplate->error()) return; output.clear(); Grantlee::Template implementationTemplate = m_engine->loadByName("implementation.cpp"); if (implementationTemplate->error()) { createOutputTab("Implementation", implementationTemplate->errorString()); return; } implementationTemplate->render(&stream, &c); createOutputTab("Implementation", implementationTemplate->error() ? implementationTemplate->errorString() : output); if (implementationTemplate->error()) return; output.clear(); if (c.lookup("pimpl").toBool()) { Grantlee::Template privateHeaderTemplate = m_engine->loadByName("private_header.h"); if (privateHeaderTemplate->error()) { createOutputTab("Private Header", privateHeaderTemplate->errorString()); return; } c.insert("className", Grantlee::getSafeString(c.lookup("className")) + QString("Private")); c.insert("baseClass", QVariant()); privateHeaderTemplate->render(&stream, &c); createOutputTab("Private Header", privateHeaderTemplate->error() ? privateHeaderTemplate->errorString() : output); if (privateHeaderTemplate->error()) return; } }