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

**

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

#include <QGraphicsWidget>

#include <QGraphicsSceneMouseEvent>

#include <QStyleOptionGraphicsItem>

#include <QInputContext>

#include <QPointer>

#include "hbinputregioncollector_p.h"

#include "hbinstance.h"

#include "hbwidget.h"

#include "hbview.h"

#include "hbstackedlayout.h"

#if defined (Q_OS_SYMBIAN)

#include <coemain.h>

#include <coecntrl.h>

#include <e32cmn.h>

TRect qt_QRect2TRect(const QRectF &rect)

{

    TRect trect;

    trect.SetRect(rect.topLeft().x(), rect.topLeft().y(),

                  rect.bottomRight().x() + 1, rect.bottomRight().y() + 1);

    return trect;

}

Q_DECLARE_TYPEINFO(TRect, Q_MOVABLE_TYPE);

#endif

class HbProxyWindow: public QWidget

{

public:

    HbProxyWindow()

    {

        setGeometry(0,0,0,0);

    }

    void setWindow(QWidget* window)

    {

        this->window = window;

        if (window) {

            window->setParent(this);

        }

    }

    ~HbProxyWindow()

    {

        if (window) {

            window->setParent(0);

        }

    }

private:

    QPointer<QWidget> window;

};

class HbInputTransparentWindow : public HbWidget

{

public:

    HbInputTransparentWindow(QGraphicsItem *parent = 0);

    ~HbInputTransparentWindow();

    enum { Type = Hb::ItemType_TransparentWindow };

    int type() const {

        return Type;

    }

    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);

};

HbInputTransparentWindow::HbInputTransparentWindow(QGraphicsItem *parent) :

    HbWidget(parent)

{

    setFlag(QGraphicsItem::ItemUsesExtendedStyleOption, true);

}

/*!

    Destructs the transparent window.

 */

HbInputTransparentWindow::~HbInputTransparentWindow()

{

}

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

{

    Q_UNUSED(widget)

    QPainter::CompositionMode compositionMode = painter->compositionMode();

    painter->setCompositionMode(QPainter::CompositionMode_Source);

    painter->fillRect(option->exposedRect, QColor(0, 0, 0, 0));

    painter->setCompositionMode(compositionMode);

}

class HbInputMainWindowPrivate

{

public:

 HbInputMainWindowPrivate(HbInputMainWindow *owner)

    :q_ptr(owner), mLastFocusedWidget(0), mSpellQueryLaunched(false), mProxyWindow(0), mIsInputWindowFocusLocked(false)

    {

    }

    ~HbInputMainWindowPrivate();

    HbInputMainWindow *q_ptr;

    QPointer<QWidget> mLastFocusedWidget;

    QRegion mMask;

    bool mSpellQueryLaunched;

    QPointer<HbProxyWindow > mProxyWindow;

    bool mIsInputWindowFocusLocked;

};

HbInputMainWindowPrivate::~HbInputMainWindowPrivate()

{

    delete mProxyWindow;

}

/*

creates an instance of HbInputMainWindow.

*/

HbInputMainWindow *HbInputMainWindow::instance()

{

    static HbInputMainWindow *mainWindow = new HbInputMainWindow();

    return mainWindow;

}

HbInputMainWindow::~HbInputMainWindow()

{

    delete d_ptr;

}

// constructor.

HbInputMainWindow::HbInputMainWindow()

// HbMainWindow creates a background QGraphicsItem, which has the background image. we need to hide it that.

    : HbMainWindow(0, Hb::WindowFlagTransparent), d_ptr(new HbInputMainWindowPrivate(this))

{

    // We need a window which is of type Qt::Window flag at the same time does not show

    // any decorators Qt::Tool seems to be the option, and we want this window to be always on top so Qt::WindowStaysOnTopHint.

    // And since transparency requires to have a frameless window we are setting that too.

    setWindowFlags(Qt::WindowStaysOnTopHint | Qt::Tool | Qt::FramelessWindowHint);

    // By default QGraphicsView has a background which is white in color (Other controls eg. QPushButton

    // have a grey background), we need to make that transparent too.

    setStyleSheet("background: transparent");

    // No focus is necessary as we don't want the hbmainwindw to steal focus.

    setFocusPolicy(Qt::NoFocus);

    // add transparency begin.

    HbView *view = new HbView;

    view->hideItems(Hb::AllItems);

    view->setContentFullScreen();

#if defined (Q_OS_SYMBIAN)

    CCoeControl *c = effectiveWinId();

    c->SetFocusing(false);

    RWindow *rw = static_cast<RWindow *>(c->DrawableWindow());

    rw->SetRequiredDisplayMode(EColor16MA);

    TInt err = rw->SetTransparencyAlphaChannel();

    if (err == KErrNone) {

        rw->SetBackgroundColor(~0);

    }

#endif // Q_OS_SYMBIAN

    HbInputTransparentWindow *transparentWindow = new HbInputTransparentWindow;

    HbStackedLayout *stackedLayout = new HbStackedLayout;

    stackedLayout->addItem(transparentWindow);

    view->setLayout(stackedLayout);

    addView(view);

    // add transparency ends.

    connect(HbInputRegionCollector::instance(), SIGNAL(updateRegion(QRegion)), this, SLOT(updateRegion(QRegion)));

    // QApplication signal for getting notification of any focus change. If therer

    // is a switch between application window and HbInputMainWindow then we need to

    // set the focus back to the application window, if we don't do that it will

    // result in focusLost call inside framework.

    connect(qApp, SIGNAL(focusChanged(QWidget *, QWidget *)),

            this, SLOT(saveFocusWidget(QWidget *, QWidget *)));

}

void HbInputMainWindow::updateRegion(QRegion region)

{

    d_ptr->mMask = region;

#if defined (Q_OS_SYMBIAN)

    RWindowBase *rwindow = effectiveWinId()->DrawableWindow();

    if (region.isEmpty()) {

        TRegionFix<1> tregion(TRect(TPoint(0, 0), TSize(0, 0)));

        rwindow->SetShape(tregion);

    } else {

        // Using QVector assumes the memory layout is the same as RRegion 

        QVector<QRect> rects = region.rects(); 

        QVector<TRect> trects(rects.count()); 

        RRegion rregion;

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

            rregion.AddRect(qt_QRect2TRect(rects.at(i)));

        }

        if (!rregion.CheckError())

            rwindow->SetShape(rregion); 

   }

#else

    setMask(region);

#endif

}

/*

we should always set the focus back to the application window.

*/

bool HbInputMainWindow::event(QEvent *e)

{

    switch (e->type()) {

    case QEvent::WindowActivate:

        if (d_ptr->mLastFocusedWidget && !d_ptr->mIsInputWindowFocusLocked) {

            qApp->setActiveWindow(d_ptr->mLastFocusedWidget);

        }

        break;

    default:

        break;

    }

    return HbMainWindow::event(e);

}

/*

This function checks for any modal dialog present in the HbGraphicsScene by checking DynamicPropertyChange

and blocks the events to the application window by launching a widget which sits exactly in between the applicaion

and HbInputMainWindow.

*/

bool HbInputMainWindow::eventFilter(QObject *obj, QEvent *event)

{

    // we need to only check for spontaneous events.

    if (event->spontaneous() && (event->type() == QEvent::MouseButtonPress || event->type() == QEvent::MouseButtonRelease)) {

        QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);

        if (mouseEvent) {

            // get the top level widget at the point, and see if that widget is a HbMainWindow,

            // If it is a HbMainWindow then do not do any thing, as events will propagate

            // correctly. But when it is clicked inside application window then send the event to

            // viewport as we might want to close a popup.

            if (!d_ptr->mMask.contains(mouseEvent->globalPos())) {

                qApp->sendEvent(viewport(), event);

            }

        }

    } else if(event->spontaneous() && event->type() == QEvent::WindowActivate) {

        if(d_ptr->mIsInputWindowFocusLocked && (qApp->activeWindow()!= this)) {

            qApp->setActiveWindow(this);

        }

    }

    return HbMainWindow::eventFilter(obj, event);

}

/*

Since hbmainwindow is overlapped on top of the application window, we need to

set the focus back to the application window. Not doing so will result in a focus

lost.

*/

void HbInputMainWindow::saveFocusWidget(QWidget * /*Old*/, QWidget *newFocus)

{

    if (newFocus && !this->isAncestorOf(newFocus)) {

        d_ptr->mLastFocusedWidget = newFocus;

    }

}

void HbInputMainWindow::showInputWindow()

{

    // installing event filter to the application.. this is needed to get

    // the events happening in other vanilla windows.

    qApp->installEventFilter(this);

    QInputContext *ic = qApp->inputContext();

    QWidget *fw = ic ? ic->focusWidget() : 0 ;

    QWidget *win = 0;

    if (fw) {

       win = fw->window();

    }

#ifdef Q_WS_WIN

    // As in windows OS HbMainWindow can come anywhere on the screen.

    // so we need to launch main window exactly at the top windows position.

    if (win) {

        move(win->frameGeometry().x(), win->pos().y());

    }

#endif

    HbInputRegionCollector::instance()->setEnabled(true);

    if (win && win->windowModality() != Qt::NonModal) {

        if (!d_ptr->mProxyWindow) {

            d_ptr->mProxyWindow = new HbProxyWindow();

        }

        d_ptr->mProxyWindow->setWindow(this);

        // since the focused widget is inside a modal dialog which blocks events to other_window.

        // and since hbinputmainwindow also comes under the other_window. It does will not get the 

        // mouse click events.

        d_ptr->mProxyWindow->setParent(win);

        // setParent resets the window flags, so we have to set the flags once again before show() is called.

        setWindowFlags(Qt::WindowStaysOnTopHint | Qt::Tool | Qt::FramelessWindowHint);

        show();

    } else {

        if (d_ptr->mProxyWindow && d_ptr->mProxyWindow->isAncestorOf(this)) {

            d_ptr->mProxyWindow->setParent(0);

            d_ptr->mProxyWindow->setWindow(0);

            setParent(0);

            // setParent resets the window flags, so we have to set the flags once again before show is called.

            setWindowFlags(Qt::WindowStaysOnTopHint | Qt::Tool | Qt::FramelessWindowHint);

        }

        show();

    }

#if defined(Q_OS_SYMBIAN)

    // this is done to come on top of all the controls in symbian OS, done to overlap soft keys as well.

    RWindow *rWindow = static_cast<RWindow *>(effectiveWinId()->DrawableWindow());

    const int positionForeground(0);

    rWindow->SetOrdinalPosition(positionForeground);

#endif

}

void HbInputMainWindow::hideInputWindow()

{

    if (d_ptr->mIsInputWindowFocusLocked) {

        return;

    }

    if (isVisible()) {

        hide();

#if defined(Q_OS_SYMBIAN)

        RWindow *rWindow = static_cast<RWindow *>(effectiveWinId()->DrawableWindow());

        const int positionBackground(-1);

        rWindow->SetOrdinalPosition(positionBackground);

#endif

    }

    HbInputRegionCollector::instance()->setEnabled(false);

    // installing event filter to the application.. this is needed to get

    // the events happening in other vanilla windows.

    qApp->removeEventFilter(this);

}

void HbInputMainWindow::lockFocus()

{

    // lock only when HbinputMainWindow is active.

    if (!isVisible())

        return;

    d_ptr->mIsInputWindowFocusLocked = true;

    setFocus(Qt::OtherFocusReason);

    qApp->setActiveWindow(this);

#if defined(Q_OS_SYMBIAN)

    // this is done to come on top of all the controls in symbian OS, done to overlap soft keys as well.

    RWindow *rWindow = static_cast<RWindow *>(effectiveWinId()->DrawableWindow());

    const int positionForeground(0);

    // Now window ordinal position works with latest symbian release. So giving back this window

    // a FEP priority. This will enable this window to come on top of any softkeys.

#endif

}

void HbInputMainWindow::unlockFocus()

{

    if (!isVisible())

        return;

    d_ptr->mIsInputWindowFocusLocked = false;

    if (d_ptr->mLastFocusedWidget) {

        qApp->setActiveWindow(d_ptr->mLastFocusedWidget);

    }

}

//EOF