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

**

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

#include "hboogmwatcher_p.h"

#ifdef Q_OS_SYMBIAN

#include <coecntrl.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. 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.

 */

/*!

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

    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.

 */

/*!

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

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

        d->mAutomaticOrientationSwitch = true;

    } else {

        d->mOrientation = d->mDefaultOrientation;

        d->mAutomaticOrientationSwitch = false; 

    }

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

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

#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

    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;

            }

        }

    }

}

/*!

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

        emit aboutToChangeView(oldView, view);

        if (oldView && animate) {

            if (flags & Hb::ViewSwitchFullScreen) {