/****************************************************************************

**

** 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 "hbmainwindow.h"

#include "hbmainwindow_p.h"

#include <QGraphicsView>

#include <QGraphicsWidget>

#include <QGraphicsItem>

#include <QGraphicsScene>

#include <QApplication>

#include "hbaction.h"

#include "hbbackgrounditem_p.h"

#include "hbscreenshotitem_p.h"

#include "hbdeviceprofile_p.h"

#include "hbindicatorgroup_p.h"

#include "hbinstance.h"

#include "hbinstance_p.h"

#include "hbgraphicsscene.h"

#include "hbnamespace.h"

#include "hbnamespace_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.h"

#include "hbcontentwidget_p.h"

#include "hbscreen_p.h"

#include "hbmainwindoworientation_p.h"

#include "hbfeaturemanager_r.h"

#include "hboogmwatcher_p.h"

#include "hbwindowobscured_p.h"

#include "hbsleepmodelistener_p.h"

#include "hbforegroundwatcher_p.h"

#ifdef Q_OS_SYMBIAN

#include <coecntrl.h>

#include <w32std.h>

#include "hbnativewindow_sym_p.h"

#endif

/*!

    @stable

    @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. The viewReady() signal is emitted when a

    view's internal construction is completed and basic parts of view are

    already drawn. Same signal is also emitted when current view has

    changed. 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.

 */

/*!

    \fn void HbMainWindow::aboutToChangeView(HbView *oldView, HbView *newView)

    This signal is emitted before starting a view change. Note that it is only

    emitted when there is a real view change (i.e. when setCurrentView() is

    used), it will not be emitted when views are added to the main window via

    addView().

    It is guaranteed that this signal is emitted before starting any view switch

    animation.

 */

/*!

    \fn void HbMainWindow::currentViewChanged(HbView *view)

    This signal is emitted when the current view changes. Do not make assumptions about

    the exact timing of this signal, it may be emitted at any time during the view switch

    (this is relevant if the view switch is animated, i.e. it is not guaranteed that the

    signal will be emitted at the end of the animation, in fact it is usually emitted

    already when the animation starts).

    \sa aboutToChangeView()

    \sa viewReady()

 */

/*!

    \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

    tasks. Note however that when thinking about the tasks, it is important to keep the UI

    responsive all the time.

 */

/*!

    \fn void HbMainWindow::obscured()

    This signal is emited whenever the window is completely overlaped by another

    window.

    Application developers can use this signal to pause or stop painting when

    the window is not visible to the user at all.

    This signal has real implementation only for Symbian and X11 platforms. On

    desktop platforms it is simulated via a settings window option.

    The typical use case is to use the obscured() and revealed() signals in

    connection with device dialogs (global pop-ups): When such a dialog is

    shown, the application loses foreground (focus), but it may still be

    partially visible because the dialogs will not fill the entire screen. To

    get notified about such cases, combine your application's

    foreground-background handling with handling also these signals.

    Consider this as a best-effort solution only, the exact behavior depends on

    the platform and may have limitations. For example on Symbian transparent

    windows will never obscure another window, regardless of the content.

    These signals are not a replacement to the focus-based ApplicationActivate

    and ApplicationDeactivate events. An application may lose the focus

    completely (i.e. lose foreground) even when it is still partially visible to

    the user.

    \sa revealed()

    \sa isObscured()

*/

/*!

    \fn void HbMainWindow::revealed()

    This signal is emited whenever the window is visible to the user partially

    or completely.

    This signal has real implementation only for Symbian and X11 platforms. On

    desktop platforms it is simulated via the settings option.

    Consider this as a best-effort solution only, the exact behavior depends on

    the platform and may have limitations. For example on Symbian transparent

    windows may cause the revealed signal to be emitted even when the content is

    not really visible.

    These signals are not a replacement to the focus-based ApplicationActivate

    and ApplicationDeactivate events. An application may lose the focus

    completely (i.e. lose foreground) even when it is still partially visible to

    the user.

    \sa obscured()

    \sa isObscured()

*/

/*!

  \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.

    setAttribute(Qt::WA_NoSystemBackground);

    viewport()->setAttribute(Qt::WA_NoSystemBackground);

    setOptimizationFlag(QGraphicsView::DontSavePainterState);

    // 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 if (HbMainWindowOrientation::instance()->isEnabled()) {

        d->mOrientation = HbMainWindowOrientation::instance()->sensorOrientation();

        d->mAutomaticOrientationSwitch = true;

    } else {

        d->mOrientation = d->mDefaultOrientation;

        d->mAutomaticOrientationSwitch = false;

    }

#if defined(Q_OS_SYMBIAN) || defined(HB_Q_WS_MAEMO)

    setWindowState(Qt::WindowFullScreen);

#endif

    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

    setFrameStyle(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;

    //makes sure clipiingItem layout is activated before any of its childitems.

    QApplication::postEvent(d->mClippingItem, new QEvent(QEvent::LayoutRequest));

    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()));

    connect(d->mViewStackWidget, SIGNAL(widgetRemoved(QGraphicsWidget *)),

            this, SLOT(_q_viewRemoved(QGraphicsWidget *)));

    // create Titlebar (container for indicator button, titlepane and navigation button

    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->mLayoutRect = rect;

    d->mRootItem->setGeometry(rect);

    d->mClippingItem->setGeometry(rect);

    setSceneRect(0, 0, pSize.width(), pSize.height());

    setTransformationAnchor(QGraphicsView::AnchorViewCenter);

    // Initialize common translations. This must be done before

    // creating any widget that can potentially use localized strings

    // and therefore cannot be delayed.

    d->initTranslations();

    // Make sure the oogm watcher is initialized (so that wserv events

    // are routed to it properly).

    HbOogmWatcher::instance();

    // Make sure the sleep mode listener instance is created.

    HbSleepModeListener::instance();

    // Have also the foregroundwatcher up and running.

    HbForegroundWatcher::instance();

    HbWindowObscured::installWindowEventFilter();

#ifdef HB_GESTURE_FW

    // @todo remove after view auto-subscribes to gestures

    viewport()->grabGesture(Qt::TapGesture);

    viewport()->grabGesture(Qt::TapAndHoldGesture);

    viewport()->grabGesture(Qt::PanGesture);

    viewport()->grabGesture(Qt::SwipeGesture);

    viewport()->grabGesture(Qt::PinchGesture);

#endif

    // 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

    a QGraphicsWidget (or any subclass that is not HbView) then

    HbMainWindow will create a HbView and set \a widget as the new

    HbView's content widget.

    When \a widget is a HbView, use HbView::setWidget() to set the content

    widget for the view. Note that you should never attach child items or set a layout

    directly to the HbView instance, even though HbView is also a HbWidget.

    Instead, create a content widget, set it to the view via HbView::setWidget(),

    and attach children or set a layout to that.

    Use setCurrentView() to switch between the added views. (only one of them is visible at a time)

    The view-specific decorators (toolbar, Options menu, title in the titlebar) and of course

    the visibility of the view's content widgets will be updated and managed automatically by the framework

    when switching views.

    For a detailed description of views see the HbView class.

    Note that using view switching (i.e. several HbView instances, setCurrentView(), etc.) in

    Hb applications is not mandatory, it is purely optional. For applications that are not really

    view based (e.g. because they only have one screen of content or because they have more "fluid" UI where

    the traditional view separation does not make that much sense) it may sometimes be better (and may provide more freedom)

    to have just one view and manage the content entirely via the content widget of that one view.

    (one can still use HbStackedLayout and manual visibility management of child widgets to achieve a traditional view-like look,

    even when the Hb view management is not used)

    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.

    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.

    \return the new view

    \sa insertView() removeView() setCurrentView()

    \sa HbView HbStackedLayout

*/

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);

        }

    }