/*
* 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;
        }
        HsGui::instance()->idleWidget()->trashBin()->activate();
    } else {
        HsGui::instance()->idleWidget()->trashBin()->deactivate();
        mTrashBinFeedbackAlreadyPlayed = false;
    }

    if (!HsGui::instance()->idleWidget()->pageIndicator()->isAnimationRunning()) {
        HsGui::instance()->idleWidget()->showTrashBin();
    }
}

/*!
    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()
{
    HsGui::instance()->setupIdleUi();
    connect(HsGui::instance(),SIGNAL(navigateToApplibrary()),SIGNAL(event_applicationLibrary()),Qt::UniqueConnection);

}

/*!
    Sets the idle view's title.
*/
void HsIdleState::action_idle_setupTitle()
{    
    onTitleChanged(mTitleResolver->title());
    connect(mTitleResolver, 
        SIGNAL(titleChanged(QString)), 
        SLOT(onTitleChanged(QString)));
}

/*!
    Updates the idle view's title.
*/
void HsIdleState::onTitleChanged(QString title)
{
    qDebug() << "HsIdleState::onTitleChanged() to title: " << title;
    HsGui::instance()->idleView()->setTitle(title);
}

/*!

*/
void HsIdleState::onAddContentFromContextMenuActionTriggered()
{
    /* include position information in homescreen data,
       which passed around in applib and returned when adding content
    */
    QVariant homescreenData(mPageHotSpot);
    machine()->postEvent(
        HsMenuEventFactory::createOpenAppLibraryEvent(Hs::AddHsMenuMode, homescreenData));
    mPageHotSpot = QPointF();
}

/*!

*/
void HsIdleState::onAddContentFromOptionsMenuActionTriggered()
{
    machine()->postEvent(
         HsMenuEventFactory::createOpenAppLibraryEvent(Hs::AddHsMenuMode));
}

/*!
    Disconnects the idle view's title.
*/
void HsIdleState::action_idle_cleanupTitle()
{
    mTitleResolver->disconnect(this);
}

/*!

*/
void HsIdleState::onPageTapAndHoldFinished(QGestureEvent *event)
{
    mPageHotSpot = qobject_cast<HbTapAndHoldGesture *>(
        event->gesture(Qt::TapAndHoldGesture))->scenePosition();

    mSceneMenu = new HbMenu();
    mSceneMenu->setObjectName("hs_ctx_menu");
    mSceneMenu->setAttribute(Qt::WA_DeleteOnClose);

    HbAction *action = mSceneMenu->addAction(hbTrId(hsLocTextId_ContextMenu_AddContent), this,
	                      SLOT(onAddContentFromContextMenuActionTriggered()));
    action->setObjectName("action_add_content_ctx_menu");

    HsScene *scene = HsScene::instance();
    if (scene->pages().count() < HSCONFIGURATION_GET(maximumPageCount)) {
        action = mSceneMenu->addAction(hbTrId(hsLocTextId_OptionsMenu_AddPage), this, SIGNAL(event_addPage()));
        action->setObjectName("action_add_page_ctx_menu");
    }

    action = mSceneMenu->addAction(hbTrId(hsLocTextId_ContextMenu_ChangeWallpaper), this, SIGNAL(event_selectWallpaper()));
    action->setObjectName("action_change_wallpaper_ctx_menu");
    mSceneMenu->setPreferredPos(mPageHotSpot);
    mSceneMenu->open();
}

void HsIdleState::onPagePanStarted(QGestureEvent *event)
{
    Q_UNUSED(event)
    emit event_moveScene();
}
 
void HsIdleState::onPagePanUpdated(QGestureEvent *event)
{
    HbPanGesture *gesture = qobject_cast<HbPanGesture *>(
        event->gesture(Qt::PanGesture));

    qreal temp = gesture->sceneOffset().x();
    // for small movement take into consideration also previous delta to remove "shaking" effect
    if (abs(mDeltaX - temp) < 10) {
        mDeltaX = 0.9 * temp + 0.1 * mDeltaX;
    } else {
        mDeltaX = temp;
    }

    HsScene *scene = HsScene::instance();
    int bounceEffect = HSCONFIGURATION_GET(bounceEffect);
    qreal x = qBound(pageLayerXPos(scene->pages().count() - 1) - bounceEffect / 2 / HsGui::instance()->idleWidget()->parallaxFactor(),
                     pageLayerXPos(scene->activePageIndex()) + mDeltaX,
                     pageLayerXPos(0) + (bounceEffect / 2 / HsGui::instance()->idleWidget()->parallaxFactor()));

    HsGui::instance()->idleWidget()->setSceneX(x);
}
 
void HsIdleState::onPagePanFinished(QGestureEvent *event)
{
    HbPanGesture *gesture = qobject_cast<HbPanGesture *>(
        event->gesture(Qt::PanGesture));
    mDeltaX = gesture->sceneOffset().x();
    emit event_waitInput();
}

void HsIdleState::onWidgetTapStarted(QPointF point, HsWidgetHost *widget)
{
    HsScene *scene = HsScene::instance();
    HsPage *page = scene->activePage();
    QMetaObject::invokeMethod(page, "updateZValues", Qt::QueuedConnection);
    HbVkbHost::HbVkbStatus status = HbVkbHostBridge::instance()->keypadStatus();
    if ( status == HbVkbHost::HbVkbStatusOpened && !isEditor(point, widget) ) {
        closeVirtualKeyboard();
    }
}
 
void HsIdleState::onWidgetTapAndHoldFinished(QGestureEvent *event, HsWidgetHost *widget)
{
    HsScene *scene = HsScene::instance();
    scene->setActiveWidget(widget);
    
    mWidgetHotSpot = qobject_cast<HbTapAndHoldGesture *>(
        event->gesture(Qt::TapAndHoldGesture))->scenePosition();
    mWidgetHotSpotOffset = mWidgetHotSpot - widget->visual()->pos();
    
    emit event_moveWidget();
}
 
void HsIdleState::onWidgetMoveUpdated(const QPointF &scenePos, HsWidgetHost *widget)
{
    /* If move was interrupted by a popup and and we plan to move second widget.
     * Then the erroneous first widget instance is received here, as there is no cancel gesture
       -> we need to use active widget that was saved during TapAndHold.
    */
    widget = HsScene::instance()->activeWidget();

    QRectF widgetRect = widget->visual()->geometry();

    // Move widget to updated position.
    mWidgetHotSpot = scenePos;
    widgetRect.moveTopLeft(mWidgetHotSpot - mWidgetHotSpotOffset);

    // When moving widget can go over the pages left border.
    qreal lowerBoundX = -widgetRect.width();

    // When moving widget can go over the pages right border.
    QRectF pageRect = HsGui::instance()->idleView()->rect();
    qreal upperBoundX = pageRect.width();

    // When moving widget can go under the chrome at the pages upper border.
    // Notice that chrome height is 64 pixels.
    qreal lowerBoundY = qreal(64) - widgetRect.height();

    // When moving widget can go over the pages down border.
    qreal upperBoundY = pageRect.height();

    qreal widgetX = qBound(lowerBoundX, widgetRect.x(), upperBoundX);
    qreal widgetY = qBound(lowerBoundY, widgetRect.y(), upperBoundY);

    // for small movement take into consideration also previous value to remove "shaking" effect
    if ((abs(mWidgetX - widgetX) < 10) && (abs(mWidgetY - widgetY) < 10)) {
        mWidgetX = 0.9 * widgetX + 0.1 * mWidgetX;
        mWidgetY = 0.9 * widgetY + 0.1 * mWidgetY;
    } else {
        mWidgetX = widgetX;
        mWidgetY = widgetY;
    }

    // If using ItemClipsChildrenToShape-flag in widgethost then
    // setPos does not update position here, however setGeometry does it, QT bug?
    widget->visual()->setGeometry(mWidgetX, mWidgetY, widgetRect.width(), widgetRect.height());
    
    if (HSCONFIGURATION_GET(isSnapEnabled)) {
        mSnapResult = HsWidgetPositioningOnWidgetMove::instance()->run(widget->visual()->sceneBoundingRect());

        bool isTrashbinOpen = HsGui::instance()->idleWidget()->trashBin()->isUnderMouse();

        if (HSCONFIGURATION_GET(isSnapEffectsEnabled)) {
            if (mSnapResult.hasHorizontalSnap && !isTrashbinOpen) {
                showVerticalLine();
            } else {
                hideVerticalLine();
            }
            if (mSnapResult.hasVerticalSnap && !isTrashbinOpen) {
                showHorizontalLine();
            } else {
                hideHorizontalLine();
            }
        }

        mPreviousSnapResult = mSnapResult;
    }

    // Handle effects:
    // User is indicated by a tactile feedback if he/she is trying to move
    // widget over the first or the last page.
    HsScene *scene = HsScene::instance();
    HsPage *page = scene->activePage();
    int bounceFeedbackEffectDistance = HSCONFIGURATION_GET(bounceFeedbackEffectDistance);
    if( (page == scene->pages().first() && mWidgetHotSpot.x() < bounceFeedbackEffectDistance ) ||
        (page == scene->pages().last() && scene->pages().count() == HSCONFIGURATION_GET(maximumPageCount)
         && mWidgetHotSpot.x() > pageRect.width() - bounceFeedbackEffectDistance)) {
             HbInstantFeedback::play(HSCONFIGURATION_GET(widgetMoveBlockedFeedbackEffect));
            // TODO: use code below when Orbit has updated ContinuousFeedback API
            //if (!mContinuousFeedback->isPlaying()) {
            //    mContinuousFeedback->play();
            //}
        } else /*if (mContinuousFeedback->isPlaying())*/ {
            //mContinuousFeedback->stop();
        }

    updateZoneAnimation();
    showTrashBin();
}
 
void HsIdleState::onWidgetMoveFinished(const QPointF &scenePos, HsWidgetHost *widget)
{
    Q_UNUSED(scenePos)
    Q_UNUSED(widget)
    emit event_MoveWidgetDelete();
}

/*!
    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->startWidget();
    }

    page->layoutNewWidgets();

}

/*!
    Moves the scene and page layers so that the active
    page is shown.
*/
void HsIdleState::action_idle_showActivePage()
{   
    HsScene *scene = HsScene::instance();
    QApplication::instance()->installEventFilter(scene);
    scene->activePage()->showWidgets();
    qreal x = pageLayerXPos(scene->activePageIndex());
    HsGui::instance()->idleWidget()->setSceneX(x);
}

/*!
    Connects the orientation change event handler.
*/
void HsIdleState::action_idle_connectOrientationChangeEventHandler()
{
    connect(HsGui::instance(),
        SIGNAL(orientationChanged(Qt::Orientation)),
        SLOT(action_idle_orientationChanged()));
}

void HsIdleState::action_idle_orientationChanged()
{
    stopPageChangeAnimations();
    action_idle_showActivePage();
}

/*!
    Installs the event filter.
*/
void HsIdleState::action_idle_installEventFilter()
{
    QCoreApplication::instance()->installEventFilter(this);
}

/*!
    Publishes the idle key
*/
void HsIdleState::action_waitInput_publishIdleKey()
{
#ifdef Q_OS_SYMBIAN
    qDebug() << "HsIdleState::action_waitInput_publishIdleKey";
    if (!mSettingsMgr){
        // All done, let others know it too
        qDebug() << "Setting the idle key";
        mSettingsMgr = new XQSettingsManager(this);
        XQPublishAndSubscribeSettingsKey key(KPSUidStartup.iUid, KPSIdlePhase1Ok);
        mSettingsMgr->writeItemValue(key, EIdlePhase1Ok);

        // Done, we can disconnect this signal.
        disconnect(sender(), SIGNAL(entered()), this, SLOT(action_waitInput_publishIdleKey()));
    }
#endif
}

/*!
    Cleans up the idle view.
*/
void HsIdleState::action_idle_cleanupView()
{
    HsScene *scene = HsScene::instance();
    QApplication::instance()->removeEventFilter(scene);
    scene->activePage()->hideWidgets();
    
    HsGui::instance()->disconnect(this,SIGNAL(event_applicationLibrary()));
    //Close options menu on view change
    HsGui::instance()->idleView()->setMenu(NULL);

    //Close context menu on view change
    if (mSceneMenu) {
        mSceneMenu->close();
    }
}

/*!
    Disconnects the orientation change event handler.
*/
void HsIdleState::action_idle_disconnectOrientationChangeEventHandler()
{
    disconnect(HsGui::instance(),
        SIGNAL(orientationChanged(Qt::Orientation)),
        this, SLOT(action_idle_orientationChanged()));
}

/*!
    Disconnects the event filter.
*/
void HsIdleState::action_idle_uninstallEventFilter()
{
    QCoreApplication::instance()->removeEventFilter(this);
}

/*!
    Updates the options menu content.
*/
void HsIdleState::action_waitInput_updateOptionsMenu()
{
    HsScene *scene = HsScene::instance();

    HbMenu *menu = new HbMenu();
    menu->setObjectName("hs_menu");
    // Task switcher
    menu->addAction(hbTrId(hsLocTextId_OptionsMenu_TaskSwitcher),
        this, SLOT(openTaskSwitcher()));
    
    // Add content
    menu->addAction(hbTrId(hsLocTextId_ContextMenu_AddContent),
        this, SLOT(onAddContentFromOptionsMenuActionTriggered()));
    // Add page
    if (scene->pages().count() < HSCONFIGURATION_GET(maximumPageCount)) {
        menu->addAction(hbTrId(hsLocTextId_OptionsMenu_AddPage),
            this, SIGNAL(event_addPage()));
    
    }

    // Change wallpaper
    menu->addAction(hbTrId(hsLocTextId_ContextMenu_ChangeWallpaper),
        this, SIGNAL(event_selectWallpaper()));
    
    // Remove page
    if (scene->activePage()->isRemovable()) {
        menu->addAction(hbTrId(hsLocTextId_OptionsMenu_RemovePage),
            this, SIGNAL(event_preRemovePage()));
    }

    // Online / Offline
    if (scene->isOnline()) {
        menu->addAction(hbTrId(hsLocTextId_OptionsMenu_HsToOffline),
            this, SIGNAL(event_toggleConnection()));
    } else {
        menu->addAction(hbTrId(hsLocTextId_OptionsMenu_HsToOnline),
            this, SIGNAL(event_toggleConnection()));
    }

    HsGui::instance()->idleView()->setMenu(menu);
}

void HsIdleState::action_waitInput_connectGestureHandlers()
{
    HsScene *scene = HsScene::instance();

    connect(scene, 
        SIGNAL(pageTapFinished(QGestureEvent*)), 
        SLOT(closeVirtualKeyboard()),
        Qt::UniqueConnection);
    connect(scene, 
        SIGNAL(pagePanStarted(QGestureEvent*)), 
        SLOT(closeVirtualKeyboard()),
        Qt::UniqueConnection);

    connect(scene, 
        SIGNAL(pageTapAndHoldFinished(QGestureEvent*)), 
        SLOT(onPageTapAndHoldFinished(QGestureEvent*)),
        Qt::UniqueConnection);

    connect(scene,
        SIGNAL(pagePanStarted(QGestureEvent*)),
        SLOT(onPagePanStarted(QGestureEvent*)),
        Qt::UniqueConnection);

    connect(scene, 
        SIGNAL(widgetTapStarted(QPointF, HsWidgetHost*)), 
        SLOT(onWidgetTapStarted(QPointF, HsWidgetHost*)),
        Qt::UniqueConnection);
    
    connect(scene, 
        SIGNAL(widgetTapAndHoldFinished(QGestureEvent*,HsWidgetHost*)), 
        SLOT(onWidgetTapAndHoldFinished(QGestureEvent*,HsWidgetHost*)),
        Qt::UniqueConnection);
}

void HsIdleState::action_waitInput_disconnectGestureHandlers()
{
    HsScene *scene = HsScene::instance();
    scene->disconnect(this);
}

/*!
    Resets new widget layout.
*/
void HsIdleState::action_waitInput_resetNewWidgets()
{
    HsScene::instance()->activePage()->resetNewWidgets();
}

/*!
    Reparents the active widget to the control layer.
*/
void HsIdleState::action_moveWidget_reparentToControlLayer()
{
    HsWidgetHost *widget = HsScene::instance()->activeWidget();
    Q_ASSERT(widget);
    widget->visual()->setParentItem(HsGui::instance()->idleWidget()->controlLayer());

    HsGui::instance()->idleWidget()->showTrashBin();
}

/*!
    Starts the widget drag effect.
*/
void HsIdleState::action_moveWidget_startWidgetDragEffect()
{
    HsWidgetHost *widget = HsScene::instance()->activeWidget();
    Q_ASSERT(widget);
    widget->startDragEffect();
    mAllowZoneAnimation = true;
}

/*!
*/
void HsIdleState::action_moveWidget_connectGestureHandlers()
{
    HsScene *scene = HsScene::instance();
        
    connect(scene, 
        SIGNAL(widgetMoveUpdated(const QPointF&,HsWidgetHost*)), 
        SLOT(onWidgetMoveUpdated(const QPointF&,HsWidgetHost*)),
        Qt::UniqueConnection);
    
    connect(scene, 
        SIGNAL(widgetMoveFinished(const QPointF&,HsWidgetHost*)), 
        SLOT(onWidgetMoveFinished(const QPointF&,HsWidgetHost*)),
        Qt::UniqueConnection);
}

/*!
    Connects the SIGNAL for changing the orientation for moveWidget state 
    to update the snapping algorithm accordingly.
*/
void HsIdleState::action_moveWidget_connectOrientationChangeEventHandler()
{
    connect(HsGui::instance(),
        SIGNAL(orientationChanged(Qt::Orientation)),
        SLOT(updateSnapAlgorithmParameters()));
}

/*!
    Initializes the presentation to the snapping algorithm
    Connects the SIGNAL for changing the presentation on active page changed
    Connects the timer for showing the snap lines
*/
void HsIdleState::action_moveWidget_setWidgetSnap()
{
    if (HSCONFIGURATION_GET(isSnapEnabled)) {

        QVariantHash snapConfiguration;
        snapConfiguration[Hs::snapEnabled] = QString::number(HSCONFIGURATION_GET(isSnapEnabled));
        snapConfiguration[Hs::snapForce] = QString::number(HSCONFIGURATION_GET(snapForce));
        snapConfiguration[Hs::snapGap] = QString::number(HSCONFIGURATION_GET(snapGap));
        HsWidgetPositioningOnWidgetMove::instance()->setConfiguration(snapConfiguration);

        updatePagePresentationToWidgetSnap();

        connect(HsScene::instance(), SIGNAL(activePageChanged()),
            SLOT(updateSnapAlgorithmParameters()));

        if (HSCONFIGURATION_GET(isSnapEffectsEnabled)) {
            mVerticalSnapLineTimer.setInterval(HSCONFIGURATION_GET(snapTimeout));
            mHorizontalSnapLineTimer.setInterval(HSCONFIGURATION_GET(snapTimeout));

            connect(&mVerticalSnapLineTimer, SIGNAL(timeout()),
                SLOT(onVerticalSnapLineTimerTimeout()));
            connect(&mHorizontalSnapLineTimer, SIGNAL(timeout()),
                SLOT(onHorizontalSnapLineTimerTimeout()));

        }
    }
}

/*!
    Create the list of inactive rectangles on the page.
*/
QList<QRectF> HsIdleState::createInactiveWidgetRects()
{
    HsScene *scene = HsScene::instance();
    HsPage *activePage = scene->activePage();
    HsWidgetHost *activeWidget = scene->activeWidget();

    QList<QRectF> incativeWidgetRects;

    foreach (HsWidgetHost* widget, activePage->widgets()) {
        //If the above function returns the active widget, skip over it as widget and mMovingRect represent same widget.
        if (widget == activeWidget) {
           continue;
        }
        QRectF widgetRect = widget->visual()->geometry();
        incativeWidgetRects.append(widgetRect);
    }
    return incativeWidgetRects;
}

/*!
    Reparents the active widget to the active page.
*/
void HsIdleState::action_moveWidget_reparentToPage()
{
    HsPropertyAnimationWrapper *pageCrawlingAnimation =
        HsGui::instance()->pageCrawlingAnimation();
    if (pageCrawlingAnimation->isRunning()&& 
        pageCrawlingAnimation->isForward()) {
        pageCrawlingAnimation->setDuration(HSCONFIGURATION_GET(pageChangeZoneReverseAnimationDuration));
        pageCrawlingAnimation->setBackward();
    }

    HsScene *scene = HsScene::instance();
    HsPage *page = scene->activePage();
    HsWidgetHost *widget = scene->activeWidget();
    
    if (widget) {
        if (widget->page() != page) {
            widget->page()->removeWidget(widget);
            page->addExistingWidget(widget);
            if (HsGui::instance()->orientation() == Qt::Horizontal) {
                widget->removePresentation(Qt::Vertical);
            } else {
                widget->removePresentation(Qt::Horizontal);
            }
        }

        //Set the snap position of the widget and save the position
        QRectF widgetRect = widget->visual()->geometry();
        if (mSnapResult.hasHorizontalSnap) {
            widgetRect.moveLeft(mSnapResult.horizontalSnapPosition);
        }
        if (mSnapResult.hasVerticalSnap) {
            widgetRect.moveTop(mSnapResult.verticalSnapPosition);
        }

        QPointF adjustedWidgetPosition = page->adjustedWidgetPosition(widgetRect);
        widget->visual()->setPos(adjustedWidgetPosition);

        widget->savePresentation();
        page->updateZValues();

        widget->visual()->setParentItem(HsScene::instance()->activePage()->visual());
    }
    HsGui::instance()->idleWidget()->showPageIndicator();
    
    emit event_waitInput();
}


/*!
    Reparents the active widget to the active page.
*/
void HsIdleState::action_moveWidgetDelete_deleteWidgetOnTrashbin()
{
    HsScene *scene = HsScene::instance();
    HsWidgetHost *widget = scene->activeWidget();

    if ( widget && HsGui::instance()->idleWidget()->trashBin()->isUnderMouse() ) {
        HbInstantFeedback::play(HSCONFIGURATION_GET(widgetDropToTrashbinFeedbackEffect));
        widget->page()->removeWidget(widget);
        widget->remove();
        scene->setActiveWidget(0);
    }
}

/*!
    Starts the widget drop effect.
*/
void HsIdleState::action_moveWidget_startWidgetDropEffect()
{
    HsWidgetHost *widget = HsScene::instance()->activeWidget();
    if (widget) {
        widget->startDropEffect();
    }
}

/*!
    Set interactive to false.
*/
void HsIdleState::action_moveWidget_disableInteractive()
{
    HsWidgetHost *widget = HsScene::instance()->activeWidget();
    if (widget) {
        HsPropertyAnimationWrapper *animation = HsGui::instance()->pageChangeAnimation();
        if (animation->isRunning()) {
            hbInstance->allMainWindows().first()->setInteractive(false);
        }
        HsScene::instance()->setActiveWidget(0);
    }
}

/*!
    Disconnects gesture handlers
*/
void HsIdleState::action_moveWidget_disconnectGestureHandlers()
{
    HsScene *scene = HsScene::instance();
    scene->disconnect(this);
}

/*!
    Disconnects orientation change on moveWidget state
*/
void HsIdleState::action_moveWidget_disconnectOrientationChangeEventHandler()
{
    disconnect(HsGui::instance(),
        SIGNAL(orientationChanged(Qt::Orientation)),
        this, SLOT(updateSnapAlgorithmParameters()));

}

/*!
    Resets the snap position
    Disconnect the Active Page Changed SIGNAL
    Disconnects the timers to show snap lines
*/
void HsIdleState::action_moveWidget_deleteWidgetSnap()
{
    if (HSCONFIGURATION_GET(isSnapEnabled)) {
        resetSnapPosition();

        disconnect(HsScene::instance(), SIGNAL(activePageChanged()),
                    this, SLOT(updateSnapAlgorithmParameters()));

        if (HSCONFIGURATION_GET(isSnapEffectsEnabled)) {
            disconnect(&mVerticalSnapLineTimer, SIGNAL(timeout()),
                this, SLOT(onVerticalSnapLineTimerTimeout()));
            disconnect(&mHorizontalSnapLineTimer, SIGNAL(timeout()),
                this, SLOT(onHorizontalSnapLineTimerTimeout()));
        }
    }
}

/*!
    Prevents page change zone animation.
*/
void HsIdleState::action_moveWidget_preventZoneAnimation()
{
    mAllowZoneAnimation = false;
}

void HsIdleState::action_moveScene_connectGestureHandlers()
{
    HsScene *scene = HsScene::instance();

    connect(scene,
        SIGNAL(pagePanUpdated(QGestureEvent*)),
        SLOT(onPagePanUpdated(QGestureEvent*)),
        Qt::UniqueConnection);

    connect(scene,
        SIGNAL(pagePanFinished(QGestureEvent*)),
        SLOT(onPagePanFinished(QGestureEvent*)),
        Qt::UniqueConnection);
}

/*!
    Moves to the nearest page.
*/
void HsIdleState::action_moveScene_moveToNearestPage()
{
    QList<HsPage *> pages = HsScene::instance()->pages();
    QSizeF pageSize = pages.first()->visual()->size();

    int pageIndex = HsScene::instance()->activePageIndex();

    if (mDeltaX < -HSCONFIGURATION_GET(pageChangePanDistance)) {
        pageIndex = qMin(pageIndex + 1, pages.count() - 1);
    } else if (HSCONFIGURATION_GET(pageChangePanDistance) < mDeltaX) {
        pageIndex = qMax(pageIndex - 1, 0);
    }

    HsScene::instance()->setActivePageIndex(pageIndex);

    HsPage *page = HsScene::instance()->activePage();
    if (page) {
        QList<HsWidgetHost *> widgets = page->newWidgets();
        if (!widgets.isEmpty()) {
            foreach (HsWidgetHost *widget, widgets) {
                widget->startWidget();
            }
        }
    page->layoutNewWidgets();
    }

    startPageChangeAnimation(pageIndex, HSCONFIGURATION_GET(pageChangeAnimationDuration));
}

void HsIdleState::action_moveScene_disconnectGestureHandlers()
{
    HsScene *scene = HsScene::instance();
    scene->disconnect(this);
}

/*!
    Adds a new page to the scene.
*/
void HsIdleState::action_addPage_addPage()
{
    HsScene *scene = HsScene::instance();
	int pageIndex = scene->activePageIndex() + 1;
    addPageToScene(pageIndex);
    scene->setActivePageIndex(pageIndex);
    startPageChangeAnimation(pageIndex, HSCONFIGURATION_GET(newPageAddedAnimationDuration));
    HsGui::instance()->idleWidget()->pageIndicator()->addItem(pageIndex);
    HsGui::instance()->idleWidget()->showPageIndicator();
}

/*!
    Displays a confirmation query before page is removed if there are widgets on page 
*/
void HsIdleState::action_preRemovePage_showQuery()
{
    HsScene *scene = HsScene::instance();
    HsPage *page = scene->activePage();

    if (!page->widgets().isEmpty()) {
        if (!mMessageBoxWrapper) {
            mMessageBoxWrapper = new HsMessageBoxWrapper(this);
            mMessageBoxWrapper->setHeader(hbTrId(hsLocTextId_Title_RemovePage));
            mMessageBoxWrapper->setQueryText(hbTrId(hsLocTextId_Confirmation_RemovePage));
            connect(mMessageBoxWrapper,SIGNAL(accepted()),SIGNAL(event_removePage())); 
            connect(mMessageBoxWrapper,SIGNAL(rejected()),SIGNAL(event_waitInput())); 
        }
        mMessageBoxWrapper->show();
    } else {
        // Empty page can be removed without confirmation
        emit event_removePage();
    }
}

/*!
    Make sure confirmation query gets closed if user exits preRemovePage state e.g. by pressing application key
*/
void HsIdleState::action_preRemovePage_exit()
{
    if (mMessageBoxWrapper) {
        mMessageBoxWrapper->close();
    }
}

/*!
    Start remove page animation.
*/
void HsIdleState::action_removePage_startRemovePageAnimation()
{
    HsScene *scene = HsScene::instance();
   
    int pageToRemoveIndex = scene->activePageIndex();
    bool isLastPage(scene->activePage() == scene->pages().last());
    
    int nextPageIndex(pageToRemoveIndex);
   
    if (isLastPage) {
        nextPageIndex--; 
    } else {
        nextPageIndex++;
    }

    HsPropertyAnimationWrapper *animation = HsGui::instance()->pageChangeAnimation();
    if (animation->isRunning()) {
        animation->stop();
    }
    animation->disconnect(this);
    connect(animation,
            SIGNAL(finished()),
            SIGNAL(event_waitInput()), 
            Qt::UniqueConnection);
    animation->setEndValue(pageLayerXPos(nextPageIndex));
    animation->setDuration(HSCONFIGURATION_GET(pageRemovedAnimationDuration));
   
    animation->start();
    
    HbInstantFeedback::play(HSCONFIGURATION_GET(pageChangeFeedbackEffect));
    
}

/*!
    Removes an existing page from the scene.
*/
void HsIdleState::action_removePage_removePage()
{
    HsIdleWidget *idleWidget = HsGui::instance()->idleWidget();
    HsPropertyAnimationWrapper *animation = HsGui::instance()->pageChangeAnimation();
    HsScene *scene = HsScene::instance();
    HsPage *pageToRemove = scene->activePage();

    if (animation->isRunning()) {
        animation->stop();
    }
    // remove from ui
    idleWidget->removePage(pageToRemove->pageIndex());
    idleWidget->showPageIndicator();
    // update data model
    scene->removePage(pageToRemove);
    // Take new active page (previous was removed) and move scene to right position
    qreal x = pageLayerXPos(scene->activePageIndex());
    idleWidget->setSceneX(x);
    // delete it   
    pageToRemove->deleteLater();
   
}
/*!
    Toggles the homescreen online/offline state.
*/
void HsIdleState::action_toggleConnection_toggleConnection()
{
    HsScene *scene = HsScene::instance();
    scene->setOnline(!scene->isOnline());
}

#ifdef COVERAGE_MEASUREMENT
#pragma CTC SKIP
#endif //COVERAGE_MEASUREMENT

/*!
 Open task switcher.
 \retval true if operation is successful.
 */
bool HsIdleState::openTaskSwitcher()
{
    return HsMenuService::launchTaskSwitcher();
}
#ifdef COVERAGE_MEASUREMENT
#pragma CTC ENDSKIP
#endif //COVERAGE_MEASUREMENT

/*!
    Page change zone animation has been finished.
 */
void HsIdleState::zoneAnimationFinished()
{
    HsScene *scene = HsScene::instance();
    int pageIndex = scene->activePageIndex();
    HsGui *gui(HsGui::instance());
    if (gui->pageCrawlingAnimation()->isForward()) {
        if (isInLeftPageChangeZone() &&
            0 < pageIndex) {
            --pageIndex;
        } else if (isInRightPageChangeZone() &&
                   pageIndex < scene->pages().count()) {
            ++pageIndex;
        }
        if (pageIndex == scene->pages().count()) {
            if (pageIndex < HSCONFIGURATION_GET(maximumPageCount)) {
                addPageToScene(pageIndex);
                gui->idleWidget()->showPageIndicator();
                gui->idleWidget()->pageIndicator()->addItem(pageIndex);
            }
        }
        scene->setActivePageIndex(pageIndex);
        startPageChangeAnimation(pageIndex, HSCONFIGURATION_GET(pageChangeAnimationDuration));
    } else {
        scene->setActivePageIndex(pageIndex);
        gui->idleWidget()->setActivePage(pageIndex);
    }
}

/*!
    Page change animation has been finished.
 */
void HsIdleState::pageChangeAnimationFinished()
{
    hbInstance->allMainWindows().first()->setInteractive(true);
    updateZoneAnimation();
}


/*!
    Provides the page presentation to the Widget Snap algorithm
*/
void HsIdleState::updatePagePresentationToWidgetSnap()
{
    QRectF containerRect = HsScene::instance()->activePage()->contentGeometry();
    HsWidgetHost *activeWidget = HsScene::instance()->activeWidget();
    HsWidgetPositioningOnWidgetMove::instance()->setPagePresentation(
        containerRect, createInactiveWidgetRects(), activeWidget->visual()->geometry());
}

/*!
    Reset Snap position, hide the snap lines
*/
void HsIdleState::resetSnapPosition()
{
    mSnapResult = HsWidgetPositioningOnWidgetMove::Result();
    mPreviousSnapResult = HsWidgetPositioningOnWidgetMove::Result();
    hideVerticalLine();
    hideHorizontalLine();
}

/*!
    Show the Vertical line for Snap guidance
*/
void HsIdleState::showVerticalLine()
{
    if (mPreviousSnapResult.verticalSnapLine.x1() != mSnapResult.verticalSnapLine.x1()) {
        hideVerticalLine();
        mVerticalSnapLineTimer.start();
    }
    else {
        //As the Vertical Line position is at the same place,
        //the timer was started when vertical line positions were at different locations
        //the line will be shown when the timer expires.
        //If timer has already expired, just show the line, which is redrawn to new geometry.
        if (!mVerticalSnapLineTimer.isActive()) {
            HsGui::instance()->idleWidget()->showVerticalSnapLine(mSnapResult.verticalSnapLine);
        }
    }
}

/*!
    Timer for showing the Vertical line expires
*/
void HsIdleState::onVerticalSnapLineTimerTimeout()
{
    HsGui::instance()->idleWidget()->showVerticalSnapLine(mSnapResult.verticalSnapLine);
}

/*!
    Hide the Vertical line for Snap guidance
*/
void HsIdleState::hideVerticalLine()
{
    HsGui::instance()->idleWidget()->hideVerticalSnapLine();
    mVerticalSnapLineTimer.stop();
}

/*!
    Show the Horizontal line for Snap guidance
*/
void HsIdleState::showHorizontalLine()
{
    if (mPreviousSnapResult.horizontalSnapLine.y1() != mSnapResult.horizontalSnapLine.y1()) {
        hideHorizontalLine();
        mHorizontalSnapLineTimer.start();
    }
    else {
        if (!mHorizontalSnapLineTimer.isActive()) {
            HsGui::instance()->idleWidget()->showHorizontalSnapLine(mSnapResult.horizontalSnapLine);
        }
    }
}

/*!
    Timer for showing the Horizontal line expires
*/
void HsIdleState::onHorizontalSnapLineTimerTimeout()
{
    HsGui::instance()->idleWidget()->showHorizontalSnapLine(mSnapResult.horizontalSnapLine);
}

/*!
    Hide the Horizontal line for Snap guidance
*/
void HsIdleState::hideHorizontalLine()
{
    HsGui::instance()->idleWidget()->hideHorizontalSnapLine();
    mHorizontalSnapLineTimer.stop();
}

/*!
    Handles updating the Snap algorithm with page presentation on page change
*/
void HsIdleState::updateSnapAlgorithmParameters()
{
    updatePagePresentationToWidgetSnap();
    resetSnapPosition();
}

/*!
    Closes virtual keyboard
*/
void HsIdleState::closeVirtualKeyboard()
{
    HbVkbHost::HbVkbStatus status = HbVkbHostBridge::instance()->keypadStatus();
    if (status == HbVkbHost::HbVkbStatusOpened ) {
        QInputContext *ic = qApp->inputContext();
        if (ic) {
            QEvent *event = new QEvent(QEvent::CloseSoftwareInputPanel);
            ic->filterEvent(event);
            delete event;
        }
    }
}

/*!
    Returns true if \a widget has editor field under \a point.
*/
bool HsIdleState::isEditor(const QPointF &point, HsWidgetHost *widget)
{
    bool isWidgetEditor = false;
    QList<QGraphicsItem *> items;
    if ( widget->visual()->scene() ) {
        items = widget->visual()->scene()->items(point);
        }
    int count = items.count();
    for (int i=0; i<count && !isWidgetEditor; i++ ) {
        QGraphicsItem *item = items.at(i);
        if (item->isWidget()) {
            isWidgetEditor = HbInputFocusObject::isEditor(item->toGraphicsObject()) && 
                qobject_cast<QGraphicsWidget *>(widget->visual()->widget())->isAncestorOf(item);
        }
    }
    return isWidgetEditor;
}

/*!
    Stops page change and page crawling animations.
*/
void HsIdleState::stopPageChangeAnimations()
{
    HsPropertyAnimationWrapper *animation = HsGui::instance()->pageChangeAnimation();
    if (animation->isRunning()) {
        animation->stop();
        hbInstance->allMainWindows().first()->setInteractive(true);
    }        
    animation->disconnect(this);
    
    HsPropertyAnimationWrapper *pageCrawlingAnimation = 
        HsGui::instance()->pageCrawlingAnimation();

    if (pageCrawlingAnimation->isRunning()) {
        pageCrawlingAnimation->stop();
    }
}

