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

**

** 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 <hbfeedbackplayer.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() : previousCursorPosition(0)

{

    // initialize

    HbFeedbackPlayer::instance();

}

/*!

    Destructor

*/

HbFeedbackEffectEngine::~HbFeedbackEffectEngine()

{

    if (hbFeedbackPlayer) {

        foreach(int identifier, continuousFeedbacks) {

            hbFeedbackPlayer->cancelContinuousFeedback(identifier);

        }

    }

    continuousFeedbacks.clear();

    boundaryWidgets.clear();

}

/*!

    Called by the feedback manager when an interaction is triggered.

*/

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

{

    HbFeedback::InstantEffect widgetOverride = widget->overrideFeedback(interaction);

    if (widgetOverride != HbFeedback::NoOverride ) {

        playInstantFeedback(widget, widgetOverride);

    } else {

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

    }

}

/*!

    Called by the feedback manager when a widget is pressed.

*/

void HbFeedbackEffectEngine::pressed(const HbWidget *widget)

{

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

    playInstantFeedback(widget, effect);

}

/*!

    Called by the feedback manager when a widget is released.

*/

void HbFeedbackEffectEngine::released(const HbWidget *widget)

{

    if (continuousFeedbacks.contains(widget)) {

        cancelContinuousFeedback(widget);

    }

    // slider-like widgets are a bit special

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

        playInstantFeedback(widget, 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() ) {

                playInstantFeedback(listViewItem,HbFeedbackEffectUtils::instantOnRelease(listViewItem, modifiers()));

            }

        }

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

        playInstantFeedback(widget, HbFeedback::Editor);

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

        playInstantFeedback(widget, HbFeedback::Editor);

    }

    else if (widget->type() == HbPrivate::ItemType_GroupBoxHeadingWidget || widget->type() == Hb::ItemType_ComboBox) {

        playInstantFeedback(widget, HbFeedbackEffectUtils::instantOnRelease(widget, modifiers()));

    }

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

{

    if (widget->type() == Hb::ItemType_InputCharacterButton) {

        playInstantFeedback(widget, HbFeedback::SensitiveKeypad);

    }

}

/*!

    Called by the feedback manager when a widget is clicked.

*/

void HbFeedbackEffectEngine::clicked(const HbWidget *widget)

{

    if (continuousFeedbacks.contains(widget)) {

        cancelContinuousFeedback(widget);

    }

    playInstantFeedback(widget, HbFeedbackEffectUtils::instantOnRelease(widget, modifiers()));

}

/*!

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

*/

void HbFeedbackEffectEngine::keyRepeated(const HbWidget *widget)

{

    playInstantFeedback(widget, HbFeedbackEffectUtils::instantOnKeyRepeat(widget));

}

/*!

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

*/

void HbFeedbackEffectEngine::draggedOver(const HbWidget *widget)

{

    // For editor highlighting

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

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

            playInstantFeedback(widget, 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() && 

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

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

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

                        playInstantFeedback(widget, HbFeedbackEffectUtils::instantOnEditorHighlight(edit, previousCursorPosition));

                        previousCursorPosition = edit->cursorPosition();

                    }

                }

            }

        }

    }

    else {

        playInstantFeedback(widget, HbFeedbackEffectUtils::instantOnDrag(widget, modifiers()));

    }

}

/*!

    Called by the feedback manager when a widget is flicked.

*/

void HbFeedbackEffectEngine::flicked(const HbWidget *widget)

{

    playInstantFeedback(widget, HbFeedback::Flick);

}

/*!

    Called by the feedback manager when a scroll area widget is flicked or dragged and the boundary reached.

*/

void HbFeedbackEffectEngine::boundaryReached(const HbWidget *widget)

{

    boundaryWidgets.append(widget);

}

/*!

    Called by the feedback manager when a rotate gesture is recognized for a widget.

*/

void HbFeedbackEffectEngine::rotated90Degrees(const HbWidget *widget)

{

    playInstantFeedback(widget, HbFeedback::RotateStep);

}

/*!

    Called by the feedback manager when a popup opens.

*/

void HbFeedbackEffectEngine::popupOpened(const HbWidget *widget)

{

    if (HbFeedbackEffectUtils::isFeedbackAllowedForPopup(widget)) {

        playInstantFeedback(widget, HbFeedback::PopupOpen);

    }

}

/*!

    Called by the feedback manager when a popup closes.

*/

void HbFeedbackEffectEngine::popupClosed(const HbWidget *widget)

{

    if (HbFeedbackEffectUtils::isFeedbackAllowedForPopup(widget)) {

        playInstantFeedback(widget, HbFeedback::PopupClose);

    }

}

/*!

    Called by the feedback manager when an item view selection has changed.

*/

void HbFeedbackEffectEngine::selectionChanged(const HbWidget *widget)

{

    playInstantFeedback(widget, HbFeedbackEffectUtils::instantOnSelectionChanged(widget));

}

/*!

    Called by the feedback manager when multitouch is activated.

*/

void HbFeedbackEffectEngine::multitouchActivated(const HbWidget *widget)

{

    playInstantFeedback(widget, HbFeedback::MultitouchActivate);

}

/*!

    Called by the feedback manager when a continuous interaction is triggered.

*/

void HbFeedbackEffectEngine::continuousTriggered(const HbWidget *widget, Hb::ContinuousInteraction interaction, QPointF delta)

{

    bool feedbackPlayed(false);

    switch(HbFeedbackEffectUtils::widgetFamily(widget))

    {

        case HbFeedbackEffectUtils::Slider:

        {

            if (!HbFeedbackEffectUtils::isSliderMoveContinuous(widget)) {

                playInstantFeedback(widget, HbFeedback::SensitiveSlider);

                feedbackPlayed = true;

            }

            break;

        }

        case HbFeedbackEffectUtils::List:

        case HbFeedbackEffectUtils::Grid:

        {

            if (interaction == Hb::ContinuousScrolled) {

                 if (const HbAbstractItemView * itemView = qobject_cast<const HbAbstractItemView *>(widget)) {

                     feedbackPlayed = true;

                     QList<HbAbstractViewItem *> visibleItems = itemView->visibleItems();

                     bool newItemFound(false);

                     int index(-1);

                     QList<int> visibleIndexes;

                     if (widget == activelyScrollingItemView) {

                         foreach (HbAbstractViewItem * item, visibleItems) {

                             index = item->modelIndex().row();

                             if (!oldVisibleIndexes.contains(index)) {

                                 newItemFound = true;

                             }

                             visibleIndexes.append(index);

                         }

                     }

                     if (widget != activelyScrollingItemView){

                         activelyScrollingItemView = widget;

                         newItemFound = false;

                     }

                     oldVisibleIndexes.clear();

                     oldVisibleIndexes = visibleIndexes;

                    if (newItemFound) {

                        const HbListView* listView = qobject_cast<const HbListView*>(widget);

                        if (!(  listView &&

                                listView->arrangeMode() &&

                                listView->draggedItem())){

                            playInstantFeedback(widget, HbFeedback::ItemScroll);

                        }

                    }

                 }

             }

            break;

        }

        default:

        {

            break;

        }

    }

    if (interaction == Hb::ContinuousScrolled) {

        // menu widget does scroll feedback elsewhere

        if (widget->type() == HbPrivate::ItemType_MenuListView) {

            feedbackPlayed = true;

        }

        // generic scroll areas don't emit continuous feedback

        if (const HbScrollArea* scrollArea = qobject_cast<const HbScrollArea *>(widget)) {

            Q_UNUSED(scrollArea)

            feedbackPlayed = true;

        }

    }

    if (!feedbackPlayed) {

        int intensity = HbFeedbackEffectUtils::intensity(widget, interaction, delta);

        // Check if the widget has overriden feedback for this interaction

        HbFeedback::ContinuousEffect widgetOverride = widget->overrideContinuousFeedback(interaction, &intensity) ;

        if (widgetOverride != HbFeedback::NoContinuousOverride) {

            playContinuousFeedback(widget, widgetOverride, intensity);

        } else {

            playContinuousFeedback(widget, HbFeedbackEffectUtils::continuousEffect(widget, interaction), intensity);

        }

    }

}

/*!

    Called by the feedback manager when a continuous interaction is stopped.

*/

void HbFeedbackEffectEngine::continuousStopped(const HbWidget *widget, Hb::ContinuousInteraction interaction)

{

    // determine if instant feedback should be played when a continuous interaction is stopped

    HbFeedback::InstantEffect effect = HbFeedback::None;

    if (boundaryWidgets.contains(widget)) {

        if (interaction == Hb::ContinuousScrolled) {

            effect = HbFeedback::BounceEffect;

        }

        boundaryWidgets.removeAll(widget);

    }

    // stop ongoing continuous and list scrolling feedback effects

    if (continuousFeedbacks.contains(widget)) {

       cancelContinuousFeedback(widget);

    }

    if (activelyScrollingItemView == widget) {

        activelyScrollingItemView = 0;

    }

    playInstantFeedback(widget, effect);

}

/*!

    Plays the instant feedback.

*/

void HbFeedbackEffectEngine::playInstantFeedback(const HbWidget* widget, HbFeedback::InstantEffect effect)

{

    const QGraphicsView* view = widget->mainWindow();

    if (view && HbFeedbackEffectUtils::isFeedbackAllowed(widget)) {

        HbInstantFeedback feedback(effect);

        feedback.setRect(widget, view);

        feedback.setOwningWindow(view);

        if (hbFeedbackPlayer && feedback.isLocated()) {

            hbFeedbackPlayer->playInstantFeedback(feedback);

        }

    }

}

/*!

    Plays the continuous feedback.

*/

void HbFeedbackEffectEngine::playContinuousFeedback(const HbWidget* widget, HbFeedback::ContinuousEffect effect, int intensity)

{

    const QGraphicsView* view = widget->mainWindow();

    if (view && HbFeedbackEffectUtils::isFeedbackAllowed(widget)) {

        HbContinuousFeedback feedback(effect,view);

        feedback.setRect(widget, view);

        feedback.setIntensity(intensity);

        if (hbFeedbackPlayer && feedback.isLocated()) {

            // if continuous feedback is still active and not stopped by continuous feedback timeout

            if (continuousFeedbacks.contains(widget)

                && hbFeedbackPlayer->continuousFeedbackOngoing(continuousFeedbacks.value(widget))) {

                hbFeedbackPlayer->updateContinuousFeedback(continuousFeedbacks.value(widget), feedback);

            } else {

                // if timeout has happened remove the item from the map storing continuous feedback identifiers

                if (continuousFeedbacks.contains(widget)) {

                    continuousFeedbacks.remove(widget);

                }

                // create a new continuous feedback

                continuousFeedbacks.insert(widget, hbFeedbackPlayer->startContinuousFeedback(feedback));

            }

        }

    }

}

/*!

    Cancels the playing of a continuous feedback.

*/

void HbFeedbackEffectEngine::cancelContinuousFeedback(const HbWidget* widget)

{

    if (hbFeedbackPlayer && continuousFeedbacks.contains(widget)) {

        hbFeedbackPlayer->cancelContinuousFeedback(continuousFeedbacks.take(widget));

    }

}