/*

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

#include "hsidlewidget.h"

#include "hsscene.h"

#include "hspage.h"

#include "hswidgethost.h"

#include "hswallpaper.h"

#include "hspagedata.h"

#include "hsselectbackgroundstate.h"

#include "hstrashbinwidget.h"

#include "hspageindicator.h"

#include "hsapptranslator.h"

#include "hswidgetpositioningonorientationchange.h"

#include "hsmenueventfactory.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 APP_LIB_BUTTON[] = 

        "hs_applib_button.png";

    /*const char TXT_HOMESCREEN_TITLE_OFFLINE[] = 

        "txt_homescreen_title_offline";*/

    const char TXT_HOMESCREEN_OPT_ADD_PAGE[] = 

        "txt_homescreen_opt_add_page";

    const char TXT_HOMESCREEN_OPT_REMOVE_PAGE[] = 

        "txt_homescreen_opt_remove_page";

    const char TXT_HOMESCREEN_OPT_HOME_SCREEN_TO_ONLINE[] = 

        "txt_homescreen_opt_home_screen_to_online";

    const char TXT_HOMESCREEN_OPT_HOME_SCREEN_TO_OFFLINE[] = 

        "txt_homescreen_opt_home_screen_to_offline";

    const char TXT_HOMESCREEN_LIST_CHANGE_WALLPAPER[] = 

        "txt_homescreen_list_change_wallpaper";

    const char TXT_HOMESCREEN_LIST_ADD_CONTENT[] = 

        "txt_homescreen_list_add_content";

}

/*!

    \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), mSoftKeyAction(0), mUiWidget(0),

    mTapAndHoldDistance(16),

    mPageChangeZoneWidth(60)

{

    setupStates();

    mTimer.setSingleShot(true);

}

/*!

    Destroys this idle state.

*/

HsIdleState::~HsIdleState()

{

}

/*!

    \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_widgetInteraction()  

    This signal initiates a transition to the widgetInteraction state.

*/

/*!

    \fn HsIdleState::event_sceneInteraction()  

    This signal initiates a transition to the sceneInteraction 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_sceneMenu()  

    This signal initiates a transition to the sceneMenu state.

*/

/*!

    \fn HsIdleState::event_selectSceneWallpaper()  

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

    HsSelectBackgroundState *state_selectSceneWallpaper = 

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

    EXIT_ACTION(this, action_idle_cleanupView)

    EXIT_ACTION(this, action_idle_disconnectOrientationChangeEventHandler)

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

    ENTRY_ACTION(state_moveWidget, action_moveWidget_connectMouseEventHandlers)

    ENTRY_ACTION(state_moveWidget, action_moveWidget_connectGestureTimers)

    EXIT_ACTION(state_moveWidget, action_moveWidget_reparentToPage)

    EXIT_ACTION(state_moveWidget, action_moveWidget_startWidgetDropAnimation)

    EXIT_ACTION(state_moveWidget, action_moveWidget_disconnectMouseEventHandlers)

    EXIT_ACTION(state_moveWidget, action_moveWidget_disconnectGestureTimers)

    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)

{

    QParallelAnimationGroup *animationGroup = new QParallelAnimationGroup;

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

    animation->setEndValue(pageLayerXPos(targetPageIndex));

    animation->setDuration(duration);

    animationGroup->addAnimation(animation);

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

    animation->setEndValue(parallaxFactor() * pageLayerXPos(targetPageIndex));

    animation->setDuration(duration);

    animationGroup->addAnimation(animation);

    animationGroup->start(QAbstractAnimation::DeleteWhenStopped);

    mUiWidget->showPageIndicator();

    mUiWidget->setActivePage(targetPageIndex);

}

/*!

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

    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.setIndex(pageIndex);

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

    page->load();

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

    mUiWidget->insertPage(pageIndex, page);

}

/*!

    Computes the parallax factor based on the current scene and

    page layer widths, and page count.

*/

qreal HsIdleState::parallaxFactor() const

{

    qreal clw = mUiWidget->controlLayer()->size().width();

    qreal slw = mUiWidget->sceneLayer()->size().width();

    int n = HsScene::instance()->pages().count();

    if (n < 2) {

        return 1;

    } else {

        return (slw - clw) / ((n - 1) * clw);

    }

}

/*!

    Disables the main window user interaction.

*/

void HsIdleState::action_disableUserInteraction()

{

    HsScene::mainWindow()->setInteractive(false);

}

/*!

    Enables the main window user interaction.

*/

void HsIdleState::action_enableUserInteraction()

{

    HsScene::mainWindow()->setInteractive(true);

}

/*!

    If called for the first time, setups the idle view.

    Updates the soft key action and sets the idle view 

    as the current view to the main window.

*/

void HsIdleState::action_idle_setupView()

{

    if (!mView) {

        mUiWidget = new HsIdleWidget;

        mView = HsScene::mainWindow()->addView(mUiWidget);

        mView->setContentFullScreen();

        mView->setTitle("Home Screen"/*hbTrId(TXT_HOMESCREEN_TITLE_OFFLINE)*/);

        mSoftKeyAction = new HbAction(this);

        mSoftKeyAction->setIcon(HbIcon(APP_LIB_BUTTON));

        connect(mSoftKeyAction, SIGNAL(triggered()), SIGNAL(event_applicationLibrary()));

#ifndef Q_OS_SYMBIAN

        connect(HsAppTranslator::instance(), 

            SIGNAL(languageChanged()), SLOT(translateUi()));

#endif

        // TODO: Workaround to Qt/Hb layouting bugs.

        QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);

    }

    HsScene::mainWindow()->addSoftKeyAction(Hb::SecondarySoftKey, mSoftKeyAction);

    HsScene::mainWindow()->setCurrentView(mView);

}

/*!

    Lays out the active page's new widgets that were added

    from the application library.

*/

void HsIdleState::action_idle_layoutNewWidgets()

{

    HsPage *page = HsScene::instance()->activePage();    

    if (!page) {

        return;

    }

    QList<HsWidgetHost *> widgets = page->newWidgets();     

    if (widgets.isEmpty()) {

        return;

    }

    foreach (HsWidgetHost *widget, widgets) {

        widget->initializeWidget();

        widget->showWidget();

    }

    page->layoutNewWidgets();

    page->resetNewWidgets();

}

/*!

    Moves the scene and page layers so that the active

    page is shown.

*/

void HsIdleState::action_idle_showActivePage()

{

    qreal x = pageLayerXPos(HsScene::instance()->activePageIndex());

    mUiWidget->pageLayer()->setX(x);

    mUiWidget->sceneLayer()->setX(parallaxFactor() * x);

}

/*!

    Connects the orientation change event handler.

*/

void HsIdleState::action_idle_connectOrientationChangeEventHandler()

{

    connect(HsScene::mainWindow(), 

        SIGNAL(orientationChanged(Qt::Orientation)),

        SLOT(onOrientationChanged(Qt::Orientation)));

}

/*!

    Cleans up the idle view.

*/

void HsIdleState::action_idle_cleanupView()

{

    HsScene::mainWindow()->removeSoftKeyAction(

        Hb::SecondarySoftKey, mSoftKeyAction);

}

/*!

    Disconnects the orientation change event handler.

*/

void HsIdleState::action_idle_disconnectOrientationChangeEventHandler()

{

    disconnect(HsScene::mainWindow(), 

        SIGNAL(orientationChanged(Qt::Orientation)),

        this, SLOT(onOrientationChanged(Qt::Orientation)));

}

/*!

    Updates the options menu content.

*/

void HsIdleState::action_waitInput_updateOptionsMenu()

{

    HbMenu *menu = new HbMenu();

    menu->addAction(hbTrId(TXT_HOMESCREEN_OPT_ADD_PAGE), 

        this, SIGNAL(event_addPage()));

    menu->addAction(hbTrId(TXT_HOMESCREEN_OPT_REMOVE_PAGE), 

        this, SIGNAL(event_removePage()))->setEnabled(

        HsScene::instance()->activePage()->isRemovable());

    if (HsScene::instance()->isOnline()) {

        menu->addAction(hbTrId(TXT_HOMESCREEN_OPT_HOME_SCREEN_TO_OFFLINE),

            this, SIGNAL(event_toggleConnection()));

    } else {

        menu->addAction(hbTrId(TXT_HOMESCREEN_OPT_HOME_SCREEN_TO_ONLINE),

            this, SIGNAL(event_toggleConnection())); 

    }

#ifndef Q_OS_SYMBIAN

    menu->addAction(hbTrId("txt_homescreen_opt_switch_language"),

        this, SLOT(switchLanguage()));

#endif

    mView->setMenu(menu);

}

/*!

    Connects the waitInput state's mouse event handlers.