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

**

** 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 HbWidgets 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 <QGraphicsSceneMouseEvent>

#include <QTimer>

#include <QGraphicsScene>

#include <QCoreApplication>

#include <QtGlobal>

#include <QGesture>

#include <QGestureEvent>

#include <hbnotificationdialog.h>

#include <hbnotificationdialog_p.h>

#include <hblabel.h>

#include <hbmainwindow.h>

#include <hbwidgetsequentialshow_p.h>

#include <hbdevicedialogserverstatus_p.h>

#include <hbtapgesture.h>

#include <hbpangesture.h>

#include <hbwidgetfeedback.h>

#ifdef HB_EFFECTS

#include "hbeffectinternal_p.h"

#endif

#include <hbstyleoptionnotificationdialog_p.h>

#include "hbnotificationdialogcontent_p.h"

#define H_MARGIN QString("hb-param-margin-gene-middle-horizontal")

#define V_MARGIN QString("hb-param-margin-gene-middle-vertical")

// Container to encapsulate device dialog server status and sequential show

class SequentialShow : public HbWidgetSequentialShow

{

public:

    SequentialShow();

    static bool allowNotification(void *serverStatus);

private:

    HbDeviceDialogServerStatus mServerStatus;

};

// Constructor

SequentialShow::SequentialShow() :

    HbWidgetSequentialShow(SequentialShow::allowNotification, &mServerStatus), mServerStatus(false)

{

    connect(&mServerStatus, SIGNAL(statusChanged()), SLOT(externalStatusChanged()));

}

// Return true if notification dialog can be shown

bool SequentialShow::allowNotification(void *serverStatus)

{

    HbDeviceDialogServerStatus* srvStatus =

        reinterpret_cast<HbDeviceDialogServerStatus*>(serverStatus);

    HbDeviceDialogServerStatus::StatusFlags flags = srvStatus->status();

    bool allow = (flags & HbDeviceDialogServerStatus::ShowingDialog) ==

        HbDeviceDialogServerStatus::NoFlags;

    // Monitor changes only when notifications are not allowed

    srvStatus->enableMonitoring(!allow);

    return allow;

}

// Singleton

Q_GLOBAL_STATIC(SequentialShow, notificationDialogSequentialShowInstance)

static SequentialShow *sequentialShowInstance()

{

    return notificationDialogSequentialShowInstance();

}

/*!

    @hbwidgets

    \class HbNotificationDialog

*/

/*!

    \fn void HbNotificationDialog::activated();

 */

/*!

 */

HbNotificationDialog::HbNotificationDialog() : HbDialog(*new HbNotificationDialogPrivate, 0)

{

    Q_D(HbNotificationDialog);

    d->q_ptr = this;

    setFocusPolicy(Qt::NoFocus);

    d->timeout = HbDialog::StandardTimeout;

    // Preferred position from style

    qreal hMargin = 0;

    qreal vMargin = 0;

    if ((style()->parameter(H_MARGIN, hMargin)) &&

        (style()->parameter(V_MARGIN, vMargin))) {

        setPreferredPos(QPointF(hMargin, vMargin));

    }

    setModal(false);

    setBackgroundFaded(false);

    setDismissPolicy(HbPopup::NoDismiss);

    setTimeout(HbPopup::StandardTimeout);

    d->setBackgroundStyle();

    grabGesture(Qt::PanGesture);

    grabGesture(Qt::TapGesture);

#ifdef HB_EFFECTS

    HbEffectInternal::add(this, "notificationdialog_appear", "appear");

    HbEffectInternal::add(this, "notificationdialog_disappear", "disappear");

#endif

}

/*!

    Destructor.

 */

HbNotificationDialog::~HbNotificationDialog()

{

    Q_D(HbNotificationDialog);

    if (d->sequentialShow) {

        sequentialShowInstance()->remove(this);

    }

}

/*!

    Enable user interaction on dialog.

    \sa isTouchActivating()

*/

void HbNotificationDialog::enableTouchActivation(bool enabled)

{

    Q_D(HbNotificationDialog);

    d->isTouchActivating = enabled;

    if (d->content) {

        d->content->enableTouchActivation(enabled);

    }

}

/*!

    Returns true if user interaction is enabled.

    \sa enableTouchActivation()

*/

bool HbNotificationDialog::isTouchActivating() const

{

    Q_D(const HbNotificationDialog);

    return d->isTouchActivating;

}

/*!

*/

void HbNotificationDialog::launchDialog(const QString &title, const QString &text, QGraphicsScene* scene)

{

    HbNotificationDialog *self = new HbNotificationDialog();

    if (scene) {

        scene->addItem(self);

    }

    self->setAttribute(Qt::WA_DeleteOnClose, true);

    self->setText(text);

    self->setTitle(title);

    self->show();

}

/*!

*/

void HbNotificationDialog::launchDialog(const QString &title, QGraphicsScene* scene)

{

    HbNotificationDialog *self = new HbNotificationDialog();

    if (scene) {

        scene->addItem(self);

    }

    self->setAttribute(Qt::WA_DeleteOnClose, true);

    self->setTitle(title);

    self->show();

}

/*!

*/

void HbNotificationDialog::launchDialog(const HbIcon &icon, const QString &title,

{

    HbNotificationDialog *self = new HbNotificationDialog();

    if (scene) {

        scene->addItem(self);

    }

    self->setAttribute(Qt::WA_DeleteOnClose, true);

    self->setIcon(icon);

    self->setText(text);

    self->setTitle(title);

    self->show();

}

/*!

    \sa setTitle()

*/

QString HbNotificationDialog::title() const

{

    Q_D(const HbNotificationDialog);

    if(d->content) {

        return d->content->title();

    } else {

        return QString();

    }

}

/*!

    \sa title()

*/

void HbNotificationDialog::setTitle(const QString& title)

{

    Q_D(HbNotificationDialog);

    d->checkAndCreateContentWidget();

    d->content->setTitle(title);

    d->setNotificationDialogContent();

}

/*!

    \sa setText()

*/

QString HbNotificationDialog::text() const

{

    Q_D(const HbNotificationDialog);

    if(d->content) {

        return d->content->text();

    } else {

        return QString();

    }

}

/*!

*/

void HbNotificationDialog::setText(const QString& text)

{

    Q_D(HbNotificationDialog);

    d->checkAndCreateContentWidget();

    d->content->setText(text);

    if (text.isEmpty()) {

        d->titleTextWrapping = Hb::TextWordWrap;

    } else {

        d->titleTextWrapping = Hb::TextNoWrap;

    }

    d->setNotificationDialogContent();

}

/*!

    \sa setIcon()

*/

HbIcon HbNotificationDialog::icon() const

{

    Q_D(const HbNotificationDialog);

    if(d->content) {

        return d->content->icon();

    } else {

        return QString();

    }

}

/*!

    \sa icon()

*/

void HbNotificationDialog::setIcon(const HbIcon& icon)

{

    Q_D(HbNotificationDialog);

    d->checkAndCreateContentWidget();

    d->content->setIcon( icon );

    d->setNotificationDialogContent();

}

/*!

    The default is Hb::TextWordWrap.

*/

Hb::TextWrapping HbNotificationDialog::titleTextWrapping() const

{

    Q_D(const HbNotificationDialog);

    return d->titleTextWrapping;

}

/*!

*/

void HbNotificationDialog::setTitleTextWrapping(Hb::TextWrapping wrapping)

{

    Q_D(HbNotificationDialog);

    if (d->titleTextWrapping != wrapping) {

        d->titleTextWrapping = wrapping;

        if (d->content) {

            d->content->setTitleTextWrapping(d->titleTextWrapping);

        }

        d->doLayout();

    }

}

/*!

    This setting is enabled by default. 

    \sa isSequentialShow()

*/

void HbNotificationDialog::setSequentialShow(bool sequentially)

{

    Q_D(HbNotificationDialog);

    if (d->sequentialShow != sequentially && !sequentially) {

        sequentialShowInstance()->remove(this);

    }

    d->sequentialShow = sequentially;

}

/*!

    Returns the sequential show setting.

    \sa setSequentialShow()

*/

bool HbNotificationDialog::isSequentialShow() const

{

    Q_D(const HbNotificationDialog);

    return d->sequentialShow;

}

/*!

 Constructor required by the shared d-pointer paradigm.

*/

HbNotificationDialog::HbNotificationDialog(HbNotificationDialogPrivate &dd, QGraphicsItem *parent) :

    HbDialog(dd, parent)

{

}

/*!

    \reimp

*/

QGraphicsItem *HbNotificationDialog::primitive(const QString &itemName) const

{

    Q_D(const HbNotificationDialog);

    if (itemName == "") {

        return 0;

    } else {

        if(d->content) {

            return d->content->primitive(itemName);

        } else {

             return HbWidget::primitive(itemName);

        }

    }

}

void HbNotificationDialog::gestureEvent(QGestureEvent *event)

{

    Q_D(HbNotificationDialog);

    if(HbTapGesture *tap = qobject_cast<HbTapGesture*>(event->gesture(Qt::TapGesture))) {

        if(tap->state() == Qt::GestureStarted) {

            HbWidgetFeedback::triggered(this, Hb::InstantPressed);

            d->stopTimeout();

        } else if(tap->state() == Qt::GestureFinished) {

            if (d->isTouchActivating) {

                HbWidgetFeedback::triggered(this, Hb::InstantReleased);

                emit activated();

            }

            close();

        }

    } else if( HbPanGesture *pan = qobject_cast<HbPanGesture*>(event->gesture(Qt::PanGesture))) {

        if(pan->state() == Qt::GestureFinished){

            close();

        }

    }

}

// Widget is about to hide. Closing effect has ended,

void HbNotificationDialog::hideEvent(QHideEvent *event)

{

    HbDialog::hideEvent(event);

    HbMainWindow* mainWnd = mainWindow();

    if (mainWnd) {

        disconnect(mainWnd, SIGNAL(orientationChanged(Qt::Orientation)),this, SLOT(orientationChanged(Qt::Orientation)));

    }

}

// Widget is about to show

void HbNotificationDialog::showEvent(QShowEvent *event)

{