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

equal deleted inserted replaced

-:06ff229162e9
+:11d3954df52a
 **
 ****************************************************************************/
 #include "hbsplashgenerator_p.h"
 #include "hbsplashdirs_p.h"
+#include "hbsplashdefs_p.h"
 #include "hbmainwindow.h"
 #include "hbmainwindow_p.h"
 #include "hbinstance.h"
 #include "hbtheme.h"
 #include "hbeffectinternal_p.h"
 #include <QPainter>
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
 #include <QSet>
+#include <QSettings>
 #include <QTranslator>
 #include <QLocale>
 #include <QTimer>
+#if defined(Q_OS_SYMBIAN)
+#include <f32file.h>
+#include <coemain.h>
+#endif
 const char *last_theme_key = "lasttheme";
 const char *last_lang_key = "lastlang";
 const char *last_file_count_key = "lastfilecount";
 const char *last_output_dir_key = "lastoutdir";
 HbSplashGenerator::HbSplashGenerator()
-: mBusy(false), mForceRegen(false), mMainWindow(0), mFirstRegenerate(true),
+: mBusy(false), mForceRegen(false), mMainWindow(0), mFirstRegenerate(true)
-mSettings("Nokia", "HbSplash")
+{
-{
+#if defined(Q_OS_SYMBIAN)
+CCoeEnv::Static()->FsSession().CreatePrivatePath(EDriveC);
+QString iniFileName = QString("c:/private/%1/hbsplashgen.ini")
+.arg(QString::number(hbsplash_server_uid3.iUid, 16));
+mSettings = new QSettings(iniFileName, QSettings::IniFormat, this);
+#else
+mSettings = new QSettings("Nokia", "HbSplash", this);
+#endif
 // 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).
 HbEffectInternal::setEffectsEnabled(false);
 }
 // Regenerate screens on startup only when the theme, the language, the
 // number of files in the splash screen directory, or the splash screen
 // directory path is different than the recorded values. (or when
 // regeneration is forced via command line arg)
-QString lastTheme = mSettings.value(QLatin1String(last_theme_key)).toString();
+QString lastTheme = mSettings->value(QLatin1String(last_theme_key)).toString();
-QString lastLang = mSettings.value(QLatin1String(last_lang_key)).toString();
+QString lastLang = mSettings->value(QLatin1String(last_lang_key)).toString();
-int lastFileCount = mSettings.value(QLatin1String(last_file_count_key)).toInt();
+int lastFileCount = mSettings->value(QLatin1String(last_file_count_key)).toInt();
-QString lastOutputDir = mSettings.value(QLatin1String(last_output_dir_key)).toString();
+QString lastOutputDir = mSettings->value(QLatin1String(last_output_dir_key)).toString();
 QString currentTheme = theme->name();
 QString currentLang = QLocale::system().name();
 QString currentOutputDir = hbsplash_output_dir();
 int currentFileCount = updateOutputDirContents(currentOutputDir);
 qDebug() << PRE << "last regen:" << lastTheme << lastLang << lastFileCount << lastOutputDir
 {
 QString themeName = hbInstance->theme()->name();
 qDebug() << PRE << "regenerate() theme:" << themeName;
 if (!themeName.isEmpty()) {
 try {
+emit regenerateStarted();
 QTime queuePrepTime;
 queuePrepTime.start();
 // Delete existing splash screens. This is important because apps
 // should never pick up a screen with the previous theme or
 // language. If the generation of the new screens (at least the
 cleanup();
 }
 }
 }
-void HbSplashGenerator::regenerateOne(const QString &splashmlFileName)
+void HbSplashGenerator::regenerateOne(const QString &splashmlFileName, const QString &customTrDir)
 {
 mQueue.clear();
 QueueItem item(hbInstance->theme()->name(), Qt::Vertical);
-item.mWorkDirForSingleFileRegen = QFileInfo(splashmlFileName).path(); // e.g. for translations
+QString path = QFileInfo(splashmlFileName).path();
+item.mCustomTrDirs.append(path);
+if (!customTrDir.isEmpty()) {
+item.mCustomTrDirs.append(customTrDir);
+}
 parseSplashml(splashmlFileName, item);
-item.mDocmlFileName = QDir(item.mWorkDirForSingleFileRegen).filePath(item.mDocmlFileName);
+item.mDocmlFileName = QDir(path).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);
 }
 // If the queue is empty then the splash regeneraton is complete so store
 // the current theme and language names as the last fully processed ones in
 // the settings and stop.
 if (mQueue.isEmpty()) {
 qDebug() << PRE << "queue is empty  regen finished";
-mSettings.setValue(last_theme_key, hbInstance->theme()->name());
+mSettings->setValue(last_theme_key, hbInstance->theme()->name());
-mSettings.setValue(last_lang_key, QLocale::system().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_file_count_key, updateOutputDirContents(outDir));
-mSettings.setValue(last_output_dir_key, 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.
 mBusy = true;
 mItem = mQueue.dequeue();
 mItemTime.start();
 log("generating splash screen", mItem.mThemeName, mItem.mOrientation);
-if (!mMainWindow) {
+ensureMainWindow();
-// The FixedVertical flag is used just to disable the sensor-based
-// orientation switching.
-mMainWindow = new HbMainWindow(0, Hb::WindowFlagFixedVertical);
-// Make sure that at least the 1st phase of the delayed
-// construction is done right now.
-HbMainWindowPrivate::d_ptr(mMainWindow)->_q_delayedConstruction();
-}
 mMainWindow->setOrientation(mItem.mOrientation, false);
 qDebug() << PRE << "mainwindow init time (ms):" << mItemTime.elapsed();
 QTime setupTime;
 setupTime.start();
 } catch (const std::bad_alloc &) {
 cleanup();
 }
 qDebug() << PRE << "processQueue() over";
+}
+void HbSplashGenerator::ensureMainWindow()
+{
+if (!mMainWindow) {
+// The FixedVertical flag is used just to disable the sensor-based
+// orientation switching.
+mMainWindow = new HbMainWindow(0, Hb::WindowFlagFixedVertical);
+// Make sure that at least the 1st phase of the delayed
+// construction is done right now.
+HbMainWindowPrivate::d_ptr(mMainWindow)->_q_delayedConstruction();
+}
 }
 void HbSplashGenerator::processWindow()
 {
 // Take the screenshot, remove content, and move on to the next request in the queue.
 QImage image = renderView();
 QTime t;
 t.start();
 QString splashFile = splashFileName();
 qDebug() << PRE << "saving to" << splashFile;
-if (saveSpl(splashFile, image)) {
+if (saveSpl(splashFile, image, mItem.mFlagsToStore)) {
 #if !defined(Q_OS_SYMBIAN) && defined(QT_DEBUG)
 image.save(splashFile + QLatin1String(".png"));
 #endif
 } else {
 qWarning() << PRE << "file write failed for" << splashFile;
 inline const uchar *imageBits(const QImage &image)
 {
 return image.bits();
 }
-bool HbSplashGenerator::saveSpl(const QString &nameWithoutExt, const QImage &image)
+bool HbSplashGenerator::saveSpl(const QString &nameWithoutExt, const QImage &image, quint32 extra)
 {
 QString fn(nameWithoutExt);
 fn.append(".spl");
 QFile f(fn);
 if (f.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
-int w = image.width();
+quint32 w = (quint32) image.width();
-int h = image.height();
+quint32 h = (quint32) image.height();
-int bpl = image.bytesPerLine();
+quint32 bpl = (quint32) image.bytesPerLine();
-QImage::Format fmt = image.format();
+qint32 fmt = (qint32) image.format();
-f.write((char *) &w, sizeof(int));
+f.write((char *) &w, sizeof(quint32));
-f.write((char *) &h, sizeof(int));
+f.write((char *) &h, sizeof(quint32));
-f.write((char *) &bpl, sizeof(int));
+f.write((char *) &bpl, sizeof(quint32));
-f.write((char *) &fmt, sizeof(QImage::Format));
+f.write((char *) &fmt, sizeof(qint32));
+f.write((char *) &extra, sizeof(quint32));
 f.write((const char *) imageBits(image), bpl * h);
 f.close();
 return true;
 }
 return false;
 return dbg;
 }
 HbSplashGenerator::QueueItem::QueueItem()
 : mOrientation(Qt::Vertical),
-mHideBackground(false)
+mHideBackground(false),
+mFlagsToStore(0)
 {
 }
 HbSplashGenerator::QueueItem::QueueItem(const QString &themeName, Qt::Orientation orientation)
-: mThemeName(themeName), mOrientation(orientation),
+: mThemeName(themeName),
-mHideBackground(false)
+mOrientation(orientation),
+mHideBackground(false),
+mFlagsToStore(0)
 {
 }
 void HbSplashGenerator::addSplashmlItemToQueue(const QueueItem &item)
 {
 }
 }
 void HbSplashGenerator::finishWindow()
 {
-// Process additional settings.
+// There must be a view always in order to support view-specific settings.
 if (mMainWindow->views().isEmpty()) {
-// There must be a view always in order to support view-specific settings.
 mMainWindow->addView(new HbWidget);
 }
 QList<HbView *> views = mMainWindow->views();
 if (!views.isEmpty()) {
 HbView *view = views.at(0);
 // view-flags
-HbView::HbViewFlags viewFlags = HbView::ViewFlagNone;
+HbView::HbViewFlags viewFlags = view->viewFlags();
 if (mItem.mViewFlags.contains("tb-minimizable")) {
 viewFlags |= HbView::ViewTitleBarMinimizable;
 }
 if (mItem.mViewFlags.contains("tb-minimized")) {
 viewFlags |= HbView::ViewTitleBarMinimized;
 }
 if (mItem.mViewFlags.contains("sb-floating")) {
 viewFlags |= HbView::ViewStatusBarFloating;
 }
 view->setViewFlags(viewFlags);
+if (viewFlags.testFlag(HbView::ViewStatusBarHidden)
+|| viewFlags.testFlag(HbView::ViewStatusBarTransparent))
+{
+mItem.mFlagsToStore |= 1;
+}
 // navi-action-icon
 if (!mItem.mNaviActionIcon.isEmpty()) {
 view->setNavigationAction(new HbAction(HbIcon(mItem.mNaviActionIcon), QString(), view));
 } // else will use the default navigation action (e.g. quit)
 mMainWindow->setBackgroundImageName(mItem.mOrientation, backgroundImageName);
 }
 }
 // Hide dynamic content from status bar (clock, indicators).
+setStatusBarElementsVisible(false);
+}
+void HbSplashGenerator::setStatusBarElementsVisible(bool visible)
+{
+HbMainWindowPrivate *mwd = HbMainWindowPrivate::d_ptr(mMainWindow);
 HbStatusBar *statusBar = mwd->mStatusBar;
 if (statusBar) {
 foreach (QGraphicsItem *item, statusBar->childItems()) {
 QString name = HbStyle::itemName(item);
-bool hideItem = name == QLatin1String("signal")
+bool knownItem =
+name == QLatin1String("signal")
 || name == QLatin1String("battery")
 || name == QLatin1String("notificationindicators")
 || name == QLatin1String("settingsindicators")
 || name == QLatin1String("timetext");
-if (hideItem) {
+if (knownItem) {
-item->setVisible(false);
+item->setVisible(visible);
 }
 }
 }
 }
 {
 QString lang = QLocale::system().name();
 QTranslator *translator = new QTranslator;
 bool ok = false;
 QStringList dirNames(hbsplash_translation_dirs());
-if (!mItem.mWorkDirForSingleFileRegen.isEmpty()) {
+dirNames.append(mItem.mCustomTrDirs);
-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.

changeset 3	11d3954df52a
parent 2	06ff229162e9
child 5	627c4a0fd0e7