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

**

** 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 <QEventLoop>

#include <QPointer>

#include <QDebug>

#include <QBitmap>

#include <hbinstance_p.h>

#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 HbPopup is a base class for different popups in Hb library.

    Popup is a widget that is displayed above other widgets in the view.

    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.

    \sa HbDialog

*/

/*!

    \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. Actual appearance is dependent on theme.

 */

/*!

    \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.

 */

/*!

    \enum HbPopup::Placement

    Placement is the corner or edge to which position of the popup refers to.

  */

/*!

    \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

  */

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

    mScreenMargin(0.0),

    mAutoLayouting(true),

    mOriginalAutoLayouting(mAutoLayouting),

    mVgMaskEffect(0),

    mOrientationEffectHide(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(HbStyle::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;

    //itemFlags |= QGraphicsItem::ItemIsPanel;

    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;

}

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

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

}

void HbPopupPrivate::stopTimeout()

{

    if (timeoutTimerInstance)

        timeoutTimerInstance->stop();

}

void HbPopupPrivate::startTimeout()

{

    if (timeout > 0) {

        timeoutTimer()->start();

        timedOut = false;

    }

}

void HbPopupPrivate::setTimeout(int msec)

{

    Q_Q(HbPopup);

    int prevTimeout = timeout;

    timeout = msec;

    if (msec > 0) {

        timeoutTimer()->setInterval(msec);

        // If timeout was 0 and it is now set to something > 0 then start the timer.

        if (q->isVisible() && prevTimeout <= 0)

            startTimeout();

    } else {

        stopTimeout();

    }

}

QTimer *HbPopupPrivate::timeoutTimer()

{

    Q_Q(HbPopup);

    if (!timeoutTimerInstance) {

        timeoutTimerInstance = new QTimer();

        timeoutTimerInstance->setSingleShot(true);

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

    }

    return timeoutTimerInstance;

}

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

{

    Q_Q(HbPopup);

    mousePressLocation = Background;

    if (dismissPolicy & HbPopup::TapOutside) {

        q->close();

    }

}

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

                }

            }

        }

    }

    // reset mousePressLocation

    mousePressLocation = None;

}