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

**

** 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 HbCore 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 "hbabstractbutton.h"

#include "hbabstractbutton_p.h"

#include "hbapplication.h"

#include "hbstyleoption_p.h"

#include "hbtooltip.h"

#include "hbinstance.h"

#include "hbnamespace_p.h"

#include <QGraphicsSceneMouseEvent>

#include <QGraphicsScene>

#include <QPointer>

#include <QStyle>

#include <hbwidgetfeedback.h>

#ifdef HB_GESTURE_FW

#include <hbtapgesture.h>

#include <hbpangesture.h>

#endif

namespace {

    static const int AUTO_REPEAT_DELAY = 300;

    static const int AUTO_REPEAT_INTERVAL = 100;

}

/*!

    @beta

    @hbcore

    \class HbAbstractButton

    \brief The HbAbstractButton class is the abstract base class of

    button widgets, providing functionality common to buttons.

    This class implements an \e abstract button.

    Subclasses of this class handle user actions, and specify how the button

    is drawn.

    HbAbstractButton provides support for both push buttons and checkable

    (toggle) buttons. Checkable buttons are implemented in the HbRadioButton

    and HbCheckBox classes. Push buttons are implemented in the

    HbPushButton and HbToolButton classes; these also provide toggle

    behavior if required.

    Any button can display  text and an icon. setText()

    sets the text; setIcon() sets the icon. If a button is disabled, its background

    is changed to give the button a "disabled" appearance.

    All of the buttons provided by Hb (HbPushButton, HbToolButton,

    HbCheckBox, and HbRadioButton) can display both text and icon.

    You can also set a tool tip for the button with \qtfunc{QGraphicsItem,setTooltip}.

    HbAbstractButton provides most of the states used for buttons:

    \li isDown() indicates whether the button is \e pressed down.

    \li isChecked() indicates whether the button is \e checked.  Only

    checkable buttons can be checked and unchecked (see below).

    \li isEnabled() indicates whether the button can be pressed by the

    user.

    \li setAutoRepeat() sets whether the button will auto-repeat if the

    user holds it down. \l autoRepeatDelay and \l autoRepeatInterval

    define how auto-repetition is done.

    \li setCheckable() sets whether the button is a toggle button or not.

    The difference between isDown() and isChecked() is as follows.

    When the user clicks a toggle button to check it, the button is first

    \e pressed then released into the \e checked state. When the user

    clicks it again (to uncheck it), the button moves first to the

    \e pressed state, then to the \e unchecked state (isChecked() and

    isDown() are both false).

    HbAbstractButton provides four signals:

    \li pressed() is emitted when the stylus is pressed while

    the stylus is inside the button.

    \li released() is emitted when the left stylus is released.

    \li clicked() is emitted when the button is first pressed and then

    released, when the shortcut key is typed, or when click() or

    animateClick() is called.

    \li toggled() is emitted when the state of a toggle button changes.

    To subclass HbAbstractButton, you must reimplement at least

    paint() to draw the button's outline and its text or pixmap. It

    is generally advisable to reimplement sizeHint() as well, and

    sometimes hitButton() (to determine whether a button press is within

    the button). For buttons with more than two states (like tri-state

    buttons), you will also have to reimplement checkStateSet() and

    nextCheckState().

*/

/*!

    \reimp

    \fn int HbAbstractButton::type() const

 */

HbAbstractButtonPrivate::HbAbstractButtonPrivate( QSizePolicy::ControlType type )

    :

    shortcutId(0),

    checkable(false), checked(false), autoRepeat(false), autoExclusive(false),

    down(false), blockRefresh(false),longPress(false),

    autoRepeatDelay(AUTO_REPEAT_DELAY),

    autoRepeatInterval(AUTO_REPEAT_INTERVAL),

    controlType(type), sizeHint(),mSizeHintPolish(false),mRepolishRequested(false)

{

}

HbAbstractButtonPrivate::~HbAbstractButtonPrivate()

{

}

QList<HbAbstractButton *>HbAbstractButtonPrivate::queryButtonList() const

{

    Q_Q( const HbAbstractButton );

    QList<HbAbstractButton*>candidates;

    if (q->parentWidget()) {

        candidates =  qFindChildren<HbAbstractButton *>(q->parentWidget());

        if (autoExclusive) {

            for (int i = candidates.count() - 1; i >= 0; --i) {

                HbAbstractButton *candidate = candidates.at(i);

                if (!candidate->autoExclusive())

                    candidates.removeAt(i);

            }

        }

    }

    return candidates;

}

HbAbstractButton *HbAbstractButtonPrivate::queryCheckedButton() const

{

    QList<HbAbstractButton *> buttonList = queryButtonList();

    if (!autoExclusive || buttonList.count() == 1) // no group

        return 0;

    Q_Q( const HbAbstractButton );

    for (int i = 0; i < buttonList.count(); ++i) {

        HbAbstractButton *b = buttonList.at(i);

        if (b->isChecked() && b != q)

            return b;

    }

    return checked  ? const_cast<HbAbstractButton *>(q) : 0;

}

void HbAbstractButtonPrivate::notifyChecked()

{

    if (autoExclusive) {

        if (HbAbstractButton *b = queryCheckedButton())

            b->setChecked(false);

    }

}

void HbAbstractButtonPrivate::moveFocus(int key)

{

    Q_Q( HbAbstractButton );

    QList<HbAbstractButton *> buttonList = queryButtonList();;

    bool exclusive = autoExclusive;

    QGraphicsItem *focusItem = q->scene()->focusItem();

    HbAbstractButton *focusButton = 0;

    if (focusItem && focusItem->isWidget()) {

        QGraphicsWidget *focusWidget = static_cast<QGraphicsWidget*>(focusItem);

        focusButton = qobject_cast<HbAbstractButton *>(focusWidget);

    }

    if (!focusButton || !buttonList.contains(focusButton))

        return;

    HbAbstractButton *candidate = 0;

    int bestScore = -1;

    QRect target = focusItem->sceneBoundingRect().toRect();

    QPoint goal = target.center();

    for (int i = 0; i < buttonList.count(); ++i) {

        HbAbstractButton *button = buttonList.at(i);

        if (button != focusItem && button->isEnabled() && button->isVisible() &&

            (autoExclusive || (button->focusPolicy() & Qt::StrongFocus) == Qt::StrongFocus)) {

            QRect buttonRect = button->sceneBoundingRect().toRect();

            QPoint p = buttonRect.center();

            //Priority to widgets that overlap on the same coordinate.

            //In that case, the distance in the direction will be used as significant score,

            //take also in account orthogonal distance in case two widget are in the same distance.

            int score;

            if ( keyNavigation() && (buttonRect.x() < target.right() && target.x() < buttonRect.right())

                  && (key == Qt::Key_Up || key == Qt::Key_Down)) {

                //one item's is at the vertical of the other

                score = (qAbs(p.y() - goal.y()) << 16) + qAbs(p.x() - goal.x());

            } else if ( keyNavigation() && (buttonRect.y() < target.bottom() && target.y() < buttonRect.bottom())

                        && (key == Qt::Key_Left || key == Qt::Key_Right) ) {

                //one item's is at the horizontal of the other

                score = (qAbs(p.x() - goal.x()) << 16) + qAbs(p.y() - goal.y());

            } else {

                score = (1 << 30) + (p.y() - goal.y()) * (p.y() - goal.y()) + (p.x() - goal.x()) * (p.x() - goal.x());

            }

            if (score > bestScore && candidate)

                continue;

            if ( keyNavigation()) {

                switch(key) {

                case Qt::Key_Up:

                    if (p.y() < goal.y()) {

                        candidate = button;

                        bestScore = score;

                    }

                    break;

                case Qt::Key_Down:

                    if (p.y() > goal.y()) {

                        candidate = button;

                        bestScore = score;

                    }

                    break;

                case Qt::Key_Left:

                    if (p.x() < goal.x()) {

                        candidate = button;

                        bestScore = score;

                    }

                    break;

                case Qt::Key_Right:

                    if (p.x() > goal.x()) {

                        candidate = button;

                        bestScore = score;

                    }

                    break;

                }

            }

        }

    }

    if (exclusive

        && !keyNavigation()

        && candidate

        && focusButton->isChecked()

        && candidate->isCheckable())

        candidate->click();

    if ( keyNavigation() && candidate) {

        if (key == Qt::Key_Up || key == Qt::Key_Left)

            candidate->setFocus(Qt::BacktabFocusReason);

        else

            candidate->setFocus(Qt::TabFocusReason);

    }

}

void HbAbstractButtonPrivate::fixFocusPolicy()

{

    if (!autoExclusive)

        return;

    Q_Q( HbAbstractButton );

    QList<HbAbstractButton *> buttonList = queryButtonList();

    for (int i = 0; i < buttonList.count(); ++i) {

        HbAbstractButton *b = buttonList.at(i);

        if (!b->isCheckable())

            continue;

        b->setFocusPolicy((Qt::FocusPolicy) ((b == q || !q->isCheckable())

                                         ? (b->focusPolicy() | Qt::TabFocus)

                                         :  (b->focusPolicy() & ~Qt::TabFocus)));

    }

}

void HbAbstractButtonPrivate::init()

{

    Q_Q( HbAbstractButton );

	q->setFocusPolicy(Qt::FocusPolicy(qApp->style()->styleHint(QStyle::SH_Button_FocusPolicy)));

#ifdef HB_GESTURE_FW

    q->grabGesture(Qt::TapGesture);

#endif

    // FIXME: size policy is commented out b/c of a bug in Qt #236689, also in our bugtracker.

    //q->setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum, controlType));

    //q->setForegroundRole(QPalette::ButtonText); TODO: check

    //q->setBackgroundRole(QPalette::Button); TODO: check

}

void HbAbstractButtonPrivate::refresh()

{

    if (blockRefresh)

        return;

    Q_Q( HbAbstractButton );

    q->updatePrimitives();

}

void HbAbstractButtonPrivate::click()

{

    Q_Q( HbAbstractButton );

    down = false;

    blockRefresh = true;

    bool changeState = true;

    if (checked && queryCheckedButton() == q) {

        // the checked button of an exclusive or autoexclusive group cannot be unchecked

        if (autoExclusive)

            changeState = false;

    }

    QPointer<HbAbstractButton> guard(q);

    if (changeState) {

        q->nextCheckState();

        if (!guard)

            return;

    }

    blockRefresh = false;

    refresh();

    if (guard)

        emitReleased();

    if (guard && !longPress)

        emitClicked();

    if(guard && longPress)

        longPress = false;

}

void HbAbstractButtonPrivate::emitClicked()

{

    Q_Q( HbAbstractButton );

    QPointer<HbAbstractButton> guard(q);

    emit q->clicked(checked);

}

void HbAbstractButtonPrivate::emitPressed()

{

    Q_Q( HbAbstractButton );

    QPointer<HbAbstractButton> guard(q);

    emit q->pressed();

}

void HbAbstractButtonPrivate::emitReleased()

{

    Q_Q( HbAbstractButton );

    QPointer<HbAbstractButton> guard(q);

    emit q->released();

}

/*!

    @beta

    Constructs an abstract button with a \a parent.

*/

HbAbstractButton::HbAbstractButton(QGraphicsItem *parent)

    : HbWidget( *new HbAbstractButtonPrivate, parent)

{

    Q_D( HbAbstractButton );

    d->init();

}

/*!

    @beta

    \internal

 */

HbAbstractButton::HbAbstractButton( HbAbstractButtonPrivate &dd, QGraphicsItem * parent ) :

        HbWidget( dd, parent )

{

    Q_D( HbAbstractButton );

    d->init();

}

/*!

    Destroys the button.

 */

 HbAbstractButton::~HbAbstractButton()

{

}

/*

\property HbAbstractButton::shortcut

\brief the mnemonic associated with the button

void HbAbstractButton::setShortcut(const QKeySequence &key)

{

    Q_ASSERT(mainWindow());

    if (d->shortcutId != 0)

        mainWindow()->releaseShortcut(d->shortcutId);

    d->shortcut = key;

    d->shortcutId = mainWindow()->grabShortcut(key);

}

QKeySequence HbAbstractButton::shortcut() const

{

    return d->shortcut;

}

*/

/*!

    @beta

    Returns whether the button is checkable.

    By default, the button is not checkable.

    \sa setCheckable() checked

*/

bool HbAbstractButton::isCheckable() const

{

    Q_D( const HbAbstractButton );

    return d->checkable;

}

/*!

    @beta

    Sets whether the button is checkable.

    \sa isCheckable()

 */

void HbAbstractButton::setCheckable(bool checkable)

{

    Q_D( HbAbstractButton );

    if (d->checkable == checkable)

        return;

    d->checkable = checkable;

    d->checked = false;

}

/*!

    @beta

    Returns whether the button is checked.

    Only checkable buttons can be checked. By default, the button is unchecked.

    \sa setChecked() setCheckable()

*/

bool HbAbstractButton::isChecked() const

{

    Q_D( const HbAbstractButton );

    return d->checked;

}

/*!

    @beta

    Sets whether the button is checked.

    Only checkable buttons can be checked. By default, the button is unchecked.

    \sa isChecked() isCheckable()

*/

void HbAbstractButton::setChecked(bool checked)

{

    Q_D( HbAbstractButton );

    if (!d->checkable || d->checked == checked) {

        if (!d->blockRefresh)

            checkStateSet();

        return;

    }

    if (!checked && d->queryCheckedButton() == this) {

        // the checked button of an exclusive or autoexclusive group cannot be  unchecked

        if (d->autoExclusive)

            return;

    }

    QPointer<HbAbstractButton> guard(this);

    d->checked = checked;

    if (!d->blockRefresh)

        checkStateSet();

    d->refresh();

    if (guard && checked)

        d->notifyChecked();

    if (guard)

        emit toggled(checked);

}

/*!

    @beta

    Returns whether the button is pressed down.

    If this property is \c true, the button is pressed down.

    The default value is \c false.

    \sa setDown()

*/

bool HbAbstractButton::isDown() const

{

    Q_D( const HbAbstractButton );

    return d->down;

}

/*!

    @beta

    Sets whether the button is pressed down.