/*

* 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 <QGraphicsLinearLayout>

#include <QParallelAnimationGroup>

#include <QPropertyAnimation>

#include <QApplication>

#include <QDir>

#include <HbMainWindow>

#include <HbView>

#include <HbMenu>

#include <HbAction>

#include <HbIcon>

#include <HbMessageBox>

#include <HbLabel>

#include "hsidlestate.h"

#include "hsidlewidget.h"

#include "hsdomainmodeldatastructures.h"

#include "hsscene.h"

#include "hspage.h"

#include "hswidgethost.h"

#include "hswallpaper.h"

#include "hsselectbackgroundstate.h"

#include "hstrashbinwidget.h"

#include "hspageindicator.h"

#include "hswidgetpositioningonorientationchange.h"

#include "hsmenueventfactory.h"

#include "hshomescreenstatecommon.h"

#include "hstitleresolver.h"

#include "hsmenuservice.h"

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

// Helper macros for connecting and disconnecting mouse event handlers.

#define CONNECT_MOUSE_EVENT_HANDLER(signal, slot) \

    connect(mUiWidget, SIGNAL(signal(QGraphicsItem*,QGraphicsSceneMouseEvent*,bool&)), \

        SLOT(slot(QGraphicsItem*,QGraphicsSceneMouseEvent*,bool&)));

#define DISCONNECT_MOUSE_EVENT_HANDLER(signal, slot) \

    disconnect(mUiWidget, SIGNAL(signal(QGraphicsItem*,QGraphicsSceneMouseEvent*,bool&)), \

        this, SLOT(slot(QGraphicsItem*,QGraphicsSceneMouseEvent*,bool&)));

namespace

{

    const char gApplicationLibraryIconName[] = "qtg_mono_applications_all";

    //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_list_add_content";

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

    //Button in confirmation dialog while removing page with content

    const char hsLocTextId_ConfirmationButton_Ok[] = "txt_homescreen_button_ok";

    //Button in confirmation dialog while removing page with content

    const char hsLocTextId_ConfirmationButton_Cancel[] = "txt_homescreen_button_cancel";

}

/*!

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

    \image html hsidlestate_statechart.png

*/

/*!

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

*/

HsIdleState::HsIdleState(QState *parent)

  : QState(parent),

    mView(0), mNavigationAction(0), mUiWidget(0),

    mTapAndHoldDistance(16),

    mPageChangeZoneWidth(60),

    mTitleResolver(0),

{

    setupStates();

    mTimer.setSingleShot(true);

    mTitleResolver = new HsTitleResolver(this);

}

/*!

    Destroys this idle state.

*/

HsIdleState::~HsIdleState()

{

}

/*!

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

*/

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

{

    switch (event->type()) {

            break;

        default:

            break;

}

/*!

    \fn HsIdleState::event_applicationLibrary()

    This signal initiates a transition to application library.

*/

/*!

    This signal initiates a transition to the waitInput state.

*/

/*!

    This signal initiates a transition to the widgetInteraction state.

*/

/*!

    This signal initiates a transition to the sceneInteraction state.

*/

/*!

    This signal initiates a transition to the moveWidget state.

*/

/*!

    This signal initiates a transition to the moveScene state.

*/

/*!

    This signal initiates a transition to the sceneMenu state.

*/

/*!

    This signal initiates a transition to the selectSceneWallpaper state.

*/

/*!

    This signal initiates a transition to the addPage state.

*/

/*!

    This signal initiates a transition to the removePage state.

*/

/*!

    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_widgetInteraction = new QState(this);

    QState *state_sceneInteraction = new QState(this);

    QState *state_moveWidget = new QState(this);

    QState *state_moveScene = new QState(this);

    QState *state_sceneMenu = new QState(this);

        new HsSelectBackgroundState(this);

    QState *state_addPage = new QState(this);

    QState *state_removePage = new QState(this);

    QState *state_toggleConnection = new QState(this);

    // Transitions

    state_waitInput->addTransition(

        this, SIGNAL(event_widgetInteraction()), state_widgetInteraction);

    state_waitInput->addTransition(

        this, SIGNAL(event_sceneInteraction()), state_sceneInteraction);

    state_waitInput->addTransition(

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

    state_waitInput->addTransition(

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

    state_waitInput->addTransition(

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

    state_waitInput->addTransition(

        this, SIGNAL(event_selectSceneWallpaper()), state_selectSceneWallpaper);

    state_widgetInteraction->addTransition(

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

    state_widgetInteraction->addTransition(

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

    state_sceneInteraction->addTransition(

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

    state_sceneInteraction->addTransition(

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

    state_sceneInteraction->addTransition(

        this, SIGNAL(event_sceneMenu()), state_sceneMenu);

    state_moveWidget->addTransition(

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

    state_moveScene->addTransition(

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

    state_sceneMenu->addTransition(

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

    state_sceneMenu->addTransition(

        this, SIGNAL(event_selectSceneWallpaper()), state_selectSceneWallpaper);

    state_sceneMenu->addTransition(

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

    state_selectSceneWallpaper->addTransition(

        state_selectSceneWallpaper, SIGNAL(event_waitInput()), state_waitInput);

    state_addPage->addTransition(state_waitInput);

    state_removePage->addTransition(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_connectMouseEventHandlers)

    EXIT_ACTION(state_waitInput, action_waitInput_disconnectMouseEventHandlers)

    ENTRY_ACTION(state_widgetInteraction, action_widgetInteraction_connectMouseEventHandlers)

    ENTRY_ACTION(state_widgetInteraction, action_widgetInteraction_connectGestureTimers)

    EXIT_ACTION(state_widgetInteraction, action_widgetInteraction_disconnectMouseEventHandlers)

    EXIT_ACTION(state_widgetInteraction, action_widgetInteraction_disconnectGestureTimers)

    ENTRY_ACTION(state_sceneInteraction, action_sceneInteraction_connectMouseEventHandlers)

    ENTRY_ACTION(state_sceneInteraction, action_sceneInteraction_connectGestureTimers)

    EXIT_ACTION(state_sceneInteraction, action_sceneInteraction_disconnectMouseEventHandlers)

    EXIT_ACTION(state_sceneInteraction, action_sceneInteraction_disconnectGestureTimers)

    ENTRY_ACTION(state_moveWidget, action_moveWidget_reparentToControlLayer)

    ENTRY_ACTION(state_moveWidget, action_moveWidget_connectMouseEventHandlers)

    EXIT_ACTION(state_moveWidget, action_moveWidget_reparentToPage)

    EXIT_ACTION(state_moveWidget, action_moveWidget_disconnectMouseEventHandlers)

    ENTRY_ACTION(state_moveScene, action_moveScene_connectMouseEventHandlers)

    EXIT_ACTION(state_moveScene, action_moveScene_disconnectMouseEventHandlers)

    ENTRY_ACTION(state_sceneMenu, action_sceneMenu_showMenu)

    ENTRY_ACTION(state_addPage, action_disableUserInteraction)

    ENTRY_ACTION(state_addPage, action_addPage_addPage)

    EXIT_ACTION(state_addPage, action_enableUserInteraction)

    ENTRY_ACTION(state_removePage, action_disableUserInteraction)

    ENTRY_ACTION(state_removePage, action_removePage_removePage)

    EXIT_ACTION(state_removePage, action_enableUserInteraction)

    ENTRY_ACTION(state_toggleConnection, action_disableUserInteraction)

    ENTRY_ACTION(state_toggleConnection, action_toggleConnection_toggleConnection)

    EXIT_ACTION(state_toggleConnection, action_enableUserInteraction)

}

/*!

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

*/

qreal HsIdleState::pageLayerXPos(int pageIndex) const

{

    return -pageIndex * HsScene::mainWindow()->layoutRect().width() - 0.5;

}

/*!

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

    and \a duration.

*/

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

{

    if (!mPageChangeAnimation) {

        mPageChangeAnimation = new QParallelAnimationGroup(this);

        QPropertyAnimation *animation = new QPropertyAnimation(mUiWidget->pageLayer(), "x");

        animation->setEndValue(pageLayerXPos(targetPageIndex));

        animation->setDuration(duration);

        mPageChangeAnimation->addAnimation(animation);

        animation = new QPropertyAnimation(mUiWidget->sceneLayer(), "x");

        animation->setEndValue((parallaxFactor() * pageLayerXPos(targetPageIndex)) - HSBOUNDARYEFFECT / 2);

        animation->setDuration(duration);

        mPageChangeAnimation->addAnimation(animation);

    }

    else {

        if (QAbstractAnimation::Stopped != mPageChangeAnimation->state()) {

            mPageChangeAnimation->stop();

        }

        QAbstractAnimation *animation = mPageChangeAnimation->animationAt(0);

        qobject_cast<QPropertyAnimation*>(animation)->setEndValue(pageLayerXPos(targetPageIndex));

        qobject_cast<QPropertyAnimation*>(animation)->setDuration(duration);

        animation = mPageChangeAnimation->animationAt(1);

        qobject_cast<QPropertyAnimation*>(animation)->setEndValue((parallaxFactor() * pageLayerXPos(targetPageIndex)) - HSBOUNDARYEFFECT / 2);

    }

    mPageChangeAnimation->start();

    mUiWidget->showPageIndicator();

    mUiWidget->setActivePage(targetPageIndex);

}

/*!

*/

void HsIdleState::startPageChangeZoneAnimation(int duration)

{

    HsScene *scene = HsScene::instance();

    int targetPageIndex = scene->activePageIndex();

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

        --targetPageIndex;

    } else if (isInRightPageChangeZone() &&

        targetPageIndex < scene->pages().count()) {

        ++targetPageIndex;

        return;

    }

    if (targetPageIndex == scene->pages().count()

        mAllowZoneAnimation = true;

    }

    if (!mZoneAnimation) {

        mZoneAnimation = new QPropertyAnimation(mUiWidget->sceneLayer(), "x");

    }

    if (isInLeftPageChangeZone()) {

        mZoneAnimation->setEndValue(((parallaxFactor() * pageLayerXPos(scene->activePageIndex()))-HSBOUNDARYEFFECT/2)+HSBOUNDARYEFFECT/2);

    } else {

        mZoneAnimation->setEndValue(((parallaxFactor() * pageLayerXPos(scene->activePageIndex()))-HSBOUNDARYEFFECT/2)-HSBOUNDARYEFFECT/2);

    }

    mZoneAnimation->setDuration(duration);

    mZoneAnimation->setDirection(QAbstractAnimation::Forward);

    connect(mZoneAnimation,

            SIGNAL(finished()),

            SLOT(zoneAnimationFinished()));

    mPageChanged = true;

}

/*!

    page change zone.

*/

bool HsIdleState::isInPageChangeZone()

{

    qreal widgetXPos = HsScene::instance()->activeWidget()->geometry().center().x();

    qreal pageWidth = HsScene::mainWindow()->layoutRect().width();

    return widgetXPos < mPageChangeZoneWidth ||

           pageWidth - mPageChangeZoneWidth < widgetXPos;

}

/*!

    Checks if the active widget is located inside the left

    page change zone.

*/

bool HsIdleState::isInLeftPageChangeZone()

{

    qreal widgetXPos = HsScene::instance()->activeWidget()->geometry().center().x();

    return widgetXPos < mPageChangeZoneWidth;

}

/*!

    Checks if the active widget is located inside the right

    page change zone.

*/

bool HsIdleState::isInRightPageChangeZone()

{

    qreal widgetXPos = HsScene::instance()->activeWidget()->geometry().center().x();

    qreal pageWidth = HsScene::mainWindow()->layoutRect().width();

    return pageWidth - mPageChangeZoneWidth < widgetXPos;

}

/*!

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

    mUiWidget->insertPage(pageIndex, page);

}

/*!

    Computes the parallax factor based on the current scene and

    page layer widths, and page count.