/****************************************************************************
**
** 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 HbFeedback 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 "hbcontinuousfeedback.h"
#include "hbfeedbackplayer_p.h"

#include <QGraphicsItem>
#include <QGraphicsView>
#include <QDebug>

class HbContinuousFeedbackPrivate
{
public:
    HbContinuousFeedbackPrivate() : cEffect(HbFeedback::ContinuousSmooth),
        cFeedbackId(-1),
        cTimeout(HbFeedback::StandardFeedbackTimeout),
        cIntensity(HbFeedback::IntensityFull)
    {
    };

    ~HbContinuousFeedbackPrivate() {};

public:
    HbFeedback::ContinuousEffect cEffect;
    int cFeedbackId;
    int cTimeout;
    int cIntensity;
};

/*!
    @beta
    @hbfeedback

    \class HbContinuousFeedback

    \brief The HbContinuousFeedback class is used for setting, playing and
    stopping continuous feedback effects from custom widgets.

    Continuous feedback is used for feedback effects that last as long as the user
    is touching the screen, for example when dragging a slider handle.
    You can use the class HbContinuousFeedback to ask the feedback framework
    to play a selected continuous effect, by giving HbContinuousFeedback
    a parameter of type HbFeedback::ContinuousEffect. The type
    HbFeedback::ContinuousEffect has a number of predefined continuous effects,
    for example \link HbFeedback::ContinuousSlider ContinuousSlider \endlink and
    \link HbFeedback::ContinuousPinch ContinuousPinch\endlink.
    The effect \link HbFeedback::ContinuousSmooth ContinuousSmooth \endlink
    can be used for a generic continuous feedback. 
    
    Continuous feedback effects need to be started and stopped using the
    HbContinuousFeedback methods play() and stop(), respectively. The effect
    intensity can be varied during the feedback.
           
    When you call play() from your widget, HbContinuousFeedback calls
    the internal feedback framework. If effects are enabled in
    the current application, the effect will be played. Applications can
    disable effects with the class HbFeedbackSettings, when effects are
    not wanted.
    
    If your custom widget derives from one of the standard %Hb widgets, it
    probably has some default feedback behaviour defined, and you should
    rely on the base class widget for triggering the feedback effects through
    the HbWidgetFeedback class. Note that if you choose to use this class,
    HbContinuousFeedback, to play effects directly, you may end up getting
    feedback effects twice, both through your call to HbContinuousFeedback
    and through the base class widget feedback mechanism.
    
    If your custom widget derives directly from HbWidget, and not through
    any other %Hb widget, HbContinuousFeedback is the recommended way
    to play continuous feedback effects.
    
    \sa HbFeedback::ContinuousEffect, HbInstantFeedback, HbWidgetFeedback
    
*/

/*!
    Sets the continuous feedback effect to be played when calling play().
    
    \sa continuousEffect()
*/

void HbContinuousFeedback::setContinuousEffect(HbFeedback::ContinuousEffect effect)
{
    d->cEffect = effect;
}

/*!
    Returns the continuous effect of this object. The continuous effect is
    the continuous feedback effect that will be played when calling play().
    
    \sa HbFeedback::ContinuousEffect
*/

HbFeedback::ContinuousEffect HbContinuousFeedback::continuousEffect() const
{
    return d->cEffect;
}

/*!
    Returns the timeout value of the feedback in milliseconds. The continuous
    feedback is automatically stopped if it is not updated within the timeout
    (by subsequent calls to play()).
    
    \sa setTimeout(), play()
*/

int HbContinuousFeedback::timeout() const {
    return d->cTimeout;
}

/*!
    Returns the intensity of the continuous feedback effect. Intensity can vary
    between HbFeedback::IntensityZero (0) and HbFeedback::IntensityFull (100).
    
    \sa setIntensity(), HbFeedback::IntensityLevel
*/

int HbContinuousFeedback::intensity() const {
    return d->cIntensity;
}

/*!
    \fn HbFeedback::Type HbContinuousFeedback::type() const

    Returns HbFeedback::TypeContinuous.
*/

/*!
    Constructor.
    
    If you use this constructor, you need to set the continuous feedback effect
    and an owning window before calling play().
*/
HbContinuousFeedback::HbContinuousFeedback() :d(new HbContinuousFeedbackPrivate)
{
}

/*!
    Constructor.

    \param effect Continuous feedback effect to be played
    \param widget Used to determine the window where the continuous feedback is active.
           There can only be one ongoing continuous feedback per application window.
*/
HbContinuousFeedback::HbContinuousFeedback(HbFeedback::ContinuousEffect effect, const QWidget *widget) : d(new HbContinuousFeedbackPrivate)
{
    d->cEffect = effect;
    setOwningWindow(widget);
}

/*!
    Destructor.
*/
HbContinuousFeedback::~HbContinuousFeedback()
{
    delete d;
}

/*!
    Sets the timeout value in milliseconds. The continuous feedback is
    automatically stopped if the continuous feedback is not updated
    within the timeout (by subsequent calls to play()). This is a safety mechanism
    to prevent situations in which the  client fails to explicitly stop()
    a continuous feedback effect. The default timeout value is
    HbFeedback::StandardFeedbackTimeout.
    
    \sa timeout()
*/
void HbContinuousFeedback::setTimeout(int msecTimeout)
{
    if (msecTimeout > 0) {
        d->cTimeout = msecTimeout;
    }
}

/*!
    Sets the intensity of the continuous feedback effect. The intensity can vary
    between HbFeedback::IntensityZero (0) and HbFeedback::IntensityFull (100).
    Smaller or bigger values are ignored.
    
    \sa intensity(), HbFeedback::IntensityLevel
*/
void HbContinuousFeedback::setIntensity(int intensity)
{
    if (intensity >= 0 && intensity <= HbFeedback::IntensityFull) {
        d->cIntensity = intensity;
    }
}

/*!
    Starts/updates the currently set continuous feedback effect.
    The feedback effect will be played until the timeout is reached
    or a call to stop() is made.
    
    \sa stop()
*/
void HbContinuousFeedback::play()
{
    HbFeedbackPlayer *feedbackPlayer = HbFeedbackPlayer::instance();
    if(feedbackPlayer) {
        if( feedbackPlayer->continuousFeedbackOngoing(d->cFeedbackId)) {
            feedbackPlayer->updateContinuousFeedback(d->cFeedbackId,*this);
        } else {
            d->cFeedbackId = feedbackPlayer->startContinuousFeedback(*this);
        }
    }
}

/*!
    Stops the continuous feedback.
*/
void HbContinuousFeedback::stop()
{
    HbFeedbackPlayer* feedbackPlayer = HbFeedbackPlayer::instance();

    if (feedbackPlayer) {
        feedbackPlayer->cancelContinuousFeedback(d->cFeedbackId);
    }
}


/*!
    Returns \c true if the continuous feedback is currently being played.
*/
bool HbContinuousFeedback::isPlaying()
{
    bool feedbackOngoing = false;
    HbFeedbackPlayer* feedbackPlayer = HbFeedbackPlayer::instance();

    if (feedbackPlayer) {
        feedbackOngoing = feedbackPlayer->continuousFeedbackOngoing(d->cFeedbackId);
    }

    return feedbackOngoing;
}


/*!
    This object is valid if the feedback effect is not set to HbFeedback::ContinuousNone
    and if the owning window has been defined. There can only be one ongoing
    continuous feedback effect per one application window.
*/
bool HbContinuousFeedback::isValid() const
{
    return d->cEffect != HbFeedback::ContinuousNone && window();
};

/*!
    Assigns a copy of \a feedback to this object, and returns a
    reference to it.
*/
HbContinuousFeedback &HbContinuousFeedback::operator=(const HbContinuousFeedback &feedback)
{
    HbAbstractFeedback::operator =(feedback);
    setContinuousEffect(feedback.continuousEffect());
    setTimeout(feedback.timeout());
    setIntensity(feedback.intensity());
    return *this;
}

/*!
    Returns \c true if this object and \a feedback have the same parent window,
    area rect, continuous effect, timeout, and intensity.
*/
bool HbContinuousFeedback::operator==(const HbContinuousFeedback &feedback) const
{
    return (rect() == feedback.rect()
            && window() == feedback.window()
            && d->cEffect == feedback.continuousEffect()
            && d->cTimeout == feedback.timeout()
            && d->cIntensity == feedback.intensity());
}

/*!
    Returns \c true if this object and \a feedback have a different parent window,
    area rect, continuous effect, timeout, or intensity.
*/
bool HbContinuousFeedback::operator!=(const HbContinuousFeedback &feedback) const
{
    return !(*this == feedback);
}