/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include <QStateMachine>

#include <QGraphicsSceneMouseEvent>

#include <QPropertyAnimation>

#include <QApplication>

#include <QVariantHash>

#include <QInputContext>

#include <HbMainWindow>

#include <HbView>

#include <HbMenu>

#include <HbAction>

#include <HbMessageBox>

#include <HbInstance>

#include <HbLabel>

#include <HbInstantFeedback>

#include <HbContinuousFeedback>

#include <HbPanGesture>

#include <HbTapAndHoldGesture>

#include <HbVkbHostBridge>

#include <HbInputFocusObject>

#ifdef Q_OS_SYMBIAN

#include <XQSettingsManager>

#include <startupdomainpskeys.h>

#endif

#include "hsidlestate.h"

#include "hsidlewidget.h"

#include "hsdomainmodeldatastructures.h"

#include "hsscene.h"

#include "hspage.h"

#include "hspagevisual.h"

#include "hswidgethost.h"

#include "hswidgethostvisual.h"

#include "hswallpaper.h"

#include "hswallpaperselectionstate.h"

#include "hstrashbinwidget.h"

#include "hspageindicator.h"

#include "hsmenueventfactory.h"

#include "hshomescreenstatecommon.h"

#include "hstitleresolver.h"

#include "hsmenuservice.h"

#include "hsconfiguration.h"

#include "hsmessageboxwrapper.h"

#include "hspropertyanimationwrapper.h"

#include "hsgui.h"

namespace

{

    //User adds a new page to home screen

    const char hsLocTextId_OptionsMenu_AddPage[] = "txt_homescreen_opt_add_page";

    //User removes page from home screen

    const char hsLocTextId_OptionsMenu_RemovePage[] = "txt_homescreen_opt_remove_page";

    //Sends request to all widgets to enable data connections

    const char hsLocTextId_OptionsMenu_HsToOnline[] = "txt_homescreen_opt_home_screen_to_online";

    //Sends request to all widgets to disable data connections

    const char hsLocTextId_OptionsMenu_HsToOffline[] = "txt_homescreen_opt_home_screen_to_offline";

    //Home screen canvas menu item for opening picture gallery

    const char hsLocTextId_ContextMenu_ChangeWallpaper[] = "txt_homescreen_list_change_wallpaper";

    //Home screen canvas menu item for opening Application library

    const char hsLocTextId_ContextMenu_AddContent[] = "txt_homescreen_opt_add_content";

    //Home screen options menu item for opening Task switcher

    const char hsLocTextId_OptionsMenu_TaskSwitcher[] = "txt_homescreen_opt_task_switcher";

    //Heading text in confirmation dialog while removing page with content

    const char hsLocTextId_Title_RemovePage[] = "txt_homescreen_title_remove_page";

    //Text in confirmation dialog while removing page with content

    const char hsLocTextId_Confirmation_RemovePage[] = "txt_homescreen_info_page_and_content_will_be_remov";

}

// Helper macros for connecting state entry and exit actions.

#define ENTRY_ACTION(state, action) \

    connect(state, SIGNAL(entered()), SLOT(action()));

#define EXIT_ACTION(state, action) \

    connect(state, SIGNAL(exited()), SLOT(action()));

/*!

    \class HsIdleState

    \ingroup group_hshomescreenstateplugin

    \brief Controller part of the home screen idle state.

    Controls the home screen idle state execution. See the

    state chart below for the state structure.

    \imageDEPRECATED html hsidlestate_statechart.png

*/

/*!

    Constructs a new idle state with the given \a parent.

*/

HsIdleState::HsIdleState(QState *parent)

  : QState(parent),

    mNavigationAction(0), 

    mTitleResolver(0),

    mAllowZoneAnimation(false),

    mContinuousFeedback(0),

    mTrashBinFeedbackAlreadyPlayed(false),

    mDeltaX(0),

    mWidgetX(0),

    mWidgetY(0),

    mSceneMenu(0)

#ifdef Q_OS_SYMBIAN

    ,mSettingsMgr(0)

#endif

    ,mMessageBoxWrapper(0)

{

    setupStates();

    mTitleResolver = new HsTitleResolver(this);

    // TODO: Uncomment when updated API available

    //mContinuousFeedback = new HbContinuousFeedback;

    //mContinuousFeedback->setContinuousEffect(HbFeedback::ContinuousSmooth);

    //mContinuousFeedback->setIntensity(HbFeedback::IntensityFull );

    mVerticalSnapLineTimer.setSingleShot(true);

    mHorizontalSnapLineTimer.setSingleShot(true);

}

/*!

    Destroys this idle state.

*/

HsIdleState::~HsIdleState()

{

    // TODO: Uncomment when updated API available

    //delete mContinuousFeedback;

}

/*!

    \copydoc QObject::eventFilter(QObject *watched, QEvent *event)

*/

bool HsIdleState::eventFilter(QObject *watched, QEvent *event)

{

    switch (event->type()) {

        case QEvent::ApplicationActivate:

            action_idle_layoutNewWidgets();

            break;

        case QEvent::ApplicationDeactivate:

            emit event_waitInput();

            break;

        default:

            break;

    }

    return QState::eventFilter(watched, event);

}

/*!

    \fn HsIdleState::event_applicationLibrary()

    This signal initiates a transition to application library.

*/

/*!

    \fn HsIdleState::event_waitInput()

    This signal initiates a transition to the waitInput state.

*/

/*!

    \fn HsIdleState::event_moveWidget()

    This signal initiates a transition to the moveWidget state.

*/

/*!

    \fn HsIdleState::event_moveScene()

    This signal initiates a transition to the moveScene state.

*/

/*!

    \fn HsIdleState::event_selectWallpaper()

    This signal initiates a transition to the selectSceneWallpaper state.

*/

/*!

    \fn HsIdleState::event_addPage()

    This signal initiates a transition to the addPage state.

*/

/*!

    \fn HsIdleState::event_removePage()

    This signal initiates a transition to the removePage state.

*/

/*!

    \fn HsIdleState::event_toggleConnection()

    This signal initiates a transition to the toggleConnection state.

*/

/*!

    Creates the internal state structure and connects

    state entry and exit actions.

*/

void HsIdleState::setupStates()

{

    // States

    QState *state_waitInput = new QState(this);

    setInitialState(state_waitInput);

    QState *state_moveWidget = new QState(this);

    QState *state_moveWidgetMoving = new QState(state_moveWidget);

    QState *state_moveWidgetDelete = new QState(state_moveWidget);

    state_moveWidget->setInitialState(state_moveWidgetMoving);

    QState *state_moveScene = new QState(this);

    HsWallpaperSelectionState *state_wallpaperSelectionState =

        new HsWallpaperSelectionState(this);

    QState *state_addPage = new QState(this);

    QState *state_preRemovePage = new QState(this);

    QState *state_removePage = new QState(this);

    QState *state_toggleConnection = new QState(this);

    // Transitions

    state_waitInput->addTransition(

        this, SIGNAL(event_addPage()), state_addPage);

    state_waitInput->addTransition(

        this, SIGNAL(event_preRemovePage()), state_preRemovePage);

    state_waitInput->addTransition(

        this, SIGNAL(event_toggleConnection()), state_toggleConnection);

    state_waitInput->addTransition(

        this, SIGNAL(event_selectWallpaper()), state_wallpaperSelectionState);

    state_waitInput->addTransition(

        this, SIGNAL(event_moveScene()), state_moveScene);

    state_waitInput->addTransition(

        this, SIGNAL(event_moveWidget()), state_moveWidget);

    state_moveWidgetMoving->addTransition(

        this, SIGNAL(event_waitInput()), state_waitInput);

    state_moveWidgetMoving->addTransition(

        this, SIGNAL(event_MoveWidgetDelete()), state_moveWidgetDelete);

    state_moveWidgetDelete->addTransition(state_waitInput);

    state_moveScene->addTransition(

        this, SIGNAL(event_waitInput()), state_waitInput);

    state_wallpaperSelectionState->addTransition(

        state_wallpaperSelectionState, SIGNAL(event_waitInput()), state_waitInput);

    state_addPage->addTransition(state_waitInput);

    state_preRemovePage->addTransition(

        this,SIGNAL(event_removePage()),state_removePage);

    state_preRemovePage->addTransition(

        this,SIGNAL(event_waitInput()),state_waitInput);

    state_removePage->addTransition(

        this,SIGNAL(event_waitInput()),state_waitInput);

    state_toggleConnection->addTransition(state_waitInput);

    // Actions

    ENTRY_ACTION(this, action_idle_setupView)

    ENTRY_ACTION(this, action_idle_layoutNewWidgets)

    ENTRY_ACTION(this, action_idle_showActivePage)

    ENTRY_ACTION(this, action_idle_connectOrientationChangeEventHandler)

    ENTRY_ACTION(this, action_idle_setupTitle)

    ENTRY_ACTION(this, action_idle_installEventFilter)

    EXIT_ACTION(this, action_idle_cleanupTitle)

    EXIT_ACTION(this, action_idle_cleanupView)

    EXIT_ACTION(this, action_idle_disconnectOrientationChangeEventHandler)

    EXIT_ACTION(this, action_idle_uninstallEventFilter)

    ENTRY_ACTION(state_waitInput, action_waitInput_updateOptionsMenu)

    ENTRY_ACTION(state_waitInput, action_waitInput_connectGestureHandlers)

    ENTRY_ACTION(state_waitInput, action_waitInput_publishIdleKey)

    EXIT_ACTION(state_waitInput, action_waitInput_disconnectGestureHandlers)

    EXIT_ACTION(state_waitInput, action_waitInput_resetNewWidgets)

    ENTRY_ACTION(state_moveWidget, action_moveWidget_reparentToControlLayer)

    ENTRY_ACTION(state_moveWidget, action_moveWidget_startWidgetDragEffect)

    ENTRY_ACTION(state_moveWidget, action_moveWidget_connectGestureHandlers)

    ENTRY_ACTION(state_moveWidget, action_moveWidget_connectOrientationChangeEventHandler)

    ENTRY_ACTION(state_moveWidget, action_moveWidget_setWidgetSnap)

    EXIT_ACTION(state_moveWidget, action_moveWidget_reparentToPage)

    EXIT_ACTION(state_moveWidget, action_moveWidget_startWidgetDropEffect)

    EXIT_ACTION(state_moveWidget, action_moveWidget_disableInteractive)

    EXIT_ACTION(state_moveWidget, action_moveWidget_disconnectGestureHandlers)

    EXIT_ACTION(state_moveWidget, action_moveWidget_disconnectOrientationChangeEventHandler)

    EXIT_ACTION(state_moveWidget, action_moveWidget_preventZoneAnimation)

    EXIT_ACTION(state_moveWidget, action_moveWidget_deleteWidgetSnap)

    ENTRY_ACTION(state_moveWidgetDelete, action_moveWidgetDelete_deleteWidgetOnTrashbin)

    ENTRY_ACTION(state_moveScene, action_moveScene_connectGestureHandlers)

    EXIT_ACTION(state_moveScene, action_moveScene_moveToNearestPage)

    EXIT_ACTION(state_moveScene, action_moveScene_disconnectGestureHandlers)

    ENTRY_ACTION(state_addPage, action_addPage_addPage)

    ENTRY_ACTION(state_preRemovePage, action_preRemovePage_showQuery)

    EXIT_ACTION(state_preRemovePage, action_preRemovePage_exit);

    ENTRY_ACTION(state_removePage, action_removePage_startRemovePageAnimation)

    EXIT_ACTION(state_removePage, action_removePage_removePage)

    ENTRY_ACTION(state_toggleConnection, action_toggleConnection_toggleConnection)

}

/*!

    Computes the page layer x position based on the given \a pageIndex.

*/

qreal HsIdleState::pageLayerXPos(int pageIndex) const

{

    return -pageIndex * HsGui::instance()->layoutRect().width();

}

/*!

    Starts the page change animation based on the given \a targetPageIndex

    and \a duration.

*/

void HsIdleState::startPageChangeAnimation(int targetPageIndex, int duration)

{

    if (!HsScene::instance()->activeWidget()) {

        hbInstance->allMainWindows().first()->setInteractive(false);

    }

    HsPropertyAnimationWrapper *animation = HsGui::instance()->pageChangeAnimation();

    if (animation->isRunning()) {

        animation->stop();

    }        

    animation->disconnect(this);

    animation->setEndValue(pageLayerXPos(targetPageIndex));

    animation->setDuration(duration);

    if (abs(mDeltaX) < HSCONFIGURATION_GET(pageChangePanDistance)) {

        animation->setEasingCurve(HSCONFIGURATION_GET(bounceAnimationEasingCurve)); 

    }

    else {

        animation->setEasingCurve(HSCONFIGURATION_GET(pageChangeAnimationEasingCurve));

    }

    connect(animation,

            SIGNAL(finished()),

            SLOT(pageChangeAnimationFinished()), 

            Qt::UniqueConnection);

    animation->start();

    HbInstantFeedback::play(HSCONFIGURATION_GET(pageChangeFeedbackEffect));

    HsGui::instance()->idleWidget()->showPageIndicator();

    HsGui::instance()->idleWidget()->setActivePage(targetPageIndex);

}

/*!

    Starts the page change zone animation (crawling) based on the given a\ duration

*/

void HsIdleState::startPageChangeZoneAnimation(int duration)

{

    HsScene *scene = HsScene::instance();

    int targetPageIndex = scene->activePageIndex();

    if (isInLeftPageChangeZone() && 0 < targetPageIndex) {

        --targetPageIndex;

    } else if (isInRightPageChangeZone() &&

        targetPageIndex < HSCONFIGURATION_GET(maximumPageCount) - 1) {

        ++targetPageIndex;

    } else {

        return;

    }

    int bounceEffect = HSCONFIGURATION_GET(bounceEffect);

    HsPropertyAnimationWrapper *pageCrawlingAnimation =

        HsGui::instance()->pageCrawlingAnimation();

    if (isInLeftPageChangeZone()) {

        pageCrawlingAnimation->setEndValue(pageLayerXPos(scene->activePageIndex()) + bounceEffect);

    } else {

        pageCrawlingAnimation->setEndValue(pageLayerXPos(scene->activePageIndex()) - bounceEffect);

    }

    pageCrawlingAnimation->setDuration(duration);

    pageCrawlingAnimation->setForward();

    connect(pageCrawlingAnimation,

            SIGNAL(finished()),

            SLOT(zoneAnimationFinished()),

            Qt::UniqueConnection);

    pageCrawlingAnimation->start();

}

/*!

    Checks if the active widget is located inside the left or right

    page change zone.

*/

bool HsIdleState::isInPageChangeZone()

{

    return isInLeftPageChangeZone() ||

           isInRightPageChangeZone();

}

/*!

    Checks if touch point in the active widget is located inside the left

    page change zone.

*/

bool HsIdleState::isInLeftPageChangeZone()

{

    return mWidgetHotSpot.x() < HSCONFIGURATION_GET(pageChangeZoneWidth);

}

/*!

    Checks if touch point in the active widget is located inside the right

    page change zone.

*/

bool HsIdleState::isInRightPageChangeZone()

{

    qreal pageWidth = HsGui::instance()->layoutRect().width();

    return mWidgetHotSpot.x() > pageWidth - HSCONFIGURATION_GET(pageChangeZoneWidth);

}

/*!

    Inserts new page at index position \a pageIndex in the scene.

*/

void HsIdleState::addPageToScene(int pageIndex)

{

    HsPageData data;

    data.indexPosition = pageIndex;

    HsPage *page = HsPage::createInstance(data);

    page->load();

    HsScene::instance()->addPage(page);

    HsGui::instance()->idleWidget()->insertPage(pageIndex, page);

}

/*!

    Checks if page change zone animation needs to be started or stopped

*/

void HsIdleState::updateZoneAnimation()

{

    HsPropertyAnimationWrapper *pageCrawlingAnimation = 

        HsGui::instance()->pageCrawlingAnimation();

    if (!mAllowZoneAnimation) {

        pageCrawlingAnimation->stop();

    } else if (isInPageChangeZone()) {

        // should we start it

        if (!pageCrawlingAnimation->isRunning() &&

            !HsGui::instance()->pageChangeAnimation()->isRunning()) {

            startPageChangeZoneAnimation(HSCONFIGURATION_GET(pageChangeZoneAnimationDuration));

        } 

    } else if (pageCrawlingAnimation->isRunning()) {

        // Not in zone, but still running     

        if (pageCrawlingAnimation->isForward()){

            // reverse

            pageCrawlingAnimation->setDuration(HSCONFIGURATION_GET(pageChangeZoneReverseAnimationDuration));

            pageCrawlingAnimation->setBackward();

        } 

    } 

}

/*!

    Selects which trash bin icon is shown or not shown at all

*/

void HsIdleState::showTrashBin()

{

    if (HsGui::instance()->idleWidget()->trashBin()->isUnderMouse()) {

        if (!mTrashBinFeedbackAlreadyPlayed) {

            HbInstantFeedback::play(HSCONFIGURATION_GET(widgetOverTrashbinFeedbackEffect));

            mTrashBinFeedbackAlreadyPlayed = true;