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

**

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

#include "hbgraphicsscene.h"

#include "hbindicatorbutton_p.h"

#include "hbtitlebar_p.h"

#include "hbstatusbar_p.h"

#include "hbmenu.h"

#include "hbnamespace.h"

#include "hbnamespace_p.h"

#include "hbstackedwidget.h"

#include "hbtoolbar.h"

#include "hbview.h"

#include "hbview_p.h"

#include "hbevent.h"

#include "hbinstance.h"

#include "hbtoolbar_p.h"

#include "hbdockwidget.h"

#include "hbeffectinternal_p.h"

#include "hbthetestutility_p.h"

#include "hbinputmethod.h"

#include "hbfadeitem_p.h"

#include "hbcontentwidget_p.h"

#include "hbscreen_p.h"

#include "hbbackgrounditem_p.h"

#include "hbscreenshotitem_p.h"

#include "hbcorepskeys_r.h"

#include "hborientationstatus_p.h"

#include "hbglobal_p.h"

#include <QApplication>

#include <QGraphicsLayout>

#include <QLocale>

#include <QDir>

#ifdef Q_OS_SYMBIAN

#include "hbnativewindow_sym_p.h"

#include "hbdevicedialogserverdefs_p.h"

#include <qsymbianevent.h>

#include <w32std.h>

#include <coemain.h>

const TUid deviceDialogUid = {0x20022FC5};

#endif //Q_OS_SYMBIAN

#if defined(Q_WS_X11)

#include <X11/Xlib.h>

#include <qx11info_x11.h>

#endif // defined(Q_WS_X11)

const int HbMainWindowPrivate::IdleEvent = QEvent::registerEventType();

const int HbMainWindowPrivate::IdleOrientationEvent = QEvent::registerEventType();

const int HbMainWindowPrivate::IdleOrientationFinalEvent = QEvent::registerEventType();

//#define ORIENTATION_CHANGE_DEBUGPRINTS

// for working around invalid device profile data

const int QVga_res = 76800;

// Setting for resizing by dragging

bool HbMainWindowPrivate::dragToResizeEnabled = false;

bool HbMainWindowPrivate::initializeInputs = true;

HbMainWindowPrivate::HbMainWindowPrivate() :

    mScene(0),

    mBgItem(0),

    mClippingItem(0),

    mScreenshotItem(0),

    mViewStackWidget(0),

    mTitleBar(0),

    mStatusBar(0),

    mFadeItem(0),

    mRootItem(0),

    mPendingOrientationValue(0),

    mAutomaticOrientationSwitch(true),

    mUserOrientationSwitch(false),

    mOrientationChangeOngoing(false),

    mRootItemFinalPhaseDone(false),

    mOrientationEffectFinished(false),

    mGVOrientationChangeEffectEnabled(false),

    mPendingPsPublish(false),

    mMainWindowActive(false),

    mOrientation(Qt::Vertical),

    mRequestedOrientation(Qt::Vertical),

    mCurrentToolbar(0),

    mCurrentDockWidget(0),

    mVisibleItems(Hb::AllItems),

    mForceSetOrientation(false),

    mDelayedConstructionHandled(false),

    q_ptr(0),

    mTheTestUtility(0),

    mIdleEventHandled(false),

    mToolbarWasAdded(false),

    mAutomaticOrientationChangeAnimation(true),

    mObscuredState(true)

#ifdef Q_OS_SYMBIAN

    ,

    mNativeWindow(0),

    mDevDlgClientSession(0)

#endif

{

#if !defined(Q_WS_X11) && !defined(Q_OS_SYMBIAN)

    mObscuredState = false;  //For non-x11 and non-symbian we start with revealed state.

#endif

    qApp->installEventFilter(this);

}

HbMainWindowPrivate::~HbMainWindowPrivate()

{

#ifdef Q_OS_SYMBIAN

    if (mNativeWindow) {

        delete mNativeWindow;

        mNativeWindow = 0;

    }

#endif

    delete mTheTestUtility;

    mEffectItem = 0;

}

void HbMainWindowPrivate::init()

{

    Q_Q(HbMainWindow);

    mGVWrapperItem.setMainWindow(*q);

}

void HbMainWindowPrivate::initTranslations()

{

    QString lang = QLocale::system().name();

#ifdef Q_OS_SYMBIAN        

    // Use Z drive. Anything else is insecure as anyone could install

    // a fake common translation to C drive for example.

    QString name = QDir(QLatin1String("Z:/resource/qt/translations")).filePath(QLatin1String("common_") + lang);

#else

    QString name = QDir(QLatin1String(HB_TRANSLATIONS_DIR)).filePath(QLatin1String("commonstrings_") + lang);

#endif

    if (mCommonTranslator.load(name)) {

        QCoreApplication::installTranslator(&mCommonTranslator);

    } else {

        qWarning("initTranslations: Failed to load translator based on name %s", qPrintable(name));

    }

}

HbToolBar *HbMainWindowPrivate::toolBar() const

{

    HbView *view = qobject_cast<HbView *>(mViewStackWidget->currentWidget());

    return view ? HbViewPrivate::d_ptr(view)->toolBar : 0;

}

void HbMainWindowPrivate::addToolBarToLayout(HbToolBar *toolBar)

{

    Q_Q(HbMainWindow);

    if (mCurrentToolbar != toolBar) {

        // Remove old toolbar

        removeToolBarFromLayout(mCurrentToolbar);

        // Add new toolbar

        if (toolBar) {

            toolBar->setParentItem(0);

            HbView *currentView = q->currentView();

            if (toolBar->scene() != mScene

                    && currentView

                    && currentView->isItemVisible(Hb::ToolBarItem)) { // check just to avoid warnings

                // Update the toolbar to use the current orientation

                // and layout direction.

                if (toolBar->layoutDirection() != q->layoutDirection() &&

                        !toolBar->testAttribute(Qt::WA_SetLayoutDirection)) {

                    toolBar->setLayoutDirection(q->layoutDirection());

                    toolBar->setAttribute(Qt::WA_SetLayoutDirection, false);

                }

                HbToolBarPrivate *toolBarD = HbToolBarPrivate::d_ptr(toolBar);

                // No "appear" effect when changing views or when the first

                // toolbar is shown. The latter is needed to prevent bad UX when

                // a splash screen containing a toolbar is shown before the

                // mainwindow.

                if (mViewStackWidget->isSwitchingViews() || !mToolbarWasAdded) {

                    toolBarD->suppressNextAppearEffect();

                    mToolbarWasAdded = true;

                } else if (mOrientationChangeOngoing && !mAnimateOrientationSwitch) {

                    toolBarD->suppressNextAppearEffect();

                }

                mScene->addItem(toolBar); // top level

            }

            toolBar->setZValue(HbPrivate::ToolBarZValue);

            toolBar->setParentItem(mClippingItem);

            mClippingItem->setToolBar(toolBar);

            mCurrentToolbar = toolBar;

            toolBar->resetTransform();

        }

    }

}

void HbMainWindowPrivate::removeToolBarFromLayout(HbToolBar *toolBar)

{

    Q_Q(HbMainWindow);

    if (mCurrentToolbar && mCurrentToolbar->scene() && mCurrentToolbar == toolBar) {

        mClippingItem->setToolBar(0);

        mScene->removeItem(mCurrentToolbar);

        mCurrentToolbar->disconnect(q);

        mCurrentToolbar = 0;

    }

}

HbDockWidget *HbMainWindowPrivate::dockWidget() const

{

    HbView *view = qobject_cast<HbView *>(mViewStackWidget->currentWidget());

    return view ? HbViewPrivate::d_ptr(view)->dockWidget : 0;

}

void HbMainWindowPrivate::addDockWidgetToLayout(HbDockWidget *dockWidget)

{

    Q_Q(HbMainWindow);

    if (mCurrentDockWidget != dockWidget) {

        // Remove old dock

        removeDockWidgetFromLayout(mCurrentDockWidget);

        // Add new dock

        if (dockWidget) {

            dockWidget->setParentItem(0);

            if (dockWidget->scene() != mScene) {

                HbView *currentView = q->currentView();

                if (currentView && currentView->isItemVisible(Hb::DockWidgetItem)) {

                    mScene->addItem(dockWidget); // top level

                }

            }

            dockWidget->setZValue(HbPrivate::DockWidgetZValue);

            dockWidget->setParentItem(mClippingItem);

            mClippingItem->setDockWidget(dockWidget);

            mCurrentDockWidget = dockWidget;

        }

    }

}

void HbMainWindowPrivate::removeDockWidgetFromLayout(HbDockWidget *dockWidget)

{

    Q_Q(HbMainWindow);

    if (mCurrentDockWidget && mCurrentDockWidget->scene() && mCurrentDockWidget == dockWidget) {

        mClippingItem->setDockWidget(0);

        mScene->removeItem(mCurrentDockWidget);

        mCurrentDockWidget->disconnect(q);

        mCurrentDockWidget = 0;

    }

}

void HbMainWindowPrivate::setTransformedOrientation(Qt::Orientation orientation, bool animate)

{

    Q_Q(HbMainWindow);

    mRequestedOrientation = orientation;

    if (mOrientationChangeOngoing) {

        if (!mForceSetOrientation && !mUserOrientationSwitch) {

            return;

        } else if (mOrientation != orientation) {

            HbEffectInternal::cancelAll();

            // Possibly posted idle events must not be delivered,

            // there will be new ones due to this new orientation switch.

            QCoreApplication::removePostedEvents(q, HbMainWindowPrivate::IdleOrientationEvent);

            QCoreApplication::removePostedEvents(q, HbMainWindowPrivate::IdleOrientationFinalEvent);

            QCoreApplication::removePostedEvents(q, QEvent::MetaCall);

        }

    }

    if (mOrientation == orientation && !mForceSetOrientation && mEffectItem) {

        return;

    }

    // skip transition if graphicsview is not visible

    mAnimateOrientationSwitch = animate;

    if (!q->isVisible()) {

        mAnimateOrientationSwitch = false;

    }

    // calling due to resize, orientation remains the same -> no signalling

    if (!((mOrientation == orientation) && mForceSetOrientation)) {

        // cancel all effects

        HbEffectInternal::cancelAll();

        mOrientationChangeOngoing = true;

        mRootItemFinalPhaseDone = false;

        mOrientationEffectFinished = false;

        emit q->aboutToChangeOrientation();

        emit q->aboutToChangeOrientation(orientation, mAnimateOrientationSwitch);

    }

    mOrientation = orientation;

    if (!mAnimateOrientationSwitch) {

        HbEffect::disable(mEffectItem);

        HbEffect::disable(&mGVWrapperItem);

    } else {

        HbEffect::enable(mEffectItem);

        HbEffect::enable(&mGVWrapperItem);

    }

    // Sets graphicsview rotation effect to either 90/270 degrees

    updateRotationEffects();

    //For mirroring case

    changeSceneSize();

#ifdef Q_OS_SYMBIAN

    updateForegroundOrientationPSKey();

#endif

    HbEffect::start(mEffectItem, "rootItemFirstPhase", q, "rootItemFirstPhaseDone");

    if (mAnimateOrientationSwitch) {

        if (mStatusBar) {

            HbEffect::start(mStatusBar, "statusbar", "disappear_orient");

        }

        if (mTitleBar) {

            HbEffect::start(mTitleBar, "titlebar", "disappear_orient");

        }

        if (mCurrentToolbar) {

            HbToolBarPrivate *toolBarD = HbToolBarPrivate::d_ptr(mCurrentToolbar);

            toolBarD->startDisappearOrientEffect();

        }

    }

}

void HbMainWindowPrivate::changeSceneSize()

{

    // no need to perform the scene size change if there's no (rotation) effect for graphicsview

    if (!mGVOrientationChangeEffectEnabled) {

        return;

    }

    Q_Q(HbMainWindow);

    HbDeviceProfile profile = HbDeviceProfile::profile(q);

    QSize pSize(profile.logicalSize());

    // For RightToLeft we need to switch sceneRect values.

    if (q->layoutDirection() == Qt::RightToLeft && q->orientation() == Qt::Vertical) {

        mScene->setSceneRect(0, 0, pSize.height(), pSize.width());

    } else if (q->layoutDirection() == Qt::RightToLeft && q->orientation() == Qt::Horizontal) {

        mScene->setSceneRect(0, 0, pSize.width(), pSize.height());

    } else {

        mScene->setSceneRect(0, 0, pSize.height(), pSize.width());

    }

    q->setScene(0);

    q->setScene(mScene);

}

void HbMainWindowPrivate::updateRotationEffects()

{

    Q_Q(HbMainWindow);

    // if this is the default orientation the there's no transform, orientation angle is 0

    if (mOrientation == mDefaultOrientation) {

        mOrientationAngle = 0;

        return;

    }

    HbDeviceProfile o = HbDeviceProfile::profile(q);

    mOrientationAngle = o.orientationAngle();

    // Effects for GraphicsView (HbMainWindow)

    bool ret(true);

    bool ret2(true);

    // wrapper item holds the degree value for optimization purposes (set effect only once)

    if (mOrientationAngle == 270 && (mGVWrapperItem.transformDegrees != 270)) {

        mGVWrapperItem.transformDegrees = 270;

        ret = HbEffectInternal::add(&mGVWrapperItem, "toDefaultOrientation270", "toDefault");

        ret2 = HbEffectInternal::add(&mGVWrapperItem, "toRotatedOrientation270", "toRotated");

    } else if (mOrientationAngle == 90 && (mGVWrapperItem.transformDegrees != 90)) {

        mGVWrapperItem.transformDegrees = 90;

        ret = HbEffectInternal::add(&mGVWrapperItem, "toDefaultOrientation90", "toDefault");

        ret2 = HbEffectInternal::add(&mGVWrapperItem, "toRotatedOrientation90", "toRotated");

    }

    mGVOrientationChangeEffectEnabled = true;

    if (!ret || !ret2) {

        HbEffectInternal::remove(&mGVWrapperItem);

        mGVOrientationChangeEffectEnabled = false;

    }

}

qreal HbMainWindowPrivate::rotation() const

{

    return mOrientationAngle;

}

void HbMainWindowPrivate::select(const HbDeviceProfile &profile, HbDeviceProfile *oldGlobalProfile)

{

    // this window has a window-specific profile, do not override with global change

    if (!mCurrentProfile.isNull() && oldGlobalProfile) {

        return;

    }

    HbDeviceProfile oldProfile = oldGlobalProfile ? *oldGlobalProfile : mCurrentProfile;

    // only change mainwindow's profile if it's a non-global change

    if (!oldGlobalProfile) {

        mCurrentProfile = profile;

        mAlternateProfile = HbDeviceProfile(mCurrentProfile.alternateProfileName());

    }

    // if setting the same orientation send the profile changed event here since the setTransformedOrientation won't do it

    if ((mOrientation == profile.orientation()) &&

            mClippingItem->size() == profile.logicalSize()) {

        HbDeviceProfileChangedEvent *event = new HbDeviceProfileChangedEvent(profile, oldProfile);

        broadcastEvent(event);

    }

    mForceSetOrientation = true;

    setTransformedOrientation(profile.orientation(), false);

    mForceSetOrientation = false;

}

HbDeviceProfile HbMainWindowPrivate::profile() const

{

    return adjustedProfile(mCurrentProfile);

}

HbDeviceProfile HbMainWindowPrivate::adjustedProfile(const HbDeviceProfile &profile) const

{

    HbDeviceProfile result = profile;

    if (!result.isNull() && result.orientation() != mOrientation) {

        if (mAlternateProfile.isNull()) {

            mAlternateProfile = HbDeviceProfile(profile.alternateProfileName());

            return mAlternateProfile;

        } else {

            return mAlternateProfile;

        }

    }

    return result;

}

void HbMainWindowPrivate::orientationEffectFinished(const HbEffect::EffectStatus &status)

{

    Q_UNUSED(status);

    Q_Q(HbMainWindow);

    mOrientationEffectFinished = true;

    QSize newSize;

    HbDeviceProfile o = HbDeviceProfile::profile(q);

    newSize = o.logicalSize();

    // do some sanity checking for the size got from device profile

    if (newSize.isNull() || ((newSize.width()*newSize.height()) < QVga_res)) {  // the resolution must be at least QVGA..

        hbWarning("Orient. change error: size from device profile is faulty!");

    }

    q->setSceneRect(0, 0, newSize.width(), newSize.height());

    if (mBgItem) {

        mBgItem->updateBackgroundImage();

    }

    // re-layouting, skip if size does not change

    if (mOrientationChangeOngoing || mClippingItem->size() != newSize) {

        mClippingItem->resize(newSize);

        if (mScreenshotItem) {

            mScreenshotItem->resize(newSize);

        }

        mLayoutRect = QRectF(QPointF(0, 0), newSize);

        // reset transformation

        q->resetTransform();

        // if not default rotation, rotate to the defined angle no matter what the effect did

        if (mOrientation != mDefaultOrientation) {

            q->rotate(mOrientationAngle);

        }

        // handle actual orientation change only if the orientation really changes (not just a resize)

        if (mOrientationChangeOngoing) {

            // signal only if layout changes (=orientation changes)

            // Background item is re-layouted from device profile changed event

            emit q->orientationChanged(mOrientation);

            HbDeviceProfile oldProfile = HbDeviceProfile(o.alternateProfileName());