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

**

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

#include "hbvgmaskeffect_p.h"

#include "hbvgchainedeffect_p.h"

#include <QTimer>

#include <QGraphicsSceneMouseEvent>

#include <QShowEvent>

#include <QHideEvent>

#include <QPointer>

#include <QDebug>

#include <QBitmap>

#include <hbinstance_p.h>

#include <QGraphicsScene>

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

#include <hbwidgetfeedback.h>

#ifdef HB_EFFECTS

#include "hbeffectinternal_p.h"

bool HbPopupPrivate::popupEffectsLoaded = false;

#endif

/*!

    @beta

    @hbcore

    \class HbPopup

    \brief The HbPopup class defines a set of properties that control the behavior of 

    the many dialog and popup classes that derive from it. 

    Objects of classes derived from %HbPopup are called \b popups. Typically they

    are displayed above other objects within the view, at the highest z-order. The %HbPopup

    class simply defines a frame with a number of properties. If you want to create an

    application dialog with a heading, content and a toolbar, use the HbDialog class (which

    is derived from %HbPopup) or one of its convenience subclasses.

    %HbPopup provides properties that you can use to customize the following aspects of a popup:

    - \b Modality. You can define whether the popup is modal or non-modal. A modal popup stops

      the user interacting with anything outside of the popup until it closes. A non-modal 

      popup does not block the user's interaction with things outside of the popup. You 

      set and get the modality by calling setModal() and isModal(), respectively.  

    - <b>Dismiss policy</b>. You can define which user actions, if any, cause the popup to 

      close. Possible values are defined by HbPopup::DismissPolicy. You set and get the dismiss 

      policy by calling setDismissPolicy() and dismissPolicy(), respectively.

    - <b>Background fade policy</b>. You can set a policy to fade everything behind the 

      popup. This is useful for modal dialogs, because the user cannot interact with 

      anything behind the popup. You control this policy by calling setBackgroundFaded() and 

      get the current policy by calling isBackgroundFaded().

    - \b Timeout. You can define a timeout that causes the popup to be dismissed automatically

      after a set a period. You set and get this property by calling setTimeout() and 

      timeout(), respectively. Call the setTimeout(HbPopup::DefaultTimeout) overload to use the 

      default value for the popup type, which provides a common look and feel.

    - <b>Frame background type</b>. You can define the popup's background style. However, 

      the actual appearance of the popup depends on the theme. You set and get this property by

      calling setFrameType() and frameType(), respectively.

    By default, popups are displayed in the center of the screen. Typically you should not override

    the default position of modal dialogs. However, some popups, such as context menus, need to be 

    in a specific position. For these, you can use the setPreferredPos() method to set the 

    preferred position.

    Popups that contain an editor may be repositioned by the virtual keyboard when it opens. 

    When the virtual keyboard closes, it attempts to reposition the popup back to its 

    previous position. However, this is not always possible, particularly when there has also

    been an orientation switch.

    \section _usecases_hbpopup Using the HbPopup class

    Although it is possible to create an instance of the HbPopup class, it is designed as a

    base class to provide common features to the many popup and dialog classes that are 

    derived from it (such as HbMenu, HbDialog, HbToolBarExtension, HbZoomSliderPopup). 

    How you open a popup depends on whether it is modal. It is important to use the 

    appropriate method, because this ensures the correct touch event handling.

    <table border="1" style="border-collapse: collapse; border: solid;">

    <tr><th>To open</TH><TH>Call</th></tr>

    <tr><td>Modal popups</td><td>open()</td></tr>

    <tr><td>Non-modal popups</td><td>\link QGraphicsItem::show() show()\endlink</td></tr>

    </table>

    \sa HbDialog, HbMenu

*/

/*!

    \fn int HbPopup::type() const

 */

/*!

    \enum HbPopup::DefaultTimeout

    Identifies default timeout values for various popup types. The timeout defines a time

    period after which the popup is automatically closed. Using these default values 

    provides a consistent look and feel.

    \sa setTimeout(HbPopup::DefaultTimeout)

 */

/*!

    \var HbPopup::NoTimeout

    Defines a permanent popup, for which no timeout is defined.

 */

/*!

    \var HbPopup::ConfirmationNoteTimeout

    The default timeout value for confirmation notes.

 */

/*!

    \var HbPopup::StandardTimeout

    The default timeout value for standard non-permanent popups, such as notes.

 */

/*!

    \var HbPopup::ContextMenuTimeout

    The default timeout value for context menus.

 */

/*!

    \enum HbPopup::DismissPolicy

    Defines the available dismiss policy values. The dismiss policy defines which

    user actions cause the popup to close.

    \sa setDismissPolicy(), dismissPolicy()

 */

/*!

    \var HbPopup::NoDismiss

    The popup cannot be closed by the user.

 */

/*!

    \var HbPopup::TapInside

    Closes the popup when the user taps within the popup's bounding rectangle.

 */

/*!

    \var HbPopup::TapOutside

    Closes the popup when the user taps outside of the popup's bounding rectangle.

 */

/*!

    \var HbPopup::TapAnywhere

    Closes the popup when the user taps either inside or outside the popup's bounding 

    rectangle.

 */

/*!

    \enum HbPopup::FrameType

    Identifies the background graphical styles of the popup's frame.

    \sa setFrameType(), frameType()

 */

/*!

    \var HbPopup::Strong

    Use the "strong" frame background style.

 */

/*!

    \var HbPopup::Weak

    Use the "weak" frame background style.

 */

/*!

    \fn void HbPopup::aboutToShow();

    This signal is emitted when the popup is about to be shown; that is, when 

    \link QGraphicsItem::show() show()\endlink is called.

 */

/*!

    \fn void HbPopup::aboutToHide();

    This signal is emitted when the popup is about to be hidden; that is, when 

    \link QGraphicsItem::hide() hide()\endlink is called.

 */

/*!

    \fn void HbPopup::aboutToClose();

    This signal is emitted when the popup is about to close; that is, when 

    \link QGraphicsWidget::close() close()\endlink is called or the popup is dismissed 

    by the user or timeout.

 */

/*!

    \enum HbPopup::Placement

    Identifies the corners and edges of the popup for use when setting its position

    using setPreferredPos(). 

  */

/*!

    \var HbPopup::TopLeftCorner

    The popup's top left corner.

 */

/*!

    \var HbPopup::TopRightCorner

    The popup's top right corner.

 */

/*!

    \var HbPopup::BottomLeftCorner

    The popup's bottom left corner.

 */

/*!

    \var HbPopup::BottomRightCorner

    The popup's bottom right corner.

 */

/*!

    \var HbPopup::TopEdgeCenter

    The center of the popup's top edge.

 */

/*!

    \var HbPopup::RightEdgeCenter

    The center of the popup's rightmost edge.

 */

/*!

    \var HbPopup::BottomEdgeCenter

    The center of the popup's bottom edge.

 */

/*!

    \var HbPopup::LeftEdgeCenter

    The center of the popup's leftmost edge.

 */

 /*!

    \var HbPopup::Center

    The center of the popup.

 */

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

{

    {HbPopup::NoTimeout,0},

    {HbPopup::ConfirmationNoteTimeout,1500},

    {HbPopup::StandardTimeout,3000},

    {HbPopup::ContextMenuTimeout,6000},

};

/*

    \primitives

    \primitive{background} HbFrameItem representing the popup background. The background can be 

    weak or strong (different graphical styles) depending on popup type.

    \primitive{P_Popup_heading_frame} HbFrameItem representing the popup heading text background

  */

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( ) :

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

    placement(HbPopup::TopLeftCorner),

    mStartEffect(true),

    mScreenMargin(0.0),

    mAutoLayouting(true),

    mOriginalAutoLayouting(mAutoLayouting),

    mActivePopup(true),

    mVgMaskEffect(0),

    mOrientationEffectHide(false),

    mGestureOverride(false),

    timeoutTimerInstance(0)

{

}

HbPopupPrivate::~HbPopupPrivate()

{

    stopTimeout();

    delete timeoutTimerInstance;

}

void HbPopupPrivate::init()

{

    Q_Q(HbPopup);

    q->setAttribute(Hb::InsidePopup);

    // By default popups are focusable

    q->setFocusPolicy(Qt::StrongFocus);    

    setBackgroundItem(HbStylePrivate::P_Popup_background);

    q->updatePrimitives();

    // Only for popup without parent

    if (!q->parentItem()) {

        backgroundItem = new HbPopupBackGround(q);

        backgroundItem->setVisible(false);

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

        q->setVisible(false);

    }

    hidingInProgress = false; 

    QGraphicsItem::GraphicsItemFlags itemFlags = q->flags();

    itemFlags |= QGraphicsItem::ItemClipsToShape;

    itemFlags |= QGraphicsItem::ItemClipsChildrenToShape;

    itemFlags |= QGraphicsItem::ItemSendsGeometryChanges;

    q->setFlags(itemFlags);

}

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

{

    Q_UNUSED(status);

}

CSystemToneService* HbPopupPrivate::systemToneService()

{

    return HbInstancePrivate::d_ptr()->systemTone();

}

/*

 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;

}

#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;

    mGestureOverride = false;

}

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

{

    Q_UNUSED(orient);    

    Q_Q(HbPopup);

    if (animate && q->isVisible()) {

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

        mOrientationEffectHide = true;

    }

}

#endif // HB_EFFECTS

void HbPopupPrivate::_q_orientationChanged()

{

    Q_Q(HbPopup);

    if (q->isVisible() || q) {

        QEvent userEvent(QEvent::ContextMenu);

        QCoreApplication::sendEvent(q, &userEvent);

    }

#ifdef HB_EFFECTS

    if (mOrientationEffectHide) {

        HbEffect::cancel(q);

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

        mOrientationEffectHide = false;

    }

#endif

}

void HbPopupPrivate::_q_timeoutFinished()

{

    Q_Q(HbPopup);

    timedOut = true;

    q->close();