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

**

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

#include "hbpopup_p.h"

#include "hbinstance.h"

#include "hbpopupmanager_p.h"

#include "hbdeviceprofile.h"

#include "hbevent.h"

#include "hbgraphicsscene.h"

#include "hbgraphicsscene_p.h"

#include "hbtooltip.h"

#include <QTimer>

#include <QGraphicsSceneMouseEvent>

#include <QShowEvent>

#include <QHideEvent>

#include <QEventLoop>

#include <QPointer>

#include <QApplication> // krazy:exclude=qclasses

#include <hbwidgetfeedback.h>

#ifdef HB_EFFECTS

#include "hbeffectinternal_p.h"

bool HbPopupPrivate::popupEffectsLoaded = false;

#endif

/*!

    @stable

    @hbcore

    \class HbPopup

    \brief HbPopup is a base class for different popup notes in Hb library.

    \image html hbpopup.png A popup with a header widget, a list as a content widget, and two

    action buttons.

    HbPopup is a concrete class. The content for a custom popup is implemented in

    a separate widget, which is set to the popup with method setContentWidget().

    Lastly shown popup is always positioned in Z order on the the top of already visible popups.

    A popup can be permanent or automatically dismissed after a time-out.

    Modal popups interrupt any other user interaction outside of the popup while they are visible,

    whereas non-modal popups do not.

    An example of how to create a simple modal popup and show it.

    \snippet{ultimatecodesnippet/ultimatecodesnippet.cpp,13}

    An example of how to create a non-modal popup and show it.

    \snippet{ultimatecodesnippet/ultimatecodesnippet.cpp,26}

*/

/*!

    \reimp

    \fn int HbPopup::type() const

 */

/*!

    \enum HbPopup::DefaultTimeout

    This enum defines available default timeout values to be used in method

    setTimeout(HbPopup::DefaultTimeout).

 */

/*!

    \var HbPopup::NoTimeout

    No timeout is defined for automatically closing the popup. i.e. the popup is permanent.

 */

/*!

    \var HbPopup::ConfirmationNoteTimeout

    Timeout value intended to be used by confirmation notes.

 */

/*!

    \var HbPopup::StandardTimeout

    The default timeout value intended to be used by most non-permanent popups e.g. by notes.

 */

/*!

    \var HbPopup::ContextMenuTimeout

    The default timeout value intended to be used by context menus.

 */

/*!

    \enum HbPopup::DismissPolicy

    This enum defines available dismiss policy values.

    The dismiss policy defines what user actions will cause the popup to be dismissed i.e. closed.

 */

/*!

    \var HbPopup::NoDismiss

    The popup cannot be dismissed automatically by user interaction.

 */

/*!

    \var HbPopup::TapInside

    The popup is dismissed when user taps within the bounding rectangle of the popup.

 */

/*!

    \var HbPopup::TapOutside

    The popup is dismissed when user taps outside of the bounding rectangle of the popup.

 */

/*!

    \var HbPopup::TapAnywhere

    The popup is dismissed when user taps either within or outside

    of the bounding rectangle of the popup.

 */

/*!

    \enum HbPopup::FrameType

    This enum defines available frame type values.

    The frame types defines what frame item backgrounds will be used by the popup.

 */

/*!

    \var HbPopup::Strong

    The popup is using strong frame.

 */

/*!

    \var HbPopup::Weak

    The popup is using weak frame.

 */

/*!

    \fn void HbPopup::aboutToShow();

    This signal is emitted when the popup is about to be shown i.e. when method show() is called.

 */

/*!

    \fn void HbPopup::aboutToHide();

    This signal is emitted when the popup is about to be hidden i.e. when method hide() is called.

 */

/*!

    \fn void HbPopup::aboutToClose();

    This signal is emitted when the popup is about to be closed i.e. when method close() is called

    or the popup is

    dismissed by the user or timeout.

 */

static const struct { HbPopup::DefaultTimeout timeout; int value; } timeoutValues[] =

{

    {HbPopup::NoTimeout,0},

    {HbPopup::ConfirmationNoteTimeout,1500},

    {HbPopup::StandardTimeout,3000},

    {HbPopup::ContextMenuTimeout,6000},

};

HbPopupBackGround::HbPopupBackGround(HbPopup * popup, QGraphicsItem *parent) :

        QGraphicsItem(parent),

        popup(popup)

{

    // This is needed to be able to block moving the focus to items behind background item by

    // clicking on them.

    setFlag(QGraphicsItem::ItemIsFocusable);

#if QT_VERSION >= 0x040600

    setFlag(QGraphicsItem::ItemHasNoContents, true);

#endif

}

HbPopupBackGround::~HbPopupBackGround()

{

    // Set backgroundItem to 0 to avoid double deletion

    // e.g. when backgroundItem is deleted by scene before its popup

    if (popup) {

        HbPopupPrivate::d_ptr(popup)->backgroundItem = 0;

    }

}

void HbPopupBackGround::setRect(QRectF rect)

{

    mRect = rect;

}

QRectF HbPopupBackGround::boundingRect() const

{

    if(!mRect.isValid()){

        // set backgroundItem's size so that it is big enough

        // to cover the screen both landscape and portrait mode

        const QSizeF screenSize = HbDeviceProfile::profile(this).logicalSize();

        qreal dim = qMax(screenSize.width(), screenSize.height());

        mRect.adjust(0,0,dim,dim);

    }

    return mRect;

}

void HbPopupBackGround::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget )

{

    Q_UNUSED(option)

    Q_UNUSED(widget);

    Q_UNUSED(painter);

}

bool HbPopupBackGround::sceneEvent(QEvent *event)

{

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

        HbPopupPrivate::d_ptr(popup)->handleBackgroundMousePressEvent();

    }

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

        HbPopupPrivate::d_ptr(popup)->handleBackgroundMouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent *>(event));

    }

    if (event->type() == QEvent::FocusIn && scene()) {

        // Prevents last focus item losing its focus

        // This event is received only when popup is modal

        QFocusEvent restoreLastFocus(QEvent::FocusIn,Qt::OtherFocusReason);

        QApplication::sendEvent(scene(),&restoreLastFocus); // krazy:exclude=qclasses

    }

    // accept events only for modal popups

    if(popup->isModal()){

        event->accept();

        return true;

    } else {

        event->ignore();

    }

    return QGraphicsItem::sceneEvent(event);

}

HbPopupPrivate::HbPopupPrivate( ) :

    eventLoop(0),

    hasEffects(false),

    closed(false),

    hidingInProgress(true),

    delayedHide(false),

    deleteOnClose(false),

    modal(true), // must be in sync QGraphicsItem::ItemIsFocusable of backgroundItem

    fadeBackground(true),

    inDestruction(false),

    aboutToShowSignalGuard(false),

    duplicateShowEvent(false),

    timedOut(false),

    timeout(HbPopupPrivate::timeoutValue(HbPopup::StandardTimeout)),

    //    priorityValue(HbPopup::Default),

    priorityValue(0),

    dismissPolicy(HbPopup::TapOutside),

    backgroundItem(0),

    mousePressLocation(None),

    frameType(HbPopup::Strong),

    preferredPosSet(false),

    mStartEffect(false),

    timeoutTimerInstance(0)

{

}

HbPopupPrivate::~HbPopupPrivate()

{

}

void HbPopupPrivate::init()

{

    Q_Q(HbPopup);

    q->setAttribute(Hb::InsidePopup);

    // By default popups are focusable

    q->setFocusPolicy(Qt::StrongFocus);    

    q->setBackgroundItem(HbStyle::P_Popup_background);

    // Only for popup without parent

    if (!q->parentItem()) {

        backgroundItem = new HbPopupBackGround(q);

        backgroundItem->setVisible(false);

        // Popup is invisible by default (explicit show or exec call is required)

        q->setVisible(false);

    }

    hidingInProgress = false;   

}

/*

*  *********** Begin of private features ***********

*/

/*

* Sets the priority for a popup.

* A popup with higher priority is always shown on top of a popup with lower priority.

* In case of popups with same priority the lastly shown will be on top.

* Default priority is HbPopup::Default

* \sa priority()

*/

void HbPopupPrivate::setPriority(quint8 priority)

{

    //TODO: consider implementing dynamic change of prorities

    // i.e. if the priority changes while the popup is registered to popupManager

    // then re-register it to get its Z value updated

    priorityValue=priority;

}

/*

*  *********** End of private features ***********

*/

#ifdef HB_EFFECTS

void HbPopupPrivate::_q_delayedHide(HbEffect::EffectStatus status)

{

    Q_UNUSED(status);

    Q_Q(HbPopup);

    // Apply forceHide only if the effect started successfully

    if (status.reason != Hb::EffectNotStarted) {

        forceHide();

    } else {

        delayedHide = false;

    }

    if (deleteOnClose) {

        q->deleteLater();

    }

    hidingInProgress = false;

}

void HbPopupPrivate::_q_orientationChange(Qt::Orientation orient, bool animate)

{

    Q_UNUSED(orient);

    if (animate) {

    Q_Q(HbPopup);

    HbEffect::start(q, "HB_POPUP", "orientationswitch");

    }

}

#endif // HB_EFFECTS

void HbPopupPrivate::_q_timeoutFinished()

{

    Q_Q(HbPopup);

    timedOut = true;

    q->close();

}

void HbPopupPrivate::stopTimeout()

{

    if (timeoutTimerInstance)

        timeoutTimerInstance->stop();

}

void HbPopupPrivate::startTimeout()

{

    if (timeout > 0) {

        timeoutTimer()->start();

        timedOut = false;

    }

}

QTimer *HbPopupPrivate::timeoutTimer()

{

    Q_Q(HbPopup);

    if (!timeoutTimerInstance) {

        timeoutTimerInstance = new QTimer(q);

        timeoutTimerInstance->setSingleShot(true);

        q->connect(timeoutTimerInstance, SIGNAL(timeout()), q, SLOT(_q_timeoutFinished()));

    }

    return timeoutTimerInstance;

}

void HbPopupPrivate::handleKeyEvent(QKeyEvent *event)

{

    Q_Q(HbPopup);

    event->accept();

    // Any key event dismisses the popup if dismissPolicy includes TapInside flag

    if (dismissPolicy & HbPopup::TapInside && !q->parentItem()) {

        q->close();

    }

}

//returns true if popup has been added to scene here.

bool HbPopupPrivate::addPopupToScene()

{

    Q_Q(HbPopup);

    bool popupAdded(false);

    if (!q->parentItem()) {

        if (!q->scene() && !HbInstance::instance()->allMainWindows().isEmpty()) {

            HbInstance::instance()->allMainWindows().at(0)->scene()->addItem(q);

            popupAdded = true;

            if (backgroundItem) {

                q->scene()->addItem(backgroundItem);

            }

        } else if (q->scene() && backgroundItem && backgroundItem->scene() != q->scene()) {

            q->scene()->addItem(backgroundItem);

        }

    }

    return popupAdded;

}

void HbPopupPrivate::handleBackgroundMousePressEvent()

{

    mousePressLocation = Background;

}

void HbPopupPrivate::handleBackgroundMouseReleaseEvent(QGraphicsSceneMouseEvent *event)

{

    Q_Q(HbPopup);

    // Handle cases only for Background or Popup originated mouse presses and when

    // any dismiss policy defined

    if (mousePressLocation != None && dismissPolicy != HbPopup::NoDismiss) {

        MouseEventLocationType mouseReleaseLocation = Background;

        if (q->contains (q->mapFromScene(event->scenePos()))) {

            mouseReleaseLocation = Popup;

        }

        // Mouse is released within popup

        if (mouseReleaseLocation == Popup) {

            // Handle cases only when TapInside is set

            if (dismissPolicy & HbPopup::TapInside) {

                // Close popup if mouse press is initiated within popup or TapOutside is set

                if (mousePressLocation == Popup || dismissPolicy & HbPopup::TapOutside) {

                    q->close();

                }

            }

        }

        // Mouse is released within popup background

        else {

            // Handle cases only when TapOutside is set

            if (dismissPolicy & HbPopup::TapOutside) {

                // Close popup if mouse press is initiated within popup background

                // or TapInside is set

                if (mousePressLocation == Background || dismissPolicy & HbPopup::TapInside) {

                    q->close();

                }

            }

        }

    }

    // reset mousePressLocation

    mousePressLocation = None;

}

int HbPopupPrivate::timeoutValue(HbPopup::DefaultTimeout timeout)

{

    int count = sizeof(timeoutValues) / sizeof(timeoutValues[0]);

    if (timeout < 0 || timeout >= count) {

        return timeoutValues[HbPopup::NoTimeout].value;

    }

    return timeoutValues[timeout].value;

}

void HbPopupPrivate::forceHide()

{

    Q_Q(HbPopup);

    delayedHide = false;

    q->hide();

    delayedHide = hasEffects;

}

void HbPopupPrivate::addPopupEffects()

{

#ifdef HB_EFFECTS

    effectType = "HB_POPUP";

    hasEffects = popupEffectsLoaded;

    if (popupEffectsLoaded)

        return;

    popupEffectsLoaded = true;

    hasEffects = HbEffectInternal::add("HB_POPUP",

                                       "popup_appear",

                                       "appear");

    if (hasEffects) {

        hasEffects = HbEffectInternal::add("HB_POPUP",

                                           "popup_disappear",

                                           "disappear");

    }

    if (hasEffects ) {

        hasEffects = HbEffectInternal::add("HB_POPUP",

                                           "dialog_rotate",

                                           "orientationswitch");

    }

#endif

}

void HbPopupPrivate::doSetModal( bool modal ) {

    if(backgroundItem) {

        // When the popup is modal background item must receive focus

        // events to be able to prevent last focus item losing its

        // focus

        backgroundItem->setFlag(QGraphicsItem::ItemIsFocusable, modal);

    }

}