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

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, 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 qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

#include "qcursor.h"

#include "qapplication.h"

#include "qapplication_p.h"

#include "qpainter.h"

#include "qbitmap.h"

#include "qimage.h"

#include "qhash.h"

#include "qstack.h"

#include "qlayout.h"

#include "qtextcodec.h"

#include "qinputcontext.h"

#include "qdesktopwidget.h"

#include "qwsdisplay_qws.h"

#include "private/qwsdisplay_qws_p.h"

#include "qscreen_qws.h"

#include "qwsmanager_qws.h"

#include <private/qwsmanager_p.h>

#include <private/qbackingstore_p.h>

#include <private/qwindowsurface_qws_p.h>

#include <private/qwslock_p.h>

#include "qpaintengine.h"

#include "qdebug.h"

#include "qwidget_p.h"

QT_BEGIN_NAMESPACE

QT_USE_NAMESPACE

extern int *qt_last_x;

extern int *qt_last_y;

extern WId qt_last_cursor;

extern bool qws_overrideCursor;

extern QWidget *qt_pressGrab;

extern QWidget *qt_mouseGrb;

static QWidget *keyboardGrb = 0;

static int takeLocalId()

{

    static int n=-1000;

    return --n;

}

class QWSServer;

extern QWSServer *qwsServer;

static inline bool isServerProcess()

{

    return (qwsServer != 0);

}

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

  QWidget member functions

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

void QWidgetPrivate::create_sys(WId window, bool initializeWindow, bool /*destroyOldWindow*/)

{

    Q_Q(QWidget);

    Qt::WindowType type = q->windowType();

    // Make sure the WindowTitleHint is on if any of the title bar hints are set

    // Note: This might be moved to cross-platform QWidgetPrivate::adjustFlags()

    if (  !(data.window_flags & Qt::CustomizeWindowHint) && (

           (data.window_flags & Qt::WindowSystemMenuHint) ||

           (data.window_flags & Qt::WindowContextHelpButtonHint) ||

           (data.window_flags & Qt::WindowMinimizeButtonHint) ||

           (data.window_flags & Qt::WindowMaximizeButtonHint) ||

           (data.window_flags & Qt::WindowCloseButtonHint) ) ) {

        data.window_flags |= Qt::WindowTitleHint;

    }

    // Decoration plugins on QWS don't support switching on the close button on its own

    if (data.window_flags & Qt::WindowCloseButtonHint)

        data.window_flags |= Qt::WindowSystemMenuHint;

    Qt::WindowFlags flags = data.window_flags;

    data.alloc_region_index = -1;

    // we don't have a "Drawer" window type

    if (type == Qt::Drawer) {

        type = Qt::Widget;

        flags &= ~Qt::WindowType_Mask;

    }

    bool topLevel = (flags & Qt::Window);

    bool popup = (type == Qt::Popup);

    bool dialog = (type == Qt::Dialog

                   || type == Qt::Sheet

                   || (flags & Qt::MSWindowsFixedSizeDialogHint));

    bool desktop = (type == Qt::Desktop);

    bool tool = (type == Qt::Tool || type == Qt::SplashScreen || type == Qt::ToolTip);

#ifndef QT_NO_WARNING_OUTPUT

    static bool toolWarningShown = false;

    if (!toolWarningShown && type == Qt::Tool && !(flags & Qt::FramelessWindowHint)) {

        qWarning("Qt for Embedded Linux " QT_VERSION_STR " does not support tool windows with frames.\n"

                 "This behavior will change in a later release. To ensure compatibility with\n"

                 "future versions, use (Qt::Tool | Qt::FramelessWindowHint).");

        toolWarningShown = true;

    }

#endif

    WId           id;

    QWSDisplay* dpy = QWidget::qwsDisplay();

    if (!window)                                // always initialize

        initializeWindow = true;

    // use the size of the primary screen to determine the default window size

    QList<QScreen *> screens = qt_screen->subScreens();

    if (screens.isEmpty())

        screens.append(qt_screen);

    int sw = screens[0]->width();

    int sh = screens[0]->height();

    if (desktop) {                                // desktop widget

        dialog = popup = false;                        // force these flags off

        data.crect.setRect(0, 0, sw, sh);

    } else if (topLevel && !q->testAttribute(Qt::WA_Resized)) {

        int width = sw / 2;

        int height = 4 * sh / 10;

        if (extra) {

            width = qMax(qMin(width, extra->maxw), extra->minw);

            height = qMax(qMin(height, extra->maxh), extra->minh);

        }

        data.crect.setSize(QSize(width, height));

    }

    if (window) {                                // override the old window

        id = window;

        setWinId(window);

    } else if (desktop) {                        // desktop widget

        id = (WId)-2;                                // id = root window

#if 0

        QWidget *otherDesktop = q->find(id);        // is there another desktop?

        if (otherDesktop && otherDesktop->testWFlags(Qt::WPaintDesktop)) {

            otherDesktop->d_func()->setWinId(0);        // remove id from widget mapper

            setWinId(id);                        // make sure otherDesktop is

            otherDesktop->d_func()->setWinId(id);        //   found first

        } else

#endif

        {

            setWinId(id);

        }

    } else {

        id = topLevel ? dpy->takeId() : takeLocalId();

        setWinId(id);                                // set widget id/handle + hd

    }

    bool hasFrame = true;

    if (topLevel) {

        if (desktop || popup || tool || q->testAttribute(Qt::WA_DontShowOnScreen))

            hasFrame = false;

        else

            hasFrame = !(flags & Qt::FramelessWindowHint);

    }

    if (desktop) {

        q->setAttribute(Qt::WA_WState_Visible);

    } else if (topLevel) {                        // set X cursor

        //QCursor *oc = QApplication::overrideCursor();

        if (initializeWindow) {

            //XXX XDefineCursor(dpy, winid, oc ? oc->handle() : cursor().handle());

        }

        QWidget::qwsDisplay()->nameRegion(q->internalWinId(), q->objectName(), q->windowTitle());

    }

    if (topLevel) {

        createTLExtra();

        QTLWExtra *topextra = extra->topextra;

#ifndef QT_NO_QWS_MANAGER

        if (hasFrame) {

            // get size of wm decoration and make the old crect the new frect

            QRect cr = data.crect;

            QRegion r = QApplication::qwsDecoration().region(q, cr) | cr;

            QRect br(r.boundingRect());

            topextra->frameStrut.setCoords(cr.x() - br.x(),

                                                  cr.y() - br.y(),

                                                  br.right() - cr.right(),

                                                  br.bottom() - cr.bottom());

            if (!q->testAttribute(Qt::WA_Moved) || topextra->posFromMove)

                data.crect.translate(topextra->frameStrut.left(), topextra->frameStrut.top());

            if (!topData()->qwsManager) {

                topData()->qwsManager = new QWSManager(q);

                if((q->data->window_state & ~Qt::WindowActive) == Qt::WindowMaximized)

                    topData()->qwsManager->maximize();

            }

        } else if (topData()->qwsManager) {

            delete topData()->qwsManager;

            topData()->qwsManager = 0;

            data.crect.translate(-topextra->frameStrut.left(), -topextra->frameStrut.top());

            topextra->frameStrut.setCoords(0, 0, 0, 0);

        }

#endif

        if (!topextra->caption.isEmpty())

            setWindowTitle_helper(topextra->caption);

        //XXX If we are session managed, inform the window manager about it

    } else {

        if (extra && extra->topextra)        { // already allocated due to reparent?

            extra->topextra->frameStrut.setCoords(0, 0, 0, 0);

        }

        //updateRequestedRegion(mapToGlobal(QPoint(0,0)));

    }

}

void QWidget::destroy(bool destroyWindow, bool destroySubWindows)

{

    Q_D(QWidget);

    if (!isWindow() && parentWidget())

        parentWidget()->d_func()->invalidateBuffer(d->effectiveRectFor(geometry()));

    d->deactivateWidgetCleanup();

    if (testAttribute(Qt::WA_WState_Created)) {

        setAttribute(Qt::WA_WState_Created, false);

        QObjectList childObjects =  children();

        for (int i = 0; i < childObjects.size(); ++i) {

            QObject *obj = childObjects.at(i);

            if (obj->isWidgetType())

                static_cast<QWidget*>(obj)->destroy(destroySubWindows,

                                                     destroySubWindows);

        }

        releaseMouse();

        if (qt_pressGrab == this)

          qt_pressGrab = 0;

        if (keyboardGrb == this)

            releaseKeyboard();

        if (testAttribute(Qt::WA_ShowModal))                // just be sure we leave modal

            QApplicationPrivate::leaveModal(this);

        else if ((windowType() == Qt::Popup))

            qApp->d_func()->closePopup(this);

        if (d->ic) {

            delete d->ic;

            d->ic =0;

        } else {

            // release previous focus information participating with

            // preedit preservation of qic -- while we still have a winId

            QInputContext *qic = inputContext();

            if (qic)

                qic->widgetDestroyed(this);

        }

        if ((windowType() == Qt::Desktop)) {

        } else {

            if (parentWidget() && parentWidget()->testAttribute(Qt::WA_WState_Created)) {

                d->hide_sys();

            }

            if (destroyWindow && isWindow()) {

                if (d->extra && d->extra->topextra && d->extra->topextra->backingStore)

                    d->extra->topextra->backingStore->windowSurface->setGeometry(QRect());

                qwsDisplay()->destroyRegion(internalWinId());

            }

        }

        QT_TRY {

            d->setWinId(0);

        } QT_CATCH (const std::bad_alloc &) {

            // swallow - destructors must not throw

        }

    }

}

void QWidgetPrivate::setParent_sys(QWidget *newparent, Qt::WindowFlags f)

{

    Q_Q(QWidget);

    bool wasCreated = q->testAttribute(Qt::WA_WState_Created);

     if (q->isVisible() && q->parentWidget() && parent != q->parentWidget())

        q->parentWidget()->d_func()->invalidateBuffer(effectiveRectFor(q->geometry()));

#ifndef QT_NO_CURSOR

    QCursor oldcurs;

    bool setcurs=q->testAttribute(Qt::WA_SetCursor);

    if (setcurs) {

        oldcurs = q->cursor();

        q->unsetCursor();

    }

#endif

    WId old_winid = data.winid;

    if ((q->windowType() == Qt::Desktop))

        old_winid = 0;

    if (!q->isWindow() && q->parentWidget() && q->parentWidget()->testAttribute(Qt::WA_WState_Created))

        hide_sys();

    setWinId(0);

    if (parent != newparent) {

        QWidget *oldparent = q->parentWidget();

        QObjectPrivate::setParent_helper(newparent);

        if (oldparent) {

//            oldparent->d_func()->setChildrenAllocatedDirty();

//            oldparent->data->paintable_region_dirty = true;

        }

        if (newparent) {

//            newparent->d_func()->setChildrenAllocatedDirty();

//            newparent->data->paintable_region_dirty = true;

            //@@@@@@@

        }

    }

    Qt::FocusPolicy fp = q->focusPolicy();

    QSize    s            = q->size();

    //QBrush   bgc    = background();                        // save colors

    bool explicitlyHidden = q->testAttribute(Qt::WA_WState_Hidden) && q->testAttribute(Qt::WA_WState_ExplicitShowHide);

    data.window_flags = f;

    q->setAttribute(Qt::WA_WState_Created, false);

    q->setAttribute(Qt::WA_WState_Visible, false);

    q->setAttribute(Qt::WA_WState_Hidden, false);

    adjustFlags(data.window_flags, q);

    // keep compatibility with previous versions, we need to preserve the created state

    // (but we recreate the winId for the widget being reparented, again for compatibility)

    if (wasCreated || (!q->isWindow() && newparent->testAttribute(Qt::WA_WState_Created)))

        createWinId();

    if (q->isWindow() || (!newparent || newparent->isVisible()) || explicitlyHidden)

        q->setAttribute(Qt::WA_WState_Hidden);

    q->setAttribute(Qt::WA_WState_ExplicitShowHide, explicitlyHidden);

    if (q->isWindow()) {

        QRect fs = frameStrut();

        data.crect = QRect(fs.left(), fs.top(), s.width(), s.height());

        if ((data.window_flags & Qt::FramelessWindowHint) && extra && extra->topextra)

            extra->topextra->frameStrut.setCoords(0, 0, 0, 0);

    } else {

        data.crect = QRect(0, 0, s.width(), s.height());

    }

    q->setFocusPolicy(fp);

    if (extra && !extra->mask.isEmpty()) {

        QRegion r = extra->mask;

        extra->mask = QRegion();

        q->setMask(r);

    }

    if ((int)old_winid > 0) {

        QWidget::qwsDisplay()->destroyRegion(old_winid);

        extra->topextra->backingStore->windowSurface->setGeometry(QRect());

    }

#ifndef QT_NO_CURSOR

    if (setcurs) {

        q->setCursor(oldcurs);

    }

#endif

}

QPoint QWidget::mapToGlobal(const QPoint &pos) const

{

    int           x=pos.x(), y=pos.y();

    const QWidget* w = this;

    while (w) {

        x += w->data->crect.x();

        y += w->data->crect.y();

        w = w->isWindow() ? 0 : w->parentWidget();

    }

    return QPoint(x, y);

}

QPoint QWidget::mapFromGlobal(const QPoint &pos) const

{

    int           x=pos.x(), y=pos.y();

    const QWidget* w = this;

    while (w) {

        x -= w->data->crect.x();

        y -= w->data->crect.y();

        w = w->isWindow() ? 0 : w->parentWidget();

    }

    return QPoint(x, y);

}

#if 0 // #####

void QWidget::setMicroFocusHint(int x, int y, int width, int height,

                                 bool text, QFont *)

{

    if (QRect(x, y, width, height) != microFocusHint()) {

        d->createExtra();

        d->extra->micro_focus_hint.setRect(x, y, width, height);

    }

#ifndef QT_NO_QWS_INPUTMETHODS

    if (text) {

        QWidget *tlw = window();

        int winid = tlw->internalWinId();

        QPoint p(x, y + height);

        QPoint gp = mapToGlobal(p);

        QRect r = QRect(mapToGlobal(QPoint(0,0)),

                         size());

        r.setBottom(tlw->geometry().bottom());

        //qDebug("QWidget::setMicroFocusHint %d %d %d %d", r.x(),

        //        r.y(), r.width(), r.height());

        QInputContext::setMicroFocusWidget(this);

        qwsDisplay()->setIMInfo(winid, gp.x(), gp.y(), r);

        //send font info,  ###if necessary

        qwsDisplay()->setInputFont(winid, font());

    }

#endif

}

#endif

void QWidgetPrivate::updateSystemBackground() {}

#ifndef QT_NO_CURSOR

void QWidgetPrivate::setCursor_sys(const QCursor &cursor)

{

    Q_UNUSED(cursor);

    Q_Q(QWidget);

    if (q->isVisible())

        updateCursor();

}

void QWidgetPrivate::unsetCursor_sys()

{

    Q_Q(QWidget);

    if (q->isVisible())

        updateCursor();

}

#endif //QT_NO_CURSOR

void QWidgetPrivate::setWindowTitle_sys(const QString &caption)

{

    Q_Q(QWidget);

    QWidget::qwsDisplay()->setWindowCaption(q, caption);

}

void QWidgetPrivate::setWindowIcon_sys(bool /*forceReset*/)

{

#if 0

     QTLWExtra* x = d->topData();

     delete x->icon;

     x->icon = 0;

    QBitmap mask;

    if (unscaledPixmap.isNull()) {

    } else {

        QImage unscaledIcon = unscaledPixmap.toImage();

        QPixmap pixmap =

            QPixmap::fromImage(unscaledIcon.scale(16, 16, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));

        x->icon = new QPixmap(pixmap);

        mask = pixmap.mask() ? *pixmap.mask() : pixmap.createHeuristicMask();

    }

#endif

}

void QWidgetPrivate::setWindowIconText_sys(const QString &iconText)

{

    Q_UNUSED(iconText);

}

void QWidget::grabMouse()

{

    if (qt_mouseGrb)

        qt_mouseGrb->releaseMouse();

    qwsDisplay()->grabMouse(this,true);

    qt_mouseGrb = this;

    qt_pressGrab = 0;

}

#ifndef QT_NO_CURSOR

void QWidget::grabMouse(const QCursor &cursor)

{

    if (qt_mouseGrb)

        qt_mouseGrb->releaseMouse();

    qwsDisplay()->grabMouse(this,true);

    qwsDisplay()->selectCursor(this, cursor.handle());

    qt_mouseGrb = this;

    qt_pressGrab = 0;

}

#endif

void QWidget::releaseMouse()

{

    if (qt_mouseGrb == this) {