--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hbcore/gui/hbmainwindow.cpp Mon Apr 19 14:02:13 2010 +0300
@@ -0,0 +1,1143 @@
+/****************************************************************************
+**
+** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (developer.feedback@nokia.com)
+**
+** This file is part of the HbCore module of the UI Extensions for Mobile.
+**
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this file.
+** Please review the following information to ensure the GNU Lesser General
+** Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at developer.feedback@nokia.com.
+**
+****************************************************************************/
+
+#include <QGraphicsView>
+#include <QGraphicsWidget>
+#include <QGraphicsItem>
+#include <QGraphicsScene>
+
+#include "hbaction.h"
+#include "hbbackgrounditem_p.h"
+#include "hbdeviceprofile_p.h"
+#include "hbindicatorgroup_p.h"
+#include "hbinstance.h"
+#include "hbinstance_p.h"
+#include "hbgraphicsscene.h"
+#include "hbmainwindow.h"
+#include "hbmainwindow_p.h"
+#include "hbnamespace.h"
+#include "hbnamespace_p.h"
+#include "hbsoftkey_p.h"
+#include "hbsoftkeygroup_p.h"
+#include "hbtitlebar_p.h"
+#include "hbstatusbar_p.h"
+#include "hbstyle.h"
+#include "hbtitlepane_p.h"
+#include "hbtoolbar.h"
+#include "hbtoolbar_p.h"
+#include "hbview.h"
+#include "hblayoutdirectionnotifier_p.h"
+#ifdef HB_EFFECTS
+#include "hbeffect.h"
+#include "hbeffectinternal_p.h"
+#endif
+#include "hbthetestutility_p.h"
+#include "hbglobal_p.h"
+#include "hbevent.h"
+#include "hbsplashscreen_p.h"
+#include "hbcontentwidget_p.h"
+#include "hbscreen_p.h"
+#include "hbmainwindoworientation_p.h"
+#include "hbfeaturemanager_p.h"
+
+#ifdef Q_OS_SYMBIAN
+#include <coecntrl.h>
+#include "hbnativewindow_sym_p.h"
+#endif
+
+/*!
+ @beta
+ @hbcore
+ \class HbMainWindow
+
+ \brief HbMainWindow is a GraphicsView instance, which can be initialized with S60
+ style decorators.
+
+ HbMainWindow is a specialized version of QGraphicsView. It represents the
+ main window of an application. HbMainWindow constructs also HbGraphicsScene,
+ which has separate layers where user can place graphics items. HbMainWindow
+ constructs three layers which are drawn on top of each other: background
+ layer, content layer and decorator layer. The level of depth of graphics
+ items is set at the items creation time by setting its parent. To place an
+ item on the content level use currentView() function to get content layer.
+
+ Do not call QGraphicsView::setBackgroundBrush() on a HbMainWindow, prefer
+ using QGraphicsScene::setBackgroundBrush() instead. By setting the
+ background brush for the graphics view certain functionality provided by
+ HbGraphicsScene's background drawing code would be lost. Also, the scene's
+ background brush is only effective (visible) when the
+ 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
+ when view's internal construction is completed and basic parts of
+ view are already drawn. Same signal is also emitted when current
+ view is switched. This helps applications to split the view
+ construction to reasonable tasks. For example the lower priority
+ tasks like opening network connection or preparing other currently
+ hidden application views can happen on background when first view
+ is already drawn.
+
+ Example of simple Hb application constructing HbMainWindow:
+
+ \include mainwindow1/main.cpp
+
+ Example of adding stock widgets to HbMainWindow:
+
+ \include mainwindow2/main.cpp
+
+ Following example has a linear layout set to a widget, which is then added
+ to the HbMainWindow. Layout contains two widgets HbLabel and HbPushButton.
+
+ \include mainwindow3/main.cpp
+
+ More examples can be found from HbView class.
+
+ \sa HbView, Hb::ZValues, Hb::WindowFlags
+*/
+
+/*!
+ \fn void HbMainWindow::aboutToChangeOrientation()
+
+ This signal is emitted when the orientation change starts.
+ */
+
+/*!
+ \fn void HbMainWindow::aboutToChangeOrientation(Qt::Orientation newOrientation, bool animated)
+
+ This signal is emitted when the orientation change starts. This version of aboutToChangeOrientation also includes the information
+ about the new orientation and whether the orientation change is animated or not.
+ This can be used for example by widgets who want to participate in the orientation change animation.
+ */
+
+/*!
+ \fn void HbMainWindow::orientationChanged()
+
+ This signal is emitted when animation related to orientation change has completed.
+ */
+
+/*!
+ \deprecated HbMainWindow::currentViewIndexChanged(int)
+ is deprecated.
+
+ \fn void HbMainWindow::currentViewIndexChanged(int index)
+
+ This signal is emitted when the current view index changes.
+ */
+
+/*!
+ \fn void HbMainWindow::currentViewChanged(HbView *view)
+
+ This signal is emitted when the current view changes.
+ */
+
+/*!
+ \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.
+
+ If applicationlaunch or current view is switched with effect, signal is
+ emitted after the effect has completed.
+
+ Application developers may connect to this signal to do lower priority construction tasks. When
+ thinking about the tasks, it's important to keep the UI responsive all the time.
+ */
+
+/*!
+ \class HbRootItem
+
+ \brief The parent of all graphics items (including the clipping item (HbScreen)
+ and the background item). Basically it is a HbWidget with polishing disabled
+ (so we won't waste time with that).
+
+ \internal
+ */
+
+class HbRootItem : public HbWidget
+{
+public:
+ explicit HbRootItem( QGraphicsItem *parent = 0 );
+ ~HbRootItem() {}
+private:
+ bool event(QEvent *event);
+};
+
+/*!
+ Constructs an HbMainWindow object with \a parent.
+
+ \a windowFlags can be used for specifying special functionality to HbMainWindow.
+
+ \sa Hb::WindowFlag
+*/
+HbMainWindow::HbMainWindow(QWidget *parent, Hb::WindowFlags windowFlags):
+ QGraphicsView(parent), d_ptr(new HbMainWindowPrivate)
+{
+ 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->init();
+
+ if (windowFlags & Hb::WindowFlagTransparent) {
+ setWindowFlags(Qt::FramelessWindowHint);
+ setAttribute(Qt::WA_TranslucentBackground);
+ }
+
+ HbDeviceProfile profile(HbDeviceProfile::current());
+ QSize pSize(profile.logicalSize());
+
+ //Determine the default orientation width < height -> portrait
+ if (pSize.width() < pSize.height()) {
+ d->mDefaultOrientation = Qt::Vertical;
+ } else {
+ d->mDefaultOrientation = Qt::Horizontal;
+ }
+
+ // Check if there is special needs from application
+ if (windowFlags & Hb::WindowFlagFixedVertical) {
+ HbMainWindowOrientation::instance()->setFixedOrientation(Qt::Vertical);
+ d->mOrientation = Qt::Vertical;
+ d->mAutomaticOrientationSwitch = false;
+ } else if (windowFlags & Hb::WindowFlagFixedHorizontal) {
+ HbMainWindowOrientation::instance()->setFixedOrientation(Qt::Horizontal);
+ d->mOrientation = Qt::Horizontal;
+ d->mAutomaticOrientationSwitch = false;
+ } else {
+ d->mOrientation = HbMainWindowOrientation::instance()->sensorOrientation();
+ d->mAutomaticOrientationSwitch = true;
+ }
+
+#if defined(Q_WS_S60) || defined(HB_Q_WS_MAEMO)
+ setWindowState(Qt::WindowFullScreen);
+#endif//Q_WS_S60
+ setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+ setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+ setFrameShape(QFrame::NoFrame);
+
+ // create scene and style
+ d->mScene = new HbGraphicsScene(this);
+
+ // workaround for problems with BSP tree implementation in Qt
+ d->mScene->setItemIndexMethod(QGraphicsScene::NoIndex);
+
+ d->mScene->setSceneRect(0, 0, pSize.width(), pSize.height());
+ setScene(d->mScene);
+
+ // add root item
+ d->mRootItem = new HbRootItem;
+ d->mRootItem->setZValue(HbPrivate::RootItemZValue);
+ d->mScene->addItem(d->mRootItem);
+
+ // add background item
+ if (!(windowFlags & Hb::WindowFlagNoBackground)) {
+ d->addBackgroundItem();
+ }
+
+ // add clipping item
+ d->mClippingItem = new HbScreen;
+ d->mClippingItem->setParentItem(d->mRootItem);
+ d->mClippingItem->setZValue(HbPrivate::ContentZValue);
+
+ // create content (stacked) widget
+ d->mViewStackWidget = new HbContentWidget(this, d->mClippingItem);
+ d->mEffectItem = d->mViewStackWidget;
+ d->mClippingItem->setStackWidget(d->mViewStackWidget);
+ connect(d->mViewStackWidget, SIGNAL(currentChanged(int)),
+ this, SLOT(_q_viewChanged(int)));
+ connect(d->mViewStackWidget, SIGNAL(widgetRemoved(QGraphicsWidget*)),
+ this, SLOT(_q_viewRemoved(QGraphicsWidget*)));
+
+ // create Titlebar (container for indicators, titlepane and secondary softkey
+ d->mTitleBar = new HbTitleBar(this, d->mClippingItem);
+ d->mTitleBar->setZValue(HbPrivate::TitleBarZValue);
+
+ // create StatusBar (container for clock, indicators, and battery and signal icons)
+ d->mStatusBar = new HbStatusBar(this, d->mClippingItem);
+ d->mStatusBar->setZValue(HbPrivate::StatusBarZValue);
+
+ // At this point the mainwindow is considered more or less fully constructed.
+ HbInstancePrivate::d_ptr()->addWindow(this);
+
+ QRectF rect(0,0,pSize.width(),pSize.height());
+ resize(pSize);
+ d->mRootItem->setGeometry(rect);
+ d->mClippingItem->setGeometry(rect);
+
+ setSceneRect(0, 0, pSize.width(), pSize.height());
+
+ setTransformationAnchor(QGraphicsView::AnchorViewCenter);
+
+ // Rest of the initialization is done later, see paintEvent().
+}
+
+/*!
+ Destructs the main window.
+*/
+HbMainWindow::~HbMainWindow()
+{
+ Q_D(HbMainWindow);
+ // cancel any orientation change related effects
+ if (d->mEffectItem) {
+ HbEffect::enable(d->mEffectItem);
+ HbEffect::cancel(d->mEffectItem, QString(), true, false, false);
+ }
+ HbEffect::enable(&(d->mGVWrapperItem));
+ HbEffect::cancel(&(d->mGVWrapperItem), QString(), true, false, false);
+
+ // Cancel all remaining effects without any notifications. This is needed
+ // to prevent crashes when widgets (and views) do not get a chance to cancel
+ // their effects properly due to their dtor being called only after the
+ // QWidget dtor already initiates some shutdown activities.
+ HbEffectInternal::safeCancelAll();
+
+ HbInstancePrivate::d_ptr()->removeWindow(this);
+ delete d_ptr;
+ // to workaround problem when creating/destroying multiple hbmainwindow's in unit tests (win env)
+ #ifdef Q_OS_WIN
+ destroy();
+ #endif
+}
+
+/*!
+ Adds a \a widget to the HbMainWindow object. Passing 0 in
+ \a widget creates an empty HbView.
+
+ The \a widget can be either a HbView or QGraphicsWidget. If it is
+ the QGraphicsWidget then HbMainWindow will create a HbView and set
+ \a widget as the new HbView's content widget.
+
+ A HbMainWindow should only have one of each view and adding a view
+ it already has will not cause the same view to be in the
+ HbMainWindow twice.
+
+ After calling addView() the caller does not need to care about
+ destroying \a widget, the framework will take care of that by
+ reparenting \a widget if needed.
+
+ \return the new view
+
+ \sa insertView removeView
+*/
+HbView *HbMainWindow::addView(QGraphicsWidget *widget)
+{
+ Q_D(HbMainWindow);
+ HbView *view = 0;
+ if (!widget) {
+ view = new HbView;
+ } else {
+ view = qobject_cast<HbView *>(widget);
+ if (!view) {
+ view = new HbView;
+ view->setWidget(widget);
+ }
+ }
+
+ // Remove view if it is already inserted
+ int index = d->mViewStackWidget->indexOf(view);
+ if (index != -1) {
+ d->mViewStackWidget->removeAt(index);
+ }
+
+ d->mViewStackWidget->insertWidget(-1, view);
+
+ return view;
+}
+
+/*!
+ Inserts a \a widget to a given \a index to the HbMainWindow object.
+
+ The \a widget can be either a HbView or QGraphicsWidget. If it is
+ the QGraphicsWidget then HbMainWindow will create a HbView and set
+ it as the internal widget.
+
+ If \a index is out of range, the new view is appended.
+ \return the new view.
+
+ \sa addView removeView
+*/
+HbView *HbMainWindow::insertView(int index, QGraphicsWidget *widget)
+{
+ Q_D(HbMainWindow);
+ HbView *view = 0;
+ if (!widget) {
+ view = new HbView(d->mViewStackWidget);
+ } else {
+ view = qobject_cast<HbView *>(widget);
+ if (!view) {
+ view = new HbView();
+ view->setWidget(widget);
+ }
+ }
+ d->mViewStackWidget->insertWidget(index, view);
+
+ return view;
+}
+
+/*!
+ Removes a \a widget from the HbMainWindow object. The \a widget must be either
+ a HbView or a QGraphicsWidget that is the internal widget of a HbView.
+
+ If \a widget is a QGraphicsWidget, it is not deleted, but it's view is deleted.
+ If \a widget is a HbView, then neither view or widget inside it is not deleted.
+
+ The ownership of the \a widget is transferred to the caller. Notice that \a widget
+ is not removed from the scene.
+
+ \sa addView insertView
+*/
+void HbMainWindow::removeView(QGraphicsWidget *widget)
+{
+ Q_D(HbMainWindow);
+ if (!widget) {
+ qWarning("HbMainWindow::removeView: widget is null");
+ return;
+ }
+
+ HbView *view = qobject_cast<HbView *>(widget);
+ if (view) {
+ d->mViewStackWidget->removeWidget(view);
+ } else {
+ // Check if it is a widget inside a view and delete that view
+ for (int n=0; n<d->mViewStackWidget->count(); n++) {
+ HbView *tempView = qobject_cast<HbView*>(d->mViewStackWidget->widgetAt(n));
+ if (tempView->widget() == widget) {
+ d->mViewStackWidget->removeWidget(tempView);
+ // Take a widget out from the view, before deleting it.
+ tempView->takeWidget();
+ delete tempView;
+ }
+ }
+ }
+}
+
+/*!
+ \deprecated HbMainWindow::removeView(int)
+ is deprecated. Use HbMainWindow::removeView(QGraphicsWidget *widget) instead!
+
+ Removes a view from a given \a index from the HbMainWindow object. The view is not deleted but returned to caller.
+
+ \return the removed widget.
+
+ \sa addView insertView
+*/
+QGraphicsWidget *HbMainWindow::removeView(int index)
+{
+ HB_DEPRECATED("HbMainWindow::removeView is deprecated. Use HbMainWindow::removeView(QGraphicsWidget *widget) instead!");
+ Q_D(HbMainWindow);
+ return d->mViewStackWidget->removeAt(index);
+}
+
+/*!
+ Returns the current view of the HbMainWindow object.
+ \return pointer to the current view object, or 0 if undefined.
+
+ \sa setCurrentView
+*/
+HbView *HbMainWindow::currentView() const
+{
+ Q_D(const HbMainWindow);
+ return qobject_cast<HbView *>(d->mViewStackWidget->currentWidget());
+}
+
+/*!
+ Sets the current \a view. The type of the view switch animation is controlled by \a
+ flags. If no view switch effect is registered to the HbView instance (\a view) or \a
+ animate is false then there will be no view switch animation displayed.
+
+ \sa currentView()
+
+ \param view The new view to be shown.
+
+ \param animate Whether to show animation on view switch or not.
+
+ \param flags Additional options.
+
+ Note that care must be taken when the application has not registered its own, custom
+ hide and show effects for the current and the new view, respectively, because in this
+ case some of the explicitly specified flags may not work well with some of the possible
+ default effects (that are coming from the currently set theme). It is best not to
+ specify any flags explicitly unless the application has registered its own view switch
+ effects (so it has knowledge about what how the show and hide effects are defined, what
+ kind of execution they expect, etc.)
+ */
+void HbMainWindow::setCurrentView(HbView *view, bool animate, Hb::ViewSwitchFlags flags)
+{
+ Q_D(HbMainWindow);
+ HbView *oldView = currentView();
+ // Switching to null view or to the one that is current will do nothing.
+ if (view && oldView != view) {
+ if (oldView && animate) {
+ if (flags & Hb::ViewSwitchFullScreen) {
+ flags |= Hb::ViewSwitchSequential;
+ }
+ if (flags & Hb::ViewSwitchUseBackAnim) {
+ flags &= ~Hb::ViewSwitchUseNormalAnim;
+ }
+ if (flags & Hb::ViewSwitchUseAltEvent) {
+ flags |= Hb::ViewSwitchSequential;
+ }
+ d->mViewStackWidget->setTargetView(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)
+ QMetaObject::invokeMethod(this, "_q_viewReady", Qt::QueuedConnection);
+ }
+ }
+}
+
+
+/*!
+ \deprecated HbMainWindow::currentViewIndex() const
+ is deprecated. Use HbMainWindow::currentView() instead!
+
+ Returns the current index of the HbMainWindow object.
+ \return current index, or -1 if undefined.
+
+ \sa setCurrentViewIndex setCurrentView currentView
+*/
+int HbMainWindow::currentViewIndex() const
+{
+ HB_DEPRECATED("HbMainWindow::currentViewIndex is deprecated. Use HbMainWindow::currentView() instead!");
+ Q_D(const HbMainWindow);
+ return d->mViewStackWidget->currentIndex();
+}
+
+/*!
+ \deprecated HbMainWindow::viewCount() const
+ is deprecated. Use HbMainWindow::views().count() instead!
+
+ Returns the count of view objects of the HbMainWindow object.
+ \return view object count.
+
+ \sa addView insertView
+*/
+int HbMainWindow::viewCount() const
+{
+ HB_DEPRECATED("HbMainWindow::viewCount is deprecated. Use HbMainWindow::views().count() instead!");
+ Q_D(const HbMainWindow);
+ return d->mViewStackWidget->count();
+}
+
+/*!
+ \deprecated HbMainWindow::indexOfView(HbView*) const
+ is deprecated. Use HbMainWindow::views().indexOf(view) instead!
+
+ Returns the index for a given \a view object of the HbMainWindow object.
+ \return index of a view object.
+
+ \sa currentViewIndex currentView
+*/
+int HbMainWindow::indexOfView(HbView *view) const
+{
+ HB_DEPRECATED("HbMainWindow::indexOfView is deprecated. Use HbMainWindow::views().indexOf(view) instead!");
+ Q_D(const HbMainWindow);
+ return d->mViewStackWidget->indexOf(view);
+}
+
+/*!
+ \deprecated HbMainWindow::viewAt(int) const
+ is deprecated. Use HbMainWindow::views() instead!
+
+ Returns \a view object for a given \a index of the HbMainWindow object.
+ \return view object.
+
+ \sa currentViewIndex currentView indexOfView
+*/
+HbView *HbMainWindow::viewAt(int index) const
+{
+ HB_DEPRECATED("HbMainWindow::viewAt is deprecated. Use HbMainWindow::views() instead!");
+ Q_D(const HbMainWindow);
+ return qobject_cast<HbView *>(d->mViewStackWidget->widgetAt(index));
+}
+
+/*!
+
+ Returns list of all views.
+ */
+QList<HbView *> HbMainWindow::views() const
+{
+ Q_D(const HbMainWindow);
+ HbContentWidget *stackWidget = d->mViewStackWidget;
+
+ const int n = stackWidget->count();
+ QList<HbView *> result;
+ for ( int i=0; i<n; ++i ) {
+ HbView *view = qobject_cast<HbView *>(stackWidget->widgetAt(i));
+ Q_ASSERT_X(view, "HbMainWindow::views()", "HbView was expected");
+ result.append(view);
+ }
+
+ return result;
+}
+/*!
+ \deprecated HbMainWindow::element(HbMainWindow::Element) const
+ is deprecated.
+
+ Returns user interface elements of mainwindow as QGraphicsWidgets. The term "element" here is used since each of these
+ elements consist of one or multiple items. The term "item" is used since each element is represented by a single
+ QGraphicsWidget (which is also a QGraphicsItem).
+
+ The returned elements can be used for example to run effects using the HbEffect API.
+ For example an application could use the ViewPortItem to do an effect on all the other parts of the UI except the background item.
+
+ Currently supported elements are:
+ - HbMainWindow::RootItem, this is an item that contains all other items including the background element.
+ - HbMainWindow::ViewportItem, this contains all other items except the background, it can be thought as the viewport for widgets.
+ This item gets resized when the orientation changes.
+ - HbMainWindow::BackgroundItem, as the name says the enum represents the background item, nothing else.
+ Note that in this case the returned pointer may be null if the main window was constructed with Hb::WindowFlagNoBackground.
+
+ \param element Enumeration of the element.
+
+*/
+QGraphicsWidget *HbMainWindow::element(HbMainWindow::Element element) const
+{
+ HB_DEPRECATED("HbMainWindow::element is deprecated!");
+ Q_D(const HbMainWindow);
+ if( element == HbMainWindow::RootItem )
+ return d->mRootItem;
+ else if( element == HbMainWindow::ViewportItem )
+ return d->mClippingItem;
+ else if( element == HbMainWindow::BackgroundItem )
+ return d->mBgItem;
+
+ return 0;
+}
+
+/*!
+ Returns orientation of the window.
+
+ \sa setOrientation() unsetOrientation()
+ */
+Qt::Orientation HbMainWindow::orientation() const
+{
+ Q_D(const HbMainWindow);
+ return d->mOrientation;
+}
+
+/*!
+ Sets orientation of the window and disables the automatic orientation switching. This means
+ that orientation will stay in the \a orientation as long as unsetOrientation is called.
+
+ Triggers orientation switch if the orientation was changed from the previous one.
+ Orientation switch animation can be skipped by using the boolean parameter.
+
+ \sa orientation() unsetOrientation()
+
+ */
+
+void HbMainWindow::setOrientation(Qt::Orientation orientation, bool animate)
+{
+ Q_D(HbMainWindow);
+ d->mAutomaticOrientationSwitch = false;
+ d->setTransformedOrientation(orientation, animate);
+}
+
+/*!
+ \deprecated HbMainWindow::toggleOrientation()
+ is deprecated.
+
+ @proto
+
+ Switches orientation of main window.
+
+ */
+void HbMainWindow::toggleOrientation()
+{
+ HB_DEPRECATED("HbMainWindow::toggleOrientation is deprecated!");
+ Q_D(HbMainWindow);
+ d->mAutomaticOrientationSwitch = false;
+ if (d->mOrientation == Qt::Horizontal) {
+ d->setTransformedOrientation(Qt::Vertical,false);
+ } else {
+ d->setTransformedOrientation(Qt::Horizontal,false);
+ }
+}
+
+/*!
+ Unsets orientation of the window. Application will listen orientation events coming from system.
+ Orientation switch animation can be skipped by using the boolean parameter.
+
+ \sa orientation() setOrientation()
+ */
+void HbMainWindow::unsetOrientation(bool animate)
+{
+ Q_D(HbMainWindow);
+ if (!d->mAutomaticOrientationSwitch) {
+ d->mAutomaticOrientationSwitch = true;
+ if(HbMainWindowOrientation::instance()->isEnabled())
+ d->setTransformedOrientation(HbMainWindowOrientation::instance()->sensorOrientation(), animate);
+ }
+}
+
+/*!
+ \deprecated HbMainWindow::showItems(QFlags<Hb::SceneItem>)
+ is deprecated. Use HbView::showItems instead.
+
+ Sets \a items to be visible in main window.
+
+ \sa isItemVisible() setItemVisible() hideItems() visibleItems()
+*/
+void HbMainWindow::showItems(Hb::SceneItems items)
+{
+ HB_DEPRECATED("HbMainWindow::showItems is deprecated! Use HbView::showItems instead.");
+ Q_D(HbMainWindow);
+ if (d->mVisibleItems ^ items) {
+ d->mVisibleItems |= items;
+ d->updateVisibleItems();
+ }
+}
+
+/*!
+ \deprecated HbMainWindow::hideItems(QFlags<Hb::SceneItem>)
+ is deprecated. Use HbView::hideItems instead.
+
+ Sets \a items to be invisible in main window.
+
+ \sa isItemVisible() setItemVisible() showItems() visibleItems()
+*/
+void HbMainWindow::hideItems(Hb::SceneItems items)
+{
+ HB_DEPRECATED("HbMainWindow::hideItems is deprecated! Use HbView::hideItems instead.");
+ Q_D(HbMainWindow);
+ if (d->mVisibleItems & items) {
+ d->mVisibleItems &= ~items;
+ d->updateVisibleItems();
+ }
+}
+
+/*!
+ \deprecated HbMainWindow::visibleItems() const
+ is deprecated. Use HbView::visibleItems instead.
+
+ Returns visible items.
+
+ \sa isItemVisible() setItemVisible() hideItems() showItems()
+
+*/
+Hb::SceneItems HbMainWindow::visibleItems() const
+{
+ HB_DEPRECATED("HbMainWindow::visibleItems is deprecated! Use HbView::visibleItems instead.");
+ Q_D(const HbMainWindow);
+ return d->mVisibleItems;
+}
+
+/*!
+ \deprecated HbMainWindow::isItemVisible(Hb::SceneItem) const
+ is deprecated. Use HbView::isItemVisible instead.
+
+ Returns \c true if \a item is set to be visible.
+
+ \sa setItemVisible() hideItems() showItems() visibleItems()
+
+*/
+bool HbMainWindow::isItemVisible(Hb::SceneItem item) const
+{
+ HB_DEPRECATED("HbMainWindow::isItemVisible is deprecated! Use HbView::isItemVisible instead.");
+ Q_D(const HbMainWindow);
+ return d->mVisibleItems & item;
+}
+
+/*!
+ \deprecated HbMainWindow::setItemVisible(Hb::SceneItem, bool)
+ is deprecated. Use HbView::setItemVisible instead.
+
+ Sets \a item to be \a visible in main window.
+
+ \sa isItemVisible() hideItems() showItems() visibleItems()
+*/
+void HbMainWindow::setItemVisible(Hb::SceneItem item, bool visible)
+{
+ HB_DEPRECATED("HbMainWindow::setItemVisible is deprecated! Use HbView::setItemVisible instead.");
+ if (visible) {
+ showItems(item);
+ } else {
+ hideItems(item);
+ }
+}
+
+/*!
+ Returns empty drawable window.
+
+ Returned window is inherited from CCoeControl in Symbian platform
+ and by default you don't have any surface attached to it. In other
+ platforms returns 0.
+
+ This window is meant to be used when developer wants to use own surface
+ running underneath the UI, e.g. video playback surface or HW accelerated
+ 3D content in own surface.
+
+ See QWidget::winId
+
+ \sa resetNativeWindow, HbTransparentWindow
+*/
+WId HbMainWindow::nativeBackgroundWindow()
+{
+#ifdef Q_OS_SYMBIAN
+ Q_D(HbMainWindow);
+
+ if (!d->mNativeWindow) {
+ d->mNativeWindow = new HbNativeWindow;
+ d->mNativeWindow->ConstructL();
+ // Let's make sure, that native window is always behind HbMainWindow instance
+ TInt mainWindowOrdinal = winId()->DrawableWindow()->OrdinalPosition();
+ d->mNativeWindow->DrawableWindow()->SetOrdinalPosition(mainWindowOrdinal + 1);
+ }
+
+ return d->mNativeWindow;
+#else
+ return 0;
+#endif
+}
+
+/*!
+ Deletes the empty drawable window.
+
+ \sa nativeWindow
+*/
+void HbMainWindow::resetNativeBackgroundWindow()
+{
+#ifdef Q_OS_SYMBIAN
+ Q_D(HbMainWindow);
+
+ if (d->mNativeWindow) {
+ delete d->mNativeWindow;
+ d->mNativeWindow = 0;
+ }
+#endif
+}
+
+/*!
+ Returns the rectangle which is used for layouting HbMainWindow contents. Updates on orientation change and is up to date
+ after HbMainWindow orientationChanged() signal. Note that this is not the same thing as QGraphicsView (HbMainWindow) geometry.
+ HbMainWindow geometry does not update on orientation change since the contents are only transformed with a rotate transform.
+
+*/
+QRectF HbMainWindow::layoutRect() const
+{
+ Q_D(const HbMainWindow);
+ if (d->mClippingItem) {
+ return d->mClippingItem->geometry();
+ }
+ return QRectF();
+}
+/*!
+ \deprecated HbMainWindow::setCurrentViewIndex(int)
+ is deprecated. Use setCurrentView() instead.
+
+ Sets the current view from a given \a index of the HbMainWindow object.
+
+ \sa currentView currentViewIndex setCurrentView
+*/
+void HbMainWindow::setCurrentViewIndex(int index)
+{
+ HB_DEPRECATED("HbMainWindow::setCurrentViewIndex is deprecated! Use setCurrentView() instead.");
+ Q_D(HbMainWindow);
+ QGraphicsWidget *widget = d->mViewStackWidget->widgetAt(index);
+ setCurrentView(qobject_cast<HbView*>(widget));
+}
+
+/*!
+ \deprecated HbMainWindow::nextView()
+ is deprecated. Use setCurrentView() instead.
+
+ Switches to next view (view with bigger index).
+ If current view is last view it does nothing.
+ */
+void HbMainWindow::nextView()
+{
+ HB_DEPRECATED("HbMainWindow::nextView is deprecated! Use setCurrentView() instead.");
+ int index = currentViewIndex()+1;
+ if( index<viewCount() ) {
+ setCurrentViewIndex(index);
+ }
+}
+
+/*!
+ \deprecated HbMainWindow::previousView()
+ is deprecated. Use setCurrentView() instead.
+
+ Switches to previous view (view with smaller index).
+ If current view is first view it does nothing.
+ */
+void HbMainWindow::previousView()
+{
+ HB_DEPRECATED("HbMainWindow::previousView is deprecated! Use setCurrentView() instead.");
+ int index = currentViewIndex()-1;
+ if( index>=0 ) {
+ setCurrentViewIndex(index);
+ }
+}
+
+/*!
+ Sets the \a name for the background image for the given \a orientation. If
+ the default image from the theme is suitable then there is no need to call
+ this function.
+
+ \sa backgroundImageName()
+ */
+void HbMainWindow::setBackgroundImageName(Qt::Orientation orientation, const QString &name)
+{
+ Q_D(HbMainWindow);
+ if (d->mBgItem) {
+ d->mBgItem->setImageName(orientation, name);
+ }
+}
+
+/*!
+ Returns the background image name for the given \a orientation.
+ If no setBackgroundImageName() calls were made before then returns the default.
+
+ \sa setBackgroundImageName()
+ */
+QString HbMainWindow::backgroundImageName(Qt::Orientation orientation) const
+{
+ Q_D(const HbMainWindow);
+ return d->mBgItem ? d->mBgItem->imageName(orientation) : QString();
+}
+
+/*!
+ Reimplemented from QWidget::changeEvent().
+*/
+void HbMainWindow::changeEvent(QEvent *event)
+{
+ QGraphicsView::changeEvent(event);
+ if (event->type() == QEvent::LayoutDirectionChange) {
+ // Notify layout direction change to the icon framework
+ HbLayoutDirectionNotifier::instance()->notifyLayoutDirectionChange();
+
+ foreach (QGraphicsItem *item, items()) {
+ if (item->isWidget() && !item->parentItem() ) {
+ QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item);
+ if (!widget->testAttribute(Qt::WA_SetLayoutDirection)){
+ widget->setLayoutDirection(layoutDirection());
+ widget->setAttribute(Qt::WA_SetLayoutDirection, false);
+ }
+ }
+ }
+ }
+}
+
+/*!
+ Reimplemented from QWidget::closeEvent().
+*/
+void HbMainWindow::closeEvent(QCloseEvent *event)
+{
+ QGraphicsView::closeEvent(event);
+ HbInstancePrivate::d_ptr()->removeWindow(this);
+}
+
+/*!
+ Reimplemented from QWidget::keyPressEvent().
+*/
+void HbMainWindow::keyPressEvent(QKeyEvent *event)
+{
+ // pass the soft key press into the soft key decorator class
+ HbAction *action = 0;
+
+ switch(event->key()) {
+
+#ifdef Q_OS_SYMBIAN
+ case Qt::Key_Context1:
+#else
+ case Hb::Key_SoftKeyPrimary:
+#endif
+
+ event->accept();
+ break;
+
+#ifdef Q_OS_SYMBIAN
+ case Qt::Key_Select:
+#else
+ case Hb::Key_SoftKeyMiddle:
+#endif
+
+ event->accept();
+ break;
+
+#ifdef Q_OS_SYMBIAN
+ case Qt::Key_Context2:
+#else
+ case Hb::Key_SoftKeySecondary:
+#endif
+ if (currentView()) {
+ action = currentView()->navigationAction();
+ }
+ event->accept();
+ break;
+
+ default:
+ QGraphicsView::keyPressEvent(event);
+ break;
+ }
+
+ if (action) {
+ action->trigger();
+ }
+}
+
+/*!
+ Reimplemented from QWidget::keyReleaseEvent().
+*/
+void HbMainWindow::keyReleaseEvent(QKeyEvent *event)
+{
+ QGraphicsView::keyReleaseEvent(event);
+}
+
+/*!
+ Reimplemented from QWidget::resizeEvent().
+*/
+void HbMainWindow::resizeEvent(QResizeEvent *event)
+{
+ Q_D(HbMainWindow);
+
+ if ( !HbMainWindowPrivate::dragToResizeEnabled ) {
+ // determine the default orientation width < height -> portrait
+ if (event->size().width() < event->size().height())
+ d->mDefaultOrientation = Qt::Vertical;
+ else
+ d->mDefaultOrientation = Qt::Horizontal;
+ d->mForceSetOrientation = true;
+ d->setTransformedOrientation(d->mOrientation, false);
+ d->mForceSetOrientation = false;
+ } else {
+ // RnD feature for resizing the window by dragging
+ QSize newSize(event->size());
+ setSceneRect(0,0,newSize.width(),newSize.height());
+ d->mClippingItem->resize(newSize);
+ if (d->mBgItem) {
+ d->mBgItem->resize(newSize);
+ }
+ }
+}
+
+/*!
+ Reimplemented from QObject::customEvent().
+*/
+void HbMainWindow::customEvent( QEvent *event )
+{
+ Q_D(HbMainWindow);
+ if (event->type() == HbMainWindowPrivate::IdleEvent) { // called asyncronously after the application start-up
+ if (!d->mIdleEventHandled) {
+ d->mIdleEventHandled = true;
+ if ( HbFeatureManager::instance()->featureStatus( HbFeatureManager::TheTestUtility ) ) {
+ // create the test utility
+ if ( !d->mTheTestUtility ) {
+ 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();
+ }
+ // 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
+ if (d->mEffectItem && d->mOrientationChangeOngoing) {
+ HbEffect::start(d->mEffectItem, "rootItemFinalPhase", this, "rootItemFinalPhaseDone");
+ }
+ } else if (event->type() == HbMainWindowPrivate::IdleOrientationFinalEvent) {
+ if (d->mAnimateOrientationSwitch) {
+ HbEffect::start(d->mStatusBar, "statusbar", "appear_orient");
+ HbEffect::start(d->mTitleBar, "titlebar", "appear_orient");
+ if (d->mCurrentToolbar) {
+ HbToolBarPrivate *toolBarD = HbToolBarPrivate::d_ptr(d->mCurrentToolbar);
+ toolBarD->startAppearOrientEffect();
+ }
+ }
+ }
+
+}
+
+/*!
+ \reimp
+*/
+void HbMainWindow::paintEvent(QPaintEvent *event)
+{
+ // Invoke the delayed construction slot asynchronously if not yet done.
+ Q_D(HbMainWindow);
+ // With this condition we may end up invoking the slot more than once but it
+ // is not a problem as the slot will have proper guard conditions.
+ if (!d->mDelayedConstructionHandled) {
+ QMetaObject::invokeMethod(this, "_q_delayedConstruction", Qt::QueuedConnection);
+ }
+
+ QGraphicsView::paintEvent(event);
+}
+
+/*!
+ Reimplemented from QAbstractScrollArea::scrollContentsBy().
+*/
+void HbMainWindow::scrollContentsBy(int dx, int dy)
+{
+ // ignore scrolling attempt
+ Q_UNUSED(dx);
+ Q_UNUSED(dy);
+}
+
+/*!
+ Broadcasts \a eventType into all widgets in the scene.
+
+ Visible widgets will receive the event synchronously and invisble widgets
+ asynchronously.
+
+ If the receiving widget has abstract items as child items, these will be informed
+ after the widget has received the event.
+*/
+void HbMainWindow::broadcastEvent( int eventType )
+{
+ Q_D(HbMainWindow);
+ d->broadcastEvent( eventType );
+}
+
+HbRootItem::HbRootItem(QGraphicsItem *parent)
+ : HbWidget(parent)
+{
+}
+
+bool HbRootItem::event(QEvent *event)
+{
+ if (event->type() == QEvent::Polish) {
+ // No need for any real polishing.
+ static_cast<HbWidgetPrivate *>(d_ptr)->polished = true;
+ return true;
+ }
+ return HbWidget::event(event);
+}
+
+#include "moc_hbmainwindow.cpp"