FCL/sf/mw/hb: comparison src/hbservers/hbsplashgenerator/hbsplashgenerator.cpp

equal deleted inserted replaced

-:f7ac710697a9
+:06ff229162e9
 #include "hbframeitem.h"
 #include <QCoreApplication>
 #include <QPainter>
 #include <QDir>
 #include <QFile>
+#include <QFileInfo>
 #include <QSet>
 #include <QTranslator>
 #include <QLocale>
 #include <QTimer>
 const char *last_lang_key = "lastlang";
 const char *last_file_count_key = "lastfilecount";
 const char *last_output_dir_key = "lastoutdir";
 HbSplashGenerator::HbSplashGenerator()
-: mBusy(false), mMainWindow(0), mFirstRegenerate(true),
+: mBusy(false), mForceRegen(false), mMainWindow(0), mFirstRegenerate(true),
 mSettings("Nokia", "HbSplash")
 {
 // Effects on decorators (started when they are shown) would ruin
 // the screenshot. So disable everything (except the orientation
 // switch effect which is needed for a proper rotated image).
 static QString orientationName(Qt::Orientation orientation)
 {
 switch (orientation) {
 case Qt::Horizontal:
-return QString("lsc");
+return QLatin1String("lsc");
 case Qt::Vertical:
-return QString("prt");
+return QLatin1String("prt");
 default:
 return QString();
 }
 }
 return entries.count();
 }
 void HbSplashGenerator::start(bool forceRegen)
 {
+mForceRegen = forceRegen;
+QTimer::singleShot(5000, this, SLOT(doStart()));
+}
+void HbSplashGenerator::doStart()
+{
+qDebug() << PRE << "accessing theme";
 // Start listening to the theme-change-finished signal.
 HbTheme *theme = hbInstance->theme();
 connect(theme, SIGNAL(changeFinished()), SLOT(regenerate()));
 // Watch also the directories containing splashml files. Files may
 QString currentLang = QLocale::system().name();
 QString currentOutputDir = hbsplash_output_dir();
 int currentFileCount = updateOutputDirContents(currentOutputDir);
 qDebug() << PRE << "last regen:" << lastTheme << lastLang << lastFileCount << lastOutputDir
 << "current:" << currentTheme << currentLang << currentFileCount << currentOutputDir;
-if (forceRegen
+if (mForceRegen
 || currentTheme != lastTheme
 || currentLang != lastLang
 || currentFileCount != lastFileCount
 || currentOutputDir != lastOutputDir)
 {
 QMetaObject::invokeMethod(this, "regenerate", Qt::QueuedConnection);
 }
+}
+void HbSplashGenerator::uncachedRegenerate()
+{
+// Same as regenerate() but no caching is used so every file is
+// parsed again.
+mParsedSplashmls.clear();
+regenerate();
 }
 void HbSplashGenerator::regenerate()
 {
 QString themeName = hbInstance->theme()->name();
 QMetaObject::invokeMethod(this, "processQueue", Qt::QueuedConnection);
 } catch (const std::bad_alloc &) {
 cleanup();
 }
 }
+}
+void HbSplashGenerator::regenerateOne(const QString &splashmlFileName)
+{
+mQueue.clear();
+QueueItem item(hbInstance->theme()->name(), Qt::Vertical);
+item.mWorkDirForSingleFileRegen = QFileInfo(splashmlFileName).path(); // e.g. for translations
+parseSplashml(splashmlFileName, item);
+item.mDocmlFileName = QDir(item.mWorkDirForSingleFileRegen).filePath(item.mDocmlFileName);
+mQueue.enqueue(item); // generate it regardless of the fixed orientation setting
+item.mOrientation = Qt::Horizontal;
+mQueue.enqueue(item);
+QMetaObject::invokeMethod(this, "processQueue", Qt::QueuedConnection);
 }
 QImage HbSplashGenerator::renderView()
 {
 log("renderView()", mItem.mThemeName, mItem.mOrientation);
 mSettings.setValue(last_theme_key, hbInstance->theme()->name());
 mSettings.setValue(last_lang_key, QLocale::system().name());
 QString outDir = hbsplash_output_dir();
 mSettings.setValue(last_file_count_key, updateOutputDirContents(outDir));
 mSettings.setValue(last_output_dir_key, outDir);
+emit finished();
 qDebug() << PRE << "processQueue() over";
 return;
 }
 // If a previous splash generation is still in progress then do nothing.
 if (mBusy) {
 qDebug() << PRE << "splashml already parsed  queuing request" << item;
 addSplashmlItemToQueue(item);
 continue;
 }
 QueueItem item(themeName, orientation);
-QFile f(fullName);
+bool ok = parseSplashml(fullName, item);
-bool ok = f.open(QIODevice::ReadOnly);
-if (ok) {
-QXmlStreamReader xml(&f);
-bool docOk = false;
-while (!xml.atEnd()) {
-QXmlStreamReader::TokenType token = xml.readNext();
-if (token == QXmlStreamReader::Invalid) {
-qWarning() << PRE << fullName << xml.errorString();
-ok = false;
-break;
-} else if (token == QXmlStreamReader::StartElement
-&& xml.name() == QLatin1String("hbsplash"))
-{
-docOk = true;
-} else if (docOk) {
-processSplashml(xml, item);
-}
-}
-f.close();
-}
 if (ok
 && !item.mAppId.isEmpty()
 && !item.mDocmlWidgetName.isEmpty()
 && !item.mDocmlFileName.isEmpty())
 {
 item.mDocmlFileName = dir.filePath(item.mDocmlFileName);
 qDebug() << PRE << "queuing request" << item;
 addSplashmlItemToQueue(item);
 mParsedSplashmls.insert(fullName, item);
 } else {
-qWarning() << PRE << "Unable to parse" << fullName;
+qWarning() << PRE << "unable to parse" << fullName;
 }
 }
 }
+}
+inline void reportSplashmlError(const QString &fullFileName, int lineNumber, const QString &msg)
+{
+qWarning("%s", qPrintable(QString(QLatin1String("%1 \"%2\":%3: %4"))
+.arg(PRE).arg(fullFileName).arg(lineNumber).arg(msg)));
+}
+bool HbSplashGenerator::parseSplashml(const QString &fullFileName, QueueItem &item)
+{
+QFile f(fullFileName);
+bool ok = f.open(QIODevice::ReadOnly);
+if (ok) {
+QXmlStreamReader xml(&f);
+bool docOk = false;
+while (!xml.atEnd()) {
+QXmlStreamReader::TokenType token = xml.readNext();
+if (token == QXmlStreamReader::Invalid) {
+reportSplashmlError(fullFileName, xml.lineNumber(), xml.errorString());
+ok = false;
+break;
+} else if (token == QXmlStreamReader::StartElement
+&& xml.name() == QLatin1String("hbsplash"))
+{
+docOk = true;
+} else if (docOk) {
+parseSplashmlElements(xml, item, fullFileName);
+}
+}
+f.close();
+}
+return ok;
 }
 inline bool readBool(QXmlStreamReader &xml)
 {
 QString text = xml.readElementText().trimmed();
 return text == QLatin1String("true") || text == QLatin1String("1");
 }
-void HbSplashGenerator::processSplashml(QXmlStreamReader &xml, QueueItem &item)
+void HbSplashGenerator::parseSplashmlElements(QXmlStreamReader &xml,
+QueueItem &item,
+const QString &fullFileName)
 {
 if (xml.isStartElement()) {
 QStringRef name = xml.name();
 if (name == QLatin1String("docml")) {
 item.mDocmlFileName = xml.readElementText().trimmed();
 req.mFrameGraphicsName = xml.readElementText().trimmed();
 if (!req.mTargetWidgetName.isEmpty() && !req.mFrameGraphicsName.isEmpty()) {
 item.mItemBgGraphics.append(req);
 }
 } else {
-qWarning() << PRE << "unknown element" << name;
+reportSplashmlError(fullFileName, xml.lineNumber(),
+QLatin1String("unknown element: ") + name.toString());
 }
 }
 }
 class CustomDocumentLoader : public HbDocumentLoader
 mMainWindow->addView(widget);
 } else {
 qWarning() << PRE << "widget creation failed from" << mItem;
 }
 } else {
-qWarning() << PRE << "Unable to parse" << mItem.mDocmlFileName;
+qWarning() << PRE << "unable to parse" << mItem.mDocmlFileName;
 }
 }
 void HbSplashGenerator::setupNameBasedWidgetProps(HbDocumentLoader &loader)
 {
 {
 QString lang = QLocale::system().name();
 QTranslator *translator = new QTranslator;
 bool ok = false;
 QStringList dirNames(hbsplash_translation_dirs());
+if (!mItem.mWorkDirForSingleFileRegen.isEmpty()) {
+dirNames.append(mItem.mWorkDirForSingleFileRegen);
+}
 foreach (const QString &dirName, dirNames) {
 QDir dir(dirName);
 QString fullName = dir.filePath(name + '_' + lang);
 // fullName is not necessarily an existing file, however the translator
 // may still pick up another suitable file based on this name.
 if (translator->load(fullName)) {
 QCoreApplication::installTranslator(translator);
-qDebug() << PRE << "Translator installed:" << fullName;
+qDebug() << PRE << "translator installed:" << fullName;
 ok = true;
 break;
 }
 }
 if (ok) {
 mTranslators.append(translator);
 } else {
-qWarning() << PRE << "Unable to find translations based on name" << name;
+qWarning() << PRE << "unable to find translations based on name" << name;
 delete translator;
 }
 }
 void HbSplashGenerator::clearTranslators()

changeset 2	06ff229162e9
parent 1	f7ac710697a9
child 3	11d3954df52a