/****************************************************************************

**

** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbPlugins module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser General Public

** License version 2.1 as published by the Free Software Foundation and

** appearing in the file LICENSE.LGPL included in the packaging of this file.

** Please review the following information to ensure the GNU Lesser General

** Public License version 2.1 requirements will be met:

** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at developer.feedback@nokia.com.

**

****************************************************************************/

#include "hbfeedbackeffectengine.h"

#include "hbfeedbackeffectutils.h"

#include <hbinstantfeedback.h>

#include <hbcontinuousfeedback.h>

#include <hbwidget.h>

#include <hbabstractitemview.h>

#include <hbabstractviewitem.h>

#include <hblistviewitem.h>

#include <hblistview.h>

#include <hbgridview.h>

#include <hbmainwindow.h>

#include <hbabstractedit.h>

#include "hbmenucontainer_p.h"

#include "hbinputvirtualrocker.h"

#include <hbnamespace_p.h>

/*

    Constructor

*/

HbFeedbackEffectEngine::HbFeedbackEffectEngine() : activelyScrollingItemView(0), previousCursorPosition(0)

{

    instantFeedback = new HbInstantFeedback(HbFeedback::None);

}

/*

    Destructor

*/

HbFeedbackEffectEngine::~HbFeedbackEffectEngine()

{

    if(instantFeedback)

        delete instantFeedback;

    foreach(HbContinuousFeedback *feedback, continuousFeedbacks) {

        feedback->stop();

        delete feedback;

    }

    continuousFeedbacks.clear();

    boundaryWidgets.clear();

}

QString HbFeedbackEffectEngine::effectOverrideProperty(Hb::InstantInteraction interaction)

{

    QString propertyName;

    switch (interaction) {

    case Hb::InstantPressed:

        propertyName = "pressedFeedbackEffect";

        break;

    case Hb::InstantReleased:

        propertyName = "releasedFeedbackEffect";

        break;

    case Hb::InstantClicked:

        propertyName = "clickedFeedbackEffect";

        break;

    case Hb::InstantKeyRepeated:

        propertyName = "keyRepeatedFeedbackEffect";

        break;

    case Hb::InstantLongPressed:

        propertyName = "longPressedFeedbackEffect";

        break;

    case Hb::InstantDraggedOver:

        propertyName = "draggedOverFeedbackEffect";

        break;

    case Hb::InstantFlicked:

        propertyName = "flickedFeedbackEffect";

        break;

    case Hb::InstantPopupOpened:

        propertyName = "popupOpenedFeedbackEffect";

        break;

    case Hb::InstantPopupClosed:

        propertyName = "popupClosedFeedbackEffect";

        break;

    case Hb::InstantBoundaryReached:

        propertyName = "boundaryReachedFeedbackEffect";

        break;

    case Hb::InstantRotated90Degrees:

        propertyName = "rotated90DegreesFeedbackEffect";

        break;

    case Hb::InstantSelectionChanged:

        propertyName = "selectionChangedFeedbackEffect";

        break;

    case Hb::InstantMultitouchActivated:

        propertyName = "multitouchActivatedFeedbackEffect";

        break;

    default:

        propertyName = "defaultFeedbackEffect";

        break;

    }

    return propertyName;

}

QString HbFeedbackEffectEngine::effectOverrideProperty(Hb::ContinuousInteraction interaction)

{

    QString propertyName;

    switch (interaction) {

    case Hb::ContinuousScrolled:

        propertyName = "scrolledFeedbackEffect";

        break;

    case Hb::ContinuousDragged:

        propertyName = "draggedFeedbackEffect";

        break;

    case Hb::ContinuousPinched:

        propertyName = "pinchedFeedbackEffect";

        break;

    case Hb::ContinuousRotated:

        propertyName = "rotatedFeedbackEffect";

        break;

    default:

        propertyName = "defaultFeedbackEffect";

        break;

    }

    return propertyName;

}

QString HbFeedbackEffectEngine::modalitiesOverrideProperty(Hb::InstantInteraction interaction)

{

    QString propertyName;

    switch (interaction) {

    case Hb::InstantPressed:

        propertyName = "pressedFeedbackModalities";

        break;

    case Hb::InstantReleased:

        propertyName = "releasedFeedbackModalities";

        break;

    case Hb::InstantClicked:

        propertyName = "clickedFeedbackModalities";

        break;

    case Hb::InstantKeyRepeated:

        propertyName = "keyRepeatedFeedbackModalities";

        break;

    case Hb::InstantLongPressed:

        propertyName = "longPressedFeedbackModalities";

        break;

    case Hb::InstantDraggedOver:

        propertyName = "draggedOverFeedbackModalities";

        break;

    case Hb::InstantFlicked:

        propertyName = "flickedFeedbackModalities";

        break;

    case Hb::InstantPopupOpened:

        propertyName = "popupOpenedFeedbackModalities";

        break;

    case Hb::InstantPopupClosed:

        propertyName = "popupClosedFeedbackModalities";

        break;

    case Hb::InstantBoundaryReached:

        propertyName = "boundaryReachedFeedbackModalities";

        break;

    case Hb::InstantRotated90Degrees:

        propertyName = "rotated90DegreesFeedbackModalities";

        break;

    case Hb::InstantSelectionChanged:

        propertyName = "selectionChangedFeedbackModalities";

        break;

    case Hb::InstantMultitouchActivated:

        propertyName = "multitouchActivatedFeedbackModalities";

        break;

    default:

        propertyName = "defaultFeedbackModalities";

        break;

    }

    return propertyName;

}

QString HbFeedbackEffectEngine::modalitiesOverrideProperty(Hb::ContinuousInteraction interaction)

{

    QString propertyName;

    switch (interaction) {

    case Hb::ContinuousScrolled:

        propertyName = "scrolledFeedbackModalities";

        break;

    case Hb::ContinuousDragged:

        propertyName = "draggedFeedbackModalities";

        break;

    case Hb::ContinuousPinched:

        propertyName = "pinchedFeedbackModalities";

        break;

    case Hb::ContinuousRotated:

        propertyName = "rotatedFeedbackModalities";

        break;

    default:

        propertyName = "defaultFeedbackModalities";

        break;

    }

    return propertyName;

}

bool HbFeedbackEffectEngine::widgetOverridesEffect(const HbWidget *widget, Hb::InstantInteraction interaction) {

    return (widget == overrider.widget && overrider.overridesEffect && overrider.instantInteraction == interaction);

}

bool HbFeedbackEffectEngine::widgetOverridesEffect(const HbWidget *widget, Hb::ContinuousInteraction interaction) {

    return (widget == overrider.widget && overrider.overridesEffect && overrider.continuousInteraction == interaction);

}

bool HbFeedbackEffectEngine::widgetOverridesModalities(const HbWidget *widget,Hb::InstantInteraction interaction) {

    return (widget == overrider.widget && overrider.overridesModalities && overrider.instantInteraction == interaction);

}

bool HbFeedbackEffectEngine::widgetOverridesModalities(const HbWidget *widget,Hb::ContinuousInteraction interaction) {

    return (widget == overrider.widget && overrider.overridesModalities && overrider.continuousInteraction == interaction);

}

/*

    Called by the feedback manager when an interaction is triggered.

*/

void HbFeedbackEffectEngine::triggered(const HbWidget *widget, Hb::InstantInteraction interaction, Hb::InteractionModifiers modifiers)

{

    overrider.widget = widget;

    overrider.instantInteraction = interaction;

    overrider.overridesEffect = false;

    overrider.overridesModalities = false;

    QString effectProperty = effectOverrideProperty(interaction);

    QVariant veffect = widget->property(effectProperty.toLatin1());

    if(veffect.isValid() && veffect.type() == QVariant::Int) {

        overrider.overridesEffect = true;

        overrider.newInstantEffect = HbFeedback::InstantEffect(veffect.toInt());

    }

    QString modalitiesProperty = modalitiesOverrideProperty(interaction);

    QVariant vmodalities = widget->property(modalitiesProperty.toLatin1());

    if(vmodalities.isValid() && vmodalities.type() == QVariant::Int) {

        overrider.overridesModalities = true;

        overrider.newModalities = HbFeedback::Modalities(vmodalities.toInt());

    }

    if(overrider.overridesEffect && overrider.overridesModalities) {

        // play specified effect via the specified modality

        playInstantFeedback(widget,overrider.newInstantEffect,overrider.newModalities);

    } else {

        // use default values for unspecified effect/modalities

        HbFeedbackEngine::triggered(widget,interaction,modifiers);

    }

}

/*

    Called by the feedback manager when a widget is pressed.

*/

void HbFeedbackEffectEngine::pressed(const HbWidget *widget)

{

    HbFeedback::InstantEffect effect = HbFeedback::None;

    HbFeedback::Modalities modalities = 0;

    Hb::InstantInteraction interaction = Hb::InstantPressed;

    if(widgetOverridesEffect( widget, interaction)) {

        effect = overrider.newInstantEffect;

    } else {

        effect = HbFeedbackEffectUtils::instantOnPress(widget, modifiers());

    }

    if(widgetOverridesModalities(widget,interaction)) {

        modalities = overrider.newModalities ;

    } else  {

        modalities = HbFeedbackEffectUtils::modalities(widget, Hb::InstantPressed, modifiers());

    }

    playInstantFeedback(widget, effect, modalities);

}

/*

    Called by the feedback manager when a widget is released.

*/

void HbFeedbackEffectEngine::released(const HbWidget *widget)

{

    HbFeedback::InstantEffect effect = HbFeedback::None;

    HbFeedback::Modalities modalities = 0;

    Hb::InstantInteraction interaction = Hb::InstantReleased;

    if (continuousFeedbacks.contains(widget)) {

        cancelContinuousFeedback(widget);

    }

    if(widgetOverridesEffect( widget, interaction)) {

        effect = overrider.newInstantEffect;

    } else {

        // use default effect

        // slider-like widgets are a bit special

        if (HbFeedbackEffectUtils::widgetFamily(widget) == HbFeedbackEffectUtils::Slider) {

            effect = HbFeedbackEffectUtils::instantOnRelease(widget, modifiers()) ;

        }

        // lists in arrange mode react on release

        else if (const HbListViewItem *listViewItem = qobject_cast<const HbListViewItem *>(widget)) {

            const HbAbstractItemView* itemView = listViewItem->itemView();

            if (const HbListView * listView = qobject_cast<const HbListView *>(itemView)) {

                if( listView->arrangeMode() ) {

                    effect = HbFeedbackEffectUtils::instantOnRelease(listViewItem, modifiers()) ;

                }

            }

        }

        else if (HbFeedbackEffectUtils::widgetFamily(widget) == HbFeedbackEffectUtils::Editor) {

            effect = HbFeedbackEffectUtils::instantOnRelease(widget, modifiers());

        } else if (widget->type() == Hb::ItemType_ComboBox) {

            effect = HbFeedbackEffectUtils::instantOnRelease(widget, modifiers()) ;

        }

        else if (widget->type() == HbPrivate::ItemType_GroupBoxContentWidget

                 || widget->type() == HbPrivate::ItemType_GroupBoxHeadingWidget

                 || widget->type() == Hb::ItemType_ComboBox) {

            effect = HbFeedbackEffectUtils::instantOnRelease(widget, modifiers());

        }

    }

    if(widgetOverridesModalities(widget,interaction)) {

        modalities = overrider.newModalities ;

    } else  {

        modalities = HbFeedbackEffectUtils::modalities(widget, Hb::InstantReleased, modifiers());

    }

    playInstantFeedback(widget,effect, modalities);

    // normally touch end feedback effect is initiated with a clicked signal

}

/*

    Called by the feedback manager when a long press is detected for a widget.

*/

void HbFeedbackEffectEngine::longPressed(const HbWidget *widget)

{

    HbFeedback::InstantEffect effect = HbFeedback::None;

    HbFeedback::Modalities modalities = 0;

    Hb::InstantInteraction interaction = Hb::InstantLongPressed;

    if(widgetOverridesEffect(widget, interaction)) {

        effect = overrider.newInstantEffect;

    } else {

        effect = HbFeedback::None;

        if (widget->type() == Hb::ItemType_InputButtonGroup && modifiers() & Hb::ModifierInputFunctionButton) {

            effect = HbFeedback::BasicKeypad;

        }

        else if(widget->type() == Hb::ItemType_InputButtonGroup) {

            effect = HbFeedback::SensitiveKeypad;

        }

        else {

            effect = HbFeedback::LongPress;

        }

    }

    if(widgetOverridesModalities(widget,interaction)) {

        modalities = overrider.newModalities ;

    } else  {

        modalities = HbFeedbackEffectUtils::modalities(widget, interaction, modifiers());

    }

    playInstantFeedback(widget, effect, modalities);

}

/*

    Called by the feedback manager when a widget is clicked.

*/

void HbFeedbackEffectEngine::clicked(const HbWidget *widget)

{

    HbFeedback::InstantEffect effect = HbFeedback::None ;

    HbFeedback::Modalities modalities = 0 ;

    Hb::InstantInteraction interaction = Hb::InstantClicked;

    if (continuousFeedbacks.contains(widget)) {

        cancelContinuousFeedback(widget);

    }

        effect = overrider.newInstantEffect;

        effect = HbFeedbackEffectUtils::instantOnRelease(widget, modifiers());

    }

    if(widgetOverridesModalities(widget,interaction)) {

        modalities = overrider.newModalities ;

    } else  {

        modalities = HbFeedbackEffectUtils::modalities(widget, interaction, modifiers());

    }

    playInstantFeedback(widget, effect, modalities);

}

/*

    Called by the feedback manager when keyrepeats are detected for a widget.

*/

void HbFeedbackEffectEngine::keyRepeated(const HbWidget *widget)

{

    HbFeedback::InstantEffect effect = HbFeedback::None ;

    HbFeedback::Modalities modalities = 0 ;

    Hb::InstantInteraction interaction = Hb::InstantKeyRepeated;

    if(widgetOverridesEffect( widget, interaction)) {

        effect = overrider.newInstantEffect;

    } else {

        effect = HbFeedbackEffectUtils::instantOnKeyRepeat(widget, modifiers());

    }

    if(widgetOverridesModalities(widget,interaction)) {

        modalities = overrider.newModalities ;

    } else  {

        modalities = HbFeedbackEffectUtils::modalities(widget, interaction, modifiers());

    }

    playInstantFeedback(widget, effect, modalities);

}

/*

    Called by the feedback manager when a dragged over event is detected for a widget.

*/

void HbFeedbackEffectEngine::draggedOver(const HbWidget *widget)

{

    HbFeedback::InstantEffect effect = HbFeedback::None ;

    HbFeedback::Modalities modalities = 0 ;

    Hb::InstantInteraction interaction = Hb::InstantDraggedOver;

    if(widgetOverridesEffect( widget, interaction)) {

        effect = overrider.newInstantEffect;

    } else {

        // For editor highlighting

        if (const HbAbstractEdit *edit = qobject_cast<const HbAbstractEdit *>(widget)) {

            if (edit->cursorPosition() != previousCursorPosition) {

                effect = HbFeedbackEffectUtils::instantOnEditorHighlight(edit, previousCursorPosition) ;

                previousCursorPosition = edit->cursorPosition();

            }

        }

        else if (const HbInputVirtualRocker *trackPoint = qobject_cast<const HbInputVirtualRocker *>(widget)) {

            if (trackPoint && trackPoint->mainWindow() && trackPoint->mainWindow()->scene() &&

                trackPoint->mainWindow()->scene()->focusItem()) {

                QGraphicsItem* graphicsItem = trackPoint->mainWindow()->scene()->focusItem();

                if (graphicsItem->isWidget()) {

                    if (static_cast<QGraphicsWidget*>(graphicsItem)->inherits("HbAbstractEdit")) {

                        if (HbAbstractEdit* edit = static_cast<HbAbstractEdit*>(graphicsItem)) {

                            if (edit->cursorPosition() != previousCursorPosition) {

                                effect = HbFeedbackEffectUtils::instantOnEditorHighlight(edit, previousCursorPosition);

                                previousCursorPosition = edit->cursorPosition();

                            }

                        }

                    }

                    else if (static_cast<QGraphicsWidget*>(graphicsItem)->inherits("QGraphicsWebView") )

                    {

                        // This takes care of the case when the track point is used on a QGraphicsWebView (for e.g. cWRT)

                        QVariant v;

                        v = graphicsItem->scene()->inputMethodQuery( Qt::ImCursorPosition );

                        if ( v.isValid() && v.canConvert<int>()) {

                            int currentCursorPosition = v.toInt();

                            if (currentCursorPosition != previousCursorPosition) {

                                effect = HbFeedbackEffectUtils::instantOnEditorHighlight(trackPoint, previousCursorPosition);

                                previousCursorPosition = currentCursorPosition;

                            }

                        }

                    }

                }

            }

        } else {

            effect = HbFeedbackEffectUtils::instantOnDrag(widget, modifiers());

        }

    }

    if(widgetOverridesModalities(widget,interaction)) {