FCL/sf/mw/hb: comparison src/hbcore/gui/hbmainwindow.cpp

equal deleted inserted replaced

-:06ff229162e9
+:11d3954df52a
 #include "hbfeaturemanager_p.h"
 #include "hboogmwatcher_p.h"
 #ifdef Q_OS_SYMBIAN
 #include <coecntrl.h>
+#include <w32std.h>
 #include "hbnativewindow_sym_p.h"
 #endif
 /*!
 @stable
 Hb::WindowFlagNoBackground flag is set for the HbMainWindow. Normally the
 standard background item fills the entire screen so the background is not
 really visible.
 HbMainWindow has a signalling mechanism for helping control the
-application's view construction. viewReady()-signal is emitted
+application's view construction. The viewReady() signal is emitted when a
-when view's internal construction is completed and basic parts of
+view's internal construction is completed and basic parts of view are
-view are already drawn. Same signal is also emitted when current
+already drawn. Same signal is also emitted when current view has
-view is switched. This helps applications to split the view
+changed. This helps applications to split the view construction to
-construction to reasonable tasks.  For example the lower priority
+reasonable tasks.  For example the lower priority tasks like opening network
-tasks like opening network connection or preparing other currently
+connection or preparing other currently hidden application views can happen
-hidden application views can happen on background when first view
+on background when first view is already drawn.
-is already drawn.
 Example of simple Hb application constructing HbMainWindow:
 \include mainwindow1/main.cpp
 /*!
 \fn void HbMainWindow::viewReady()
 This signal is emitted first time when window content is drawn on screen.
 It will only be emitted again when current view is changed and drawn on screen.
+This means that this signal is emitted in the following cases:
+- When the mainwindow is fully constructed, this happens shortly after
+painting it for the first time.
+- When a new view is added using addView() or insertView() after the
+mainwindow is fully constructed and the newly added view becomes the
+current view. It will not be emitted when calling addView() or
+insertView() before showing the mainwindow or entering the event loop
+because in that case the signal will anyway be emitted later, when the
+mainwindow becomes ready. It is also not emitted when the newly added view
+does not become the current view.
+- When the current view is changed using setCurrentView().
 If the view switch is animated, the signal is emitted only after the effect has
 completed.
 Application developers may connect to this signal to do lower priority construction
 {
 Q_D(HbMainWindow);
 d->q_ptr = this;
 // No need for any default (e.g. blank white) background for this window.
-// Setting this attribute is mandatory in order to have a flicker-less
-// startup (both with and without splash screen).
 setAttribute(Qt::WA_NoSystemBackground);
 // Continue with basic initialization. Note: Prefer doing everything that is
 // not absolutely compulsory in _q_delayedConstruction instead.
 d->mViewStackWidget->removeAt(index);
 }
 d->mViewStackWidget->insertWidget(-1, view);
+// If the newly added view becomes the current one then emit the viewReady
+// signal (unless the delayed construction is still pending).
+if (d->mDelayedConstructionHandled && currentView() == view) {
+QMetaObject::invokeMethod(this, "_q_viewReady", Qt::QueuedConnection);
+}
 return view;
 }
 /*!
 Inserts a \a widget to a given \a index to the HbMainWindow object.
 if (!view) {
 view = new HbView();
 view->setWidget(widget);
 }
 }
 d->mViewStackWidget->insertWidget(index, view);
+// If the newly inserted view becomes the current one then emit the
+// viewReady signal (unless the delayed construction is still pending).
+if (d->mDelayedConstructionHandled && currentView() == view) {
+QMetaObject::invokeMethod(this, "_q_viewReady", Qt::QueuedConnection);
+}
 return view;
 }
 /*!
 d->mViewStackWidget->runViewSwitchEffectHide(oldView, flags);
 } else {
 // If animation is disabled or there is no view set currently then change
 // without animation.
 d->mViewStackWidget->setCurrentWidget(view);
-if (d->mDelayedConstructionHandled)
+if (d->mDelayedConstructionHandled) {
 QMetaObject::invokeMethod(this, "_q_viewReady", Qt::QueuedConnection);
+}
 }
 }
 }
 /*!
 */
 QString HbMainWindow::backgroundImageName(Qt::Orientation orientation) const
 {
 Q_D(const HbMainWindow);
 return d->mBgItem ? d->mBgItem->imageName(orientation) : QString();
+}
+/*!
+Sets the background image drawing mode. This setting controls how
+the background image is displayed.
+By default the mode is set to Hb::ScaleBackgroundToFit.
+\sa backgroundImageMode()
+\sa Hb::BackgroundImageMode
+*/
+void HbMainWindow::setBackgroundImageMode(Hb::BackgroundImageMode mode)
+{
+Q_D(HbMainWindow);
+if (d->mBgItem) {
+d->mBgItem->setImageMode(mode);
+}
+}
+/*!
+Returns the currently set background image drawing mode.
+\sa setBackgroundImageMode()
+\sa Hb::BackgroundImageMode
+*/
+Hb::BackgroundImageMode HbMainWindow::backgroundImageMode() const
+{
+Q_D(const HbMainWindow);
+return d->mBgItem ? d->mBgItem->imageMode() : Hb::ScaleBackgroundToFit;
 }
 /*!
 Sets the animations enabled when the orientation is changed automatically.
 By default animations are enabled.
 d->mTheTestUtility = new HbTheTestUtility(this);
 }
 }
 // get rid of the splash screen widget (it is not visible to the user anyway at this point)
 HbSplashScreen::destroy();
+#ifdef Q_OS_SYMBIAN
+// disable surface transparency unless we were really asked to be transparent
+if (!testAttribute(Qt::WA_TranslucentBackground)) {
+RWindow *const window = static_cast<RWindow *>(effectiveWinId()->DrawableWindow());
+window->SetSurfaceTransparency(false);
+}
+#endif
 }
 // Notify that mainwindow is (most probably) ready.
 // The signal must be emitted always, even when there was no need to do anything.
 emit d->idleEventDispatched();
 } else if(event->type() == HbMainWindowPrivate::IdleOrientationEvent) { // complete the orientation change effect chain
 }
 QGraphicsView::paintEvent(event);
 }
+void HbMainWindow::showEvent(QShowEvent *event)
+{
+#ifdef Q_OS_SYMBIAN
+// Enable surface transparency if QWidget did not do it already. This is a
+// workaround for having non-transparent surfaces filled automatically with
+// black color. The showEvent is a suitable place because the native control
+// is already created at this point, but it is not too late either.
+if (!testAttribute(Qt::WA_TranslucentBackground)) {
+RWindow *const window = static_cast<RWindow *>(effectiveWinId()->DrawableWindow());
+window->SetSurfaceTransparency(true);
+}
+#endif
+QGraphicsView::showEvent(event);
+}
 /*!
 Reimplemented from QAbstractScrollArea::scrollContentsBy().
 */
 void HbMainWindow::scrollContentsBy(int dx, int dy)
 {

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