Merge branch '4.7' of scm.dev.nokia.troll.no:qt/qt-qml into 4.7-integration

* '4.7' of scm.dev.nokia.troll.no:qt/qt-qml: (44 commits)
  Stop QMLLauncher from crashing on exit on Mac when quitting app via the
  VisualDataModel hasModelChildren role shadowed user roles.
  Allow positioning of ListView items width sub-pixel precision.
  Examples clean up
  Docs
  Improve appearance when scaling
  Tweak Qt Demo Behaviour
  forget to rename the moc include when renaming deviceorientation_maemo.cpp
  fix namespace macros
  fix QML Viewer resize modes
  forgot to cleanup the code a bit after adding Maemo5 support
  Make the QML viewer usable on the N900
  Test QTBUG-11222
  Test ListElement type via type system, not string comparison.
  Test only on X11, not only on Linux (which includes embedded).
  Handle enums in method arguments in the same way as QtScript
  Allow custom parsers to handle attached properties
  Allow components to be created from .pragma library JS files
  Fix assert
  Disallow global object properties as property names
  ...

1 files changed, 314 insertions, 173 deletions

diff --git a/tools/qml/qmlruntime.cpp b/tools/qml/qmlruntime.cpp
index 676881d..e0482cf 100644
--- a/tools/qml/qmlruntime.cpp
+++ b/tools/qml/qmlruntime.cpp
@@ -44,7 +44,15 @@
 #ifdef hz
 #undef hz
 #endif
-#include "ui_recopts.h"
+#ifdef Q_WS_MAEMO_5
+#  include <QMaemo5ValueButton>
+#  include <QMaemo5ListPickSelector>
+#  include <QWidgetAction>
+#  include <QStringListModel>
+#  include "ui_recopts_maemo5.h"
+#else
+#  include "ui_recopts.h"
+#endif
 
 #include "qmlruntime.h"
 #include <qdeclarativecontext.h>
@@ -136,24 +144,59 @@ private:
 };
 
 
-class SizedMenuBar : public QMenuBar
-{
+
+#if defined(Q_WS_MAEMO_5)
+
+class Maemo5PickerAction : public QWidgetAction {
     Q_OBJECT
 public:
-    SizedMenuBar(QWidget *parent, QWidget *referenceWidget)
-        : QMenuBar(parent), refWidget(referenceWidget)
+    Maemo5PickerAction(const QString &text, QActionGroup *actions, QObject *parent)
+        : QWidgetAction(parent), m_text(text), m_actions(actions)
+    { }
+
+    QWidget *createWidget(QWidget *parent)
     {
+	QMaemo5ValueButton *button = new QMaemo5ValueButton(m_text, parent);
+	button->setValueLayout(QMaemo5ValueButton::ValueUnderTextCentered);
+        QMaemo5ListPickSelector *pick = new QMaemo5ListPickSelector(button);
+	button->setPickSelector(pick);
+	if (m_actions) {
+	    QStringList sl;
+	    int curIdx = -1, idx = 0;
+	    foreach (QAction *a, m_actions->actions()) {
+		sl << a->text();
+		if (a->isChecked())
+		    curIdx = idx;
+		idx++;
+            }
+	    pick->setModel(new QStringListModel(sl));
+	    pick->setCurrentIndex(curIdx);
+	} else {
+	    button->setEnabled(false);
+	}
+	connect(pick, SIGNAL(selected(QString)), this, SLOT(emitTriggered()));
+	return button;
     }
 
-    virtual QSize sizeHint() const
+private slots:
+    void emitTriggered()
     {
-        return QSize(refWidget->sizeHint().width(), QMenuBar::sizeHint().height());
+	QMaemo5ListPickSelector *pick = qobject_cast<QMaemo5ListPickSelector *>(sender());
+	if (!pick)
+	    return;
+	int idx = pick->currentIndex();
+
+	if (m_actions && idx >= 0 && idx < m_actions->actions().count())
+	    m_actions->actions().at(idx)->trigger();
     }
 
 private:
-    QWidget *refWidget;
+    QString m_text;
+    QPointer<QActionGroup> m_actions;
 };
 
+#endif // Q_WS_MAEMO_5
+
 static struct { const char *name, *args; } ffmpegprofiles[] = {
     {"Maximum Quality", "-sameq"},
     {"High Quality", "-qmax 2"},
@@ -170,7 +213,9 @@ public:
     RecordingDialog(QWidget *parent) : QDialog(parent)
     {
         setupUi(this);
+#ifndef Q_WS_MAEMO_5
         hz->setValidator(new QDoubleValidator(hz));
+#endif
         for (int i=0; ffmpegprofiles[i].name; ++i) {
             profile->addItem(ffmpegprofiles[i].name);
         }
@@ -197,6 +242,132 @@ public:
         return ffmpegprofiles[i].args[0] ? QLatin1String(ffmpegprofiles[i].args) : customargs;
     }
 
+    void setOriginalSize(const QSize &s)
+    {
+        QString str = tr("Original (%1x%2)").arg(s.width()).arg(s.height());
+
+#ifdef Q_WS_MAEMO_5
+        sizeCombo->setItemText(0, str);
+#else
+        sizeOriginal->setText(str);
+        if (sizeWidth->value()<=1) {
+            sizeWidth->setValue(s.width());
+            sizeHeight->setValue(s.height());
+        }
+#endif
+    }
+
+    void showffmpegOptions(bool b)
+    {
+#ifdef Q_WS_MAEMO_5
+        profileLabel->setVisible(b);
+        profile->setVisible(b);
+        ffmpegHelp->setVisible(b);
+        args->setVisible(b);
+#else
+        ffmpegOptions->setVisible(b);
+#endif
+    }
+
+    void showRateOptions(bool b)
+    {
+#ifdef Q_WS_MAEMO_5
+        rateLabel->setVisible(b);
+        rateCombo->setVisible(b);
+#else
+        rateOptions->setVisible(b);
+#endif
+    }
+
+    void setVideoRate(int rate)
+    {
+#ifdef Q_WS_MAEMO_5
+        int idx;
+        if (rate >= 60)
+            idx = 0;
+        else if (rate >= 50)
+            idx = 2;
+        else if (rate >= 25)
+            idx = 3;
+        else if (rate >= 24)
+            idx = 4;
+        else if (rate >= 20)
+            idx = 5;
+        else if (rate >= 15)
+            idx = 6;
+        else
+            idx = 7;
+        rateCombo->setCurrentIndex(idx);
+#else
+        if (rate == 24)
+            hz24->setChecked(true);
+        else if (rate == 25)
+            hz25->setChecked(true);
+        else if (rate == 50)
+            hz50->setChecked(true);
+        else if (rate == 60)
+            hz60->setChecked(true);
+        else {
+            hzCustom->setChecked(true);
+            hz->setText(QString::number(rate));
+        }
+#endif
+    }
+
+    int videoRate() const
+    {
+#ifdef Q_WS_MAEMO_5
+        switch (rateCombo->currentIndex()) {
+            case 0: return 60;
+            case 1: return 50;
+            case 2: return 25;
+            case 3: return 24;
+            case 4: return 20;
+            case 5: return 15;
+            case 7: return 10;
+            default: return 60;
+        }
+#else
+        if (hz24->isChecked())
+            return 24;
+        else if (hz25->isChecked())
+            return 25;
+        else if (hz50->isChecked())
+            return 50;
+        else if (hz60->isChecked())
+            return 60;
+        else {
+            return hz->text().toInt();
+        }
+#endif
+    }
+
+    QSize videoSize() const
+    {
+#ifdef Q_WS_MAEMO_5
+        switch (sizeCombo->currentIndex()) {
+            case 0: return QSize();
+            case 1: return QSize(640,480);
+            case 2: return QSize(320,240);
+            case 3: return QSize(1280,720);
+            default: return QSize();
+        }
+#else
+        if (sizeOriginal->isChecked())
+            return QSize();
+        else if (size720p->isChecked())
+            return QSize(1280,720);
+        else if (sizeVGA->isChecked())
+            return QSize(640,480);
+        else if (sizeQVGA->isChecked())
+            return QSize(320,240);
+        else
+            return QSize(sizeWidth->value(), sizeHeight->value());
+#endif
+    }
+
+
+
 private slots:
     void pickProfile(int i)
     {
@@ -363,15 +534,21 @@ QString QDeclarativeViewer::getVideoFileName()
     return QFileDialog::getSaveFileName(this, title, "", types.join(";; "));
 }
 
+QDeclarativeViewer *QDeclarativeViewer::inst = 0;
+
+QDeclarativeViewer *QDeclarativeViewer::instance(QWidget *parent, Qt::WindowFlags flags)
+{
+    if (!inst) {
+        inst = new QDeclarativeViewer(parent, flags);
+        inst->setAttribute(Qt::WA_DeleteOnClose);
+    }
+    return inst;
+}
 
 QDeclarativeViewer::QDeclarativeViewer(QWidget *parent, Qt::WindowFlags flags)
-#if defined(Q_OS_SYMBIAN)
     : QMainWindow(parent, flags)
-#else
-    : QWidget(parent, flags)
-#endif
-      , loggerWindow(new LoggerWidget())
-      , frame_stream(0), mb(0)
+      , loggerWindow(new LoggerWidget(this))
+      , frame_stream(0)
       , orientation(0)
       , showWarningsWindow(0)
       , m_scriptOptions(0)
@@ -381,6 +558,10 @@ QDeclarativeViewer::QDeclarativeViewer(QWidget *parent, Qt::WindowFlags flags)
 {
     QDeclarativeViewer::registerTypes();
     setWindowTitle(tr("Qt QML Viewer"));
+#ifdef Q_WS_MAEMO_5
+    setAttribute(Qt::WA_Maemo5StackedWindow);
+//    setPalette(QApplication::palette("QLabel"));
+#endif
 
     devicemode = false;
     canvas = 0;
@@ -393,9 +574,9 @@ QDeclarativeViewer::QDeclarativeViewer(QWidget *parent, Qt::WindowFlags flags)
     senseFfmpeg();
     senseImageMagick();
     if (!ffmpegAvailable)
-        recdlg->ffmpegOptions->hide();
+        recdlg->showffmpegOptions(false);
     if (!ffmpegAvailable && !convertAvailable)
-        recdlg->rateOptions->hide();
+        recdlg->showRateOptions(false);
     QString warn;
     if (!ffmpegAvailable) {
         if (!convertAvailable)
@@ -422,21 +603,14 @@ QDeclarativeViewer::QDeclarativeViewer(QWidget *parent, Qt::WindowFlags flags)
     QObject::connect(warningsWidget(), SIGNAL(closed()), this, SLOT(warningsWidgetClosed()));
 
     if (!(flags & Qt::FramelessWindowHint)) {
-        createMenu(menuBar(),0);
+        createMenu();
         changeOrientation(orientation->actions().value(0));
+    } else {
+        setMenuBar(0);
     }
 
-#if !defined(Q_OS_SYMBIAN)
-    QVBoxLayout *layout = new QVBoxLayout;
-    layout->setMargin(0);
-    layout->setSpacing(0);
-    setLayout(layout);
-    if (mb)
-        layout->addWidget(mb);
-    layout->addWidget(canvas);
-#else
     setCentralWidget(canvas);
-#endif
+
     namFactory = new NetworkAccessManagerFactory;
     canvas->engine()->setNetworkAccessManagerFactory(namFactory);
 
@@ -449,6 +623,8 @@ QDeclarativeViewer::QDeclarativeViewer(QWidget *parent, Qt::WindowFlags flags)
     autoStopTimer.setRunning(false);
     recordTimer.setRunning(false);
     recordTimer.setRepeating(true);
+
+    QObject::connect(qApp, SIGNAL(aboutToQuit()), this, SLOT(appAboutToQuit()));
 }
 
 QDeclarativeViewer::~QDeclarativeViewer()
@@ -468,26 +644,6 @@ void QDeclarativeViewer::enableExperimentalGestures()
     canvas->viewport()->setAttribute(Qt::WA_AcceptTouchEvents);
 }
 
-int QDeclarativeViewer::menuBarHeight() const
-{
-    if (!(windowFlags() & Qt::FramelessWindowHint))
-        return menuBar()->height();
-    else
-        return 0; // don't create menu
-}
-
-QMenuBar *QDeclarativeViewer::menuBar() const
-{
-#if !defined(Q_OS_SYMBIAN)
-    if (!mb)
-        mb = new SizedMenuBar((QWidget*)this, canvas);
-#else
-    mb = QMainWindow::menuBar();
-#endif
-
-    return mb;
-}
-
 QDeclarativeView *QDeclarativeViewer::view() const
 {
     return canvas;
@@ -498,120 +654,128 @@ LoggerWidget *QDeclarativeViewer::warningsWidget() const
     return loggerWindow;
 }
 
-void QDeclarativeViewer::createMenu(QMenuBar *menu, QMenu *flatmenu)
+void QDeclarativeViewer::createMenu()
 {
-    QObject *parent = flatmenu ? (QObject*)flatmenu : (QObject*)menu;
-
-    QMenu *fileMenu = flatmenu ? flatmenu : menu->addMenu(tr("&File"));
-
-    QAction *openAction = new QAction(tr("&Open..."), parent);
+    QAction *openAction = new QAction(tr("&Open..."), this);
     openAction->setShortcut(QKeySequence("Ctrl+O"));
     connect(openAction, SIGNAL(triggered()), this, SLOT(openFile()));
-    fileMenu->addAction(openAction);
 
-    QAction *reloadAction = new QAction(tr("&Reload"), parent);
+    QAction *reloadAction = new QAction(tr("&Reload"), this);
     reloadAction->setShortcut(QKeySequence("Ctrl+R"));
     connect(reloadAction, SIGNAL(triggered()), this, SLOT(reload()));
-    fileMenu->addAction(reloadAction);
 
-#if !defined(Q_OS_SYMBIAN)
-    if (flatmenu) flatmenu->addSeparator();
-
-    QMenu *recordMenu = flatmenu ? flatmenu : menu->addMenu(tr("&Recording"));
-
-    QAction *snapshotAction = new QAction(tr("&Take Snapshot\tF3"), parent);
+    QAction *snapshotAction = new QAction(tr("&Take Snapshot"), this);
+    snapshotAction->setShortcut(QKeySequence("F3"));
     connect(snapshotAction, SIGNAL(triggered()), this, SLOT(takeSnapShot()));
-    recordMenu->addAction(snapshotAction);
 
-    recordAction = new QAction(tr("Start Recording &Video\tF9"), parent);
+    recordAction = new QAction(tr("Start Recording &Video"), this);
+    recordAction->setShortcut(QKeySequence("F9"));
     connect(recordAction, SIGNAL(triggered()), this, SLOT(toggleRecordingWithSelection()));
-    recordMenu->addAction(recordAction);
 
-    QAction *recordOptions = new QAction(tr("Video &Options..."), parent);
+    QAction *recordOptions = new QAction(tr("Video &Options..."), this);
     connect(recordOptions, SIGNAL(triggered()), this, SLOT(chooseRecordingOptions()));
 
-    if (flatmenu)
-        flatmenu->addAction(recordOptions);
-
-    if (flatmenu) flatmenu->addSeparator();
-
-    QMenu *debugMenu = flatmenu ? flatmenu->addMenu(tr("&Debugging")) : menu->addMenu(tr("&Debugging"));
-
-    QAction *slowAction = new QAction(tr("&Slow Down Animations"), parent);
+    QAction *slowAction = new QAction(tr("&Slow Down Animations"), this);
     slowAction->setShortcut(QKeySequence("Ctrl+."));
     slowAction->setCheckable(true);
     connect(slowAction, SIGNAL(triggered(bool)), this, SLOT(setSlowMode(bool)));
-    debugMenu->addAction(slowAction);
 
-    showWarningsWindow = new QAction(tr("Show Warnings"), parent);
+    showWarningsWindow = new QAction(tr("Show Warnings"), this);
     showWarningsWindow->setCheckable((true));
     showWarningsWindow->setChecked(loggerWindow->isVisible());
     connect(showWarningsWindow, SIGNAL(triggered(bool)), this, SLOT(showWarnings(bool)));
 
-#if !defined(Q_OS_SYMBIAN)
-    debugMenu->addAction(showWarningsWindow);
-#endif
-
-    if (flatmenu) flatmenu->addSeparator();
-
-#endif // Q_OS_SYMBIAN
-
-    QMenu *settingsMenu = flatmenu ? flatmenu : menu->addMenu(tr("S&ettings"));
-    QAction *proxyAction = new QAction(tr("Http &proxy..."), parent);
+    QAction *proxyAction = new QAction(tr("HTTP &Proxy..."), this);
     connect(proxyAction, SIGNAL(triggered()), this, SLOT(showProxySettings()));
-    settingsMenu->addAction(proxyAction);
-#if !defined(Q_OS_SYMBIAN)
-    if (!flatmenu)
-        settingsMenu->addAction(recordOptions);
 
-    settingsMenu->addMenu(loggerWindow->preferencesMenu());
-#else
-    QAction *fullscreenAction = new QAction(tr("Full Screen"), parent);
+    QAction *fullscreenAction = new QAction(tr("Full Screen"), this);
     fullscreenAction->setCheckable(true);
     connect(fullscreenAction, SIGNAL(triggered()), this, SLOT(toggleFullScreen()));
-    settingsMenu->addAction(fullscreenAction);
-#endif
 
-    if (flatmenu) flatmenu->addSeparator();
-
-    QMenu *propertiesMenu = settingsMenu->addMenu(tr("Properties"));
-
-    orientation = new QActionGroup(parent);
-
-    QAction *rotateOrientation = new QAction(tr("Rotate orientation"), parent);
+    QAction *rotateOrientation = new QAction(tr("Rotate orientation"), this);
     rotateOrientation->setShortcut(QKeySequence("Ctrl+T"));
-    settingsMenu->addAction(rotateOrientation);
     connect(rotateOrientation, SIGNAL(triggered()), this, SLOT(rotateOrientation()));
 
+    orientation = new QActionGroup(this);
     orientation->setExclusive(true);
     connect(orientation, SIGNAL(triggered(QAction*)), this, SLOT(changeOrientation(QAction*)));
 
-    orientation->addAction(tr("orientation: Portrait"));
-    orientation->addAction(tr("orientation: Landscape"));
-    orientation->addAction(tr("orientation: Portrait (Inverted)"));
-    orientation->addAction(tr("orientation: Landscape (Inverted)"));
-    QList<QAction *> actions = orientation->actions();
-    for (int i=0; i<actions.count(); i++) {
-        propertiesMenu->addAction(actions[i]);
-        actions[i]->setCheckable(true);
-    }
+    QAction *portraitAction = new QAction(tr("Portrait"), this);
+    portraitAction->setCheckable(true);
+    QAction *landscapeAction = new QAction(tr("Landscape"), this);
+    landscapeAction->setCheckable(true);
+    QAction *portraitInvAction = new QAction(tr("Portrait (inverted)"), this);
+    portraitInvAction->setCheckable(true);
+    QAction *landscapeInvAction = new QAction(tr("Landscape (inverted)"), this);
+    landscapeInvAction->setCheckable(true);
 
-    if (flatmenu) flatmenu->addSeparator();
-
-    QMenu *helpMenu = flatmenu ? flatmenu : menu->addMenu(tr("&Help"));
-    QAction *aboutAction = new QAction(tr("&About Qt..."), parent);
+    QAction *aboutAction = new QAction(tr("&About Qt..."), this);
     connect(aboutAction, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
-    helpMenu->addAction(aboutAction);
 
-    QAction *quitAction = new QAction(tr("&Quit"), parent);
+    QAction *quitAction = new QAction(tr("&Quit"), this);
     quitAction->setShortcut(QKeySequence("Ctrl+Q"));
     connect(quitAction, SIGNAL(triggered()), qApp, SLOT(quit()));
+
+    QMenuBar *menu = menuBar();
+    if (!menu)
+	return;
+
+#if defined(Q_WS_MAEMO_5)
+    menu->addAction(openAction);
+    menu->addAction(reloadAction);
+
+    menu->addAction(snapshotAction);
+    menu->addAction(recordAction);
+
+    menu->addAction(recordOptions);
+    menu->addAction(proxyAction);
+
+    menu->addAction(slowAction);
+    menu->addAction(showWarningsWindow);
+
+    orientation->addAction(landscapeAction);
+    orientation->addAction(portraitAction);
+    menu->addAction(new Maemo5PickerAction(tr("Set orientation"), orientation, this));
+    menu->addAction(fullscreenAction);
+    return;
+#endif // Q_WS_MAEMO_5
+
+    QMenu *fileMenu = menu->addMenu(tr("&File"));
+    fileMenu->addAction(openAction);
+    fileMenu->addAction(reloadAction);
     fileMenu->addSeparator();
     fileMenu->addAction(quitAction);
-    if (menu) {
-        menu->setFixedHeight(menu->sizeHint().height());
-        menu->setMinimumWidth(10);
-    }
+
+#if !defined(Q_OS_SYMBIAN)
+    QMenu *recordMenu = menu->addMenu(tr("&Recording"));
+    recordMenu->addAction(snapshotAction);
+    recordMenu->addAction(recordAction);
+
+    QMenu *debugMenu = menu->addMenu(tr("&Debugging"));
+    debugMenu->addAction(slowAction);
+    debugMenu->addAction(showWarningsWindow);
+#endif // ! Q_OS_SYMBIAN
+
+    QMenu *settingsMenu = menu->addMenu(tr("S&ettings"));
+    settingsMenu->addAction(proxyAction);
+#if !defined(Q_OS_SYMBIAN)
+    settingsMenu->addAction(recordOptions);
+    settingsMenu->addMenu(loggerWindow->preferencesMenu());
+#else // ! Q_OS_SYMBIAN
+    settingsMenu->addAction(fullscreenAction);
+#endif // Q_OS_SYMBIAN
+    settingsMenu->addAction(rotateOrientation);
+
+    QMenu *propertiesMenu = settingsMenu->addMenu(tr("Properties"));
+
+    orientation->addAction(portraitAction);
+    orientation->addAction(landscapeAction);
+    orientation->addAction(portraitInvAction);
+    orientation->addAction(landscapeInvAction);
+    propertiesMenu->addActions(orientation->actions());
+
+    QMenu *helpMenu = menu->addMenu(tr("&Help"));
+    helpMenu->addAction(aboutAction);
 }
 
 void QDeclarativeViewer::showProxySettings()
@@ -685,25 +849,11 @@ void QDeclarativeViewer::chooseRecordingOptions()
     recdlg->file->setText(record_file);
 
     // Size
-    recdlg->sizeOriginal->setText(tr("Original (%1x%2)").arg(canvas->width()).arg(canvas->height()));
-    if (recdlg->sizeWidth->value()<=1) {
-        recdlg->sizeWidth->setValue(canvas->width());
-        recdlg->sizeHeight->setValue(canvas->height());
-    }
+    recdlg->setOriginalSize(canvas->size());
 
     // Rate
-    if (record_rate == 24)
-        recdlg->hz24->setChecked(true);
-    else if (record_rate == 25)
-        recdlg->hz25->setChecked(true);
-    else if (record_rate == 50)
-        recdlg->hz50->setChecked(true);
-    else if (record_rate == 60)
-        recdlg->hz60->setChecked(true);
-    else {
-        recdlg->hzCustom->setChecked(true);
-        recdlg->hz->setText(QString::number(record_rate));
-    }
+    recdlg->setVideoRate(record_rate);
+
 
     // Profile
     recdlg->setArguments(record_args.join(" "));
@@ -711,28 +861,9 @@ void QDeclarativeViewer::chooseRecordingOptions()
         // File
         record_file = recdlg->file->text();
         // Size
-        if (recdlg->sizeOriginal->isChecked())
-            record_outsize = QSize();
-        else if (recdlg->size720p->isChecked())
-            record_outsize = QSize(1280,720);
-        else if (recdlg->sizeVGA->isChecked())
-            record_outsize = QSize(640,480);
-        else if (recdlg->sizeQVGA->isChecked())
-            record_outsize = QSize(320,240);
-        else
-            record_outsize = QSize(recdlg->sizeWidth->value(),recdlg->sizeHeight->value());
+        record_outsize = recdlg->videoSize();
         // Rate
-        if (recdlg->hz24->isChecked())
-            record_rate = 24;
-        else if (recdlg->hz25->isChecked())
-            record_rate = 25;
-        else if (recdlg->hz50->isChecked())
-            record_rate = 50;
-        else if (recdlg->hz60->isChecked())
-            record_rate = 60;
-        else {
-            record_rate = recdlg->hz->text().toDouble();
-        }
+        record_rate = recdlg->videoRate();
         // Profile
         record_args = recdlg->arguments().split(" ",QString::SkipEmptyParts);
     }
@@ -807,8 +938,9 @@ void QDeclarativeViewer::statusChanged()
         initialSize = canvas->initialSize();
         if (canvas->resizeMode() == QDeclarativeView::SizeRootObjectToView) {
             if (!isFullScreen() && !isMaximized()) {
-                resize(QSize(initialSize.width(), initialSize.height()+menuBarHeight()));
-                updateSizeHints();
+                canvas->setFixedSize(initialSize);
+                resize(1, 1); // workaround for QMainWindowLayout NOT shrinking the window if the centralWidget() shrink
+                QTimer::singleShot(0, this, SLOT(updateSizeHints()));
             }
         }
     }
@@ -1147,6 +1279,16 @@ void QDeclarativeViewer::ffmpegFinished(int code)
     qDebug() << "ffmpeg returned" << code << frame_stream->readAllStandardError();
 }
 
+void QDeclarativeViewer::appAboutToQuit()
+{
+    // avoid QGLContext errors about invalid contexts on exit
+    canvas->setViewport(0);
+
+    // avoid crashes if messages are received after app has closed
+    delete loggerWindow;
+    loggerWindow = 0;
+}
+
 void QDeclarativeViewer::autoStartRecording()
 {
     setRecording(true);
@@ -1181,14 +1323,14 @@ void QDeclarativeViewer::changeOrientation(QAction *action)
         return;
     action->setChecked(true);
 
-    QString o = action->text().split(QLatin1Char(':')).value(1).trimmed();
+    QString o = action->text();
     if (o == QLatin1String("Portrait"))
         DeviceOrientation::instance()->setOrientation(DeviceOrientation::Portrait);
     else if (o == QLatin1String("Landscape"))
         DeviceOrientation::instance()->setOrientation(DeviceOrientation::Landscape);
-    else if (o == QLatin1String("Portrait (Inverted)"))
+    else if (o == QLatin1String("Portrait (inverted)"))
         DeviceOrientation::instance()->setOrientation(DeviceOrientation::PortraitInverted);
-    else if (o == QLatin1String("Landscape (Inverted)"))
+    else if (o == QLatin1String("Landscape (inverted)"))
         DeviceOrientation::instance()->setOrientation(DeviceOrientation::LandscapeInverted);
 }
 
@@ -1197,9 +1339,10 @@ void QDeclarativeViewer::orientationChanged()
     if (canvas->resizeMode() == QDeclarativeView::SizeRootObjectToView) {
         if (canvas->rootObject()) {
             QSizeF rootObjectSize = canvas->rootObject()->boundingRect().size();
-            QSize newSize(rootObjectSize.width(), rootObjectSize.height()+menuBarHeight());
-            if (size() != newSize) {
-                resize(newSize);
+            if (size() != rootObjectSize.toSize()) {
+                canvas->setMinimumSize(rootObjectSize.toSize());
+                canvas->resize(rootObjectSize.toSize());
+                resize(1, 1); // workaround for QMainWindowLayout NOT shrinking the window if the centralWidget() shrinks
             }
         }
     }
@@ -1253,16 +1396,14 @@ void QDeclarativeViewer::updateSizeHints()
 {
     if (canvas->resizeMode() == QDeclarativeView::SizeViewToRootObject) {
         QSize newWindowSize = canvas->sizeHint();
-        newWindowSize.setHeight(newWindowSize.height()+menuBarHeight());
         if (!isFullScreen() && !isMaximized()) {
-            resize(newWindowSize);
-            setFixedSize(newWindowSize);
+            canvas->setMinimumSize(newWindowSize);
+            canvas->resize(newWindowSize);
+            resize(1, 1); // workaround for QMainWindowLayout NOT shrinking the window if the centralWidget() shrinks
         }
     } else { // QDeclarativeView::SizeRootObjectToView
         canvas->setMinimumSize(QSize(0,0));
         canvas->setMaximumSize(QSize(16777215,16777215));
-        setMinimumSize(QSize(0,0));
-        setMaximumSize(QSize(16777215,16777215));
     }
 }