/*

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

#include <QStateMachine>

#include <QState>

#include <QFinalState>

#include <QGraphicsLinearLayout>

#include <QParallelAnimationGroup>

#include <QPropertyAnimation>

#include <QGraphicsDropShadowEffect>

#include <QGraphicsSceneResizeEvent>

#include <QGesture>

#include <QGraphicsScene>

#include <qservicemanager.h>

#include <qservicefilter.h>

#include <qserviceinterfacedescriptor.h>

#include <HbInstantFeedback>

#include "hsdatabase.h"

#include "hsdomainmodeldatastructures.h"

#include "hsscene.h"

#include "hspage.h"

#include "hswidgethost.h"

#include "hswidgetcomponentregistry.h"

#include "hswidgetcomponent.h"

#include "hsconfiguration.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()));

QTM_USE_NAMESPACE

HsWidgetHost::HsWidgetHost(int databaseId, QGraphicsItem *parent)

  : HbWidget(parent),

    mDatabaseId(databaseId),

    mStateMachine(0),

    mWidget(0),

    mPage(0),

    mComponent(0),

    mIsFinishing(false)

{

    setFlag(QGraphicsItem::ItemClipsChildrenToShape);

    setFlag(QGraphicsItem::ItemHasNoContents);

    grabGesture(Qt::TapGesture);

    grabGesture(Qt::TapAndHoldGesture);

    grabGesture(Qt::PanGesture);

    grabGesture(Qt::PinchGesture);

    grabGesture(Qt::SwipeGesture);

    grabGesture(Qt::CustomGesture);

    setupEffects();

    setupStates();

}

HsWidgetHost::~HsWidgetHost()

{

}

HsWidgetHost *HsWidgetHost::createInstance(HsWidgetData &widgetData, 

                                           const QVariantHash &preferences)

{

    HsDatabase *db = HsDatabase::instance();

    if (db->insertWidget(widgetData)) {

        db->setWidgetPreferences(widgetData.id, preferences);

        return new HsWidgetHost(widgetData.id);

    } else {

        return 0;

    }

}

int HsWidgetHost::databaseId() const

{

    return mDatabaseId;

}

bool HsWidgetHost::setPage(HsPage *page)

{

    HsDatabase *db = HsDatabase::instance();

    HsWidgetData data;

    data.id = mDatabaseId;

    if (db->widget(data)) {

        if (!page) {

            data.pageId = -1;

        } else {

            data.pageId = page->databaseId();

        }

        if (!db->updateWidget(data)) {

            return false;

        }

    } else {

        return false;

    }

    mPage = page;

    return true;

}

HsPage *HsWidgetHost::page() const

{

    return mPage;

}

bool HsWidgetHost::loadPresentation()

{

    return loadPresentation(HsScene::orientation());

}

bool HsWidgetHost::loadPresentation(Qt::Orientation orientation)

{

    HsDatabase *db = HsDatabase::instance();

    HsWidgetPresentationData data;

    data.orientation = orientation;

    data.widgetId = mDatabaseId;

    if (!db->widgetPresentation(data)) {

        return false;

    }

    setPos(data.x, data.y);

    setZValue(data.zValue);

    return true;

}

bool HsWidgetHost::savePresentation()

{

    return savePresentation(HsScene::orientation());

}

bool HsWidgetHost::savePresentation(Qt::Orientation orientation)

{

    HsDatabase *db = HsDatabase::instance();

    HsWidgetPresentationData data;

    data.orientation = orientation;

    data.setPos(pos());

    data.zValue = zValue();

    data.widgetId = mDatabaseId;

    return db->setWidgetPresentation(data);

}

bool HsWidgetHost::savePresentation(HsWidgetPresentationData &presentation)

{

    HsDatabase *db = HsDatabase::instance();

    presentation.widgetId = mDatabaseId;

    return db->setWidgetPresentation(presentation);

}

bool HsWidgetHost::getPresentation(HsWidgetPresentationData &presentation)

{

    HsDatabase *db = HsDatabase::instance();

    presentation.widgetId = mDatabaseId;

    return db->widgetPresentation(presentation);

}

bool HsWidgetHost::removePresentation(Qt::Orientation orientation)

{

    HsDatabase *db = HsDatabase::instance();

    return db->deleteWidgetPresentation(mDatabaseId, orientation);

}

void HsWidgetHost::startWidget(bool show)

{

    if (!mStateMachine->isRunning()) {

        mStateMachine->start();

        // This is needed because QStateMachine::start() starts

        // the state machine asynchronously via the eventloop. 

        // Here we want the machine to start synchronously.

        QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);

    }

    if (show) {

        emit event_startAndShow();

    } else {

        emit event_startAndHide();

    }

}

void HsWidgetHost::showWidget()

{

    emit event_show();

}

void HsWidgetHost::hideWidget()

{

    emit event_hide();

}

void HsWidgetHost::setOnline(bool online)

{

    mIsOnlineProperty.write(mWidget, online);

}

void HsWidgetHost::remove()

{

    if (mStateMachine->isRunning()) {

        emit event_remove();

    } else {

        action_remove();

        deleteLater();

    }

}

void HsWidgetHost::close()

{

    if (mStateMachine->isRunning()) {

        emit event_close();

    } else {

        deleteLater();

    }

}

void HsWidgetHost::startDragEffect()

{

    /* TODO: Uncomment after the Qt bug has been fixed.

    QGraphicsDropShadowEffect *effect =

        static_cast<QGraphicsDropShadowEffect *>(graphicsEffect());

    */

    HbInstantFeedback::play(HbFeedback::ItemPick);

    setTransformOriginPoint(rect().center());

    QParallelAnimationGroup *animationGroup = new QParallelAnimationGroup();

    QPropertyAnimation *animation = new QPropertyAnimation(this, "scale");

    animation->setEndValue(1.1);

    animationGroup->addAnimation(animation);

    /* TODO: Uncomment after the Qt bug has been fixed.

    animation = new QPropertyAnimation(effect, "offset");

    animation->setDuration(200);

    animation->setEndValue(QPointF(8 ,8));

    animationGroup->addAnimation(animation);

    */

    animationGroup->start(QAbstractAnimation::DeleteWhenStopped);

}

void HsWidgetHost::startDropEffect()

{

    /* TODO: Uncomment after the Qt bug has been fixed.

    QGraphicsDropShadowEffect *effect =

        static_cast<QGraphicsDropShadowEffect *>(graphicsEffect());

    */

    HbInstantFeedback::play(HbFeedback::ItemDrop);

    QParallelAnimationGroup *animationGroup = new QParallelAnimationGroup;

    QPropertyAnimation *animation = new QPropertyAnimation(this, "scale");

    animation->setEndValue(1);

    animationGroup->addAnimation(animation);

    /* TODO: Uncomment after the Qt bug has been fixed.

    animation = new QPropertyAnimation(effect, "offset");

    animation->setDuration(200);

    animation->setEndValue(QPointF(3, 3));

    animationGroup->addAnimation(animation);

    */

    animationGroup->start(QAbstractAnimation::DeleteWhenStopped);

}

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

{

    if (event->type() == QEvent::GraphicsSceneResize ) {

        QGraphicsSceneResizeEvent *resizeEvent = 

            static_cast<QGraphicsSceneResizeEvent *>(event);

        setNewSize(resizeEvent->newSize());

        emit resized();

    }

    return HbWidget::eventFilter(watched, event);

}