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

**

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

#include "qwidget.h"

#include "qdesktopwidget.h"

#include "qapplication.h"

#include "qapplication_p.h"

#include "qnamespace.h"

#include "qpainter.h"

#include "qbitmap.h"

#include "qlayout.h"

#include "qtextcodec.h"

#include "qdatetime.h"

#include "qcursor.h"

#include "qstack.h"

#include "qcolormap.h"

#include "qdebug.h"

#include "qmenu.h"

#include "private/qmenu_p.h"

#include "private/qbackingstore_p.h"

#include "private/qwindowsurface_x11_p.h"

//extern bool qt_sendSpontaneousEvent(QObject *, QEvent *); //qapplication_x11.cpp

#include <private/qpixmap_x11_p.h>

#include <private/qpaintengine_x11_p.h>

#include "qt_x11_p.h"

#include "qx11info_x11.h"

#include <stdlib.h>

//#define ALIEN_DEBUG

// defined in qapplication_x11.cpp

//bool qt_wstate_iconified(WId);

//void qt_updated_rootinfo();

#if !defined(QT_NO_IM)

#include "qinputcontext.h"

#include "qinputcontextfactory.h"

#endif

#include "qwidget_p.h"

#define XCOORD_MAX 16383

#define WRECT_MAX 8191

QT_BEGIN_NAMESPACE

extern bool qt_nograb();

QWidget *QWidgetPrivate::mouseGrabber = 0;

QWidget *QWidgetPrivate::keyboardGrabber = 0;

void qt_net_remove_user_time(QWidget *tlw);

void qt_net_update_user_time(QWidget *tlw, unsigned long timestamp);

int qt_x11_create_desktop_on_screen = -1;

extern void qt_net_update_user_time(QWidget *tlw, unsigned long timestamp);

// MWM support

struct QtMWMHints {

    ulong flags, functions, decorations;

    long input_mode;

    ulong status;

};

enum {

    MWM_HINTS_FUNCTIONS   = (1L << 0),

    MWM_FUNC_ALL      = (1L << 0),

    MWM_FUNC_RESIZE   = (1L << 1),

    MWM_FUNC_MOVE     = (1L << 2),

    MWM_FUNC_MINIMIZE = (1L << 3),

    MWM_FUNC_MAXIMIZE = (1L << 4),

    MWM_FUNC_CLOSE    = (1L << 5),

    MWM_HINTS_DECORATIONS = (1L << 1),

    MWM_DECOR_ALL      = (1L << 0),

    MWM_DECOR_BORDER   = (1L << 1),

    MWM_DECOR_RESIZEH  = (1L << 2),

    MWM_DECOR_TITLE    = (1L << 3),

    MWM_DECOR_MENU     = (1L << 4),

    MWM_DECOR_MINIMIZE = (1L << 5),

    MWM_DECOR_MAXIMIZE = (1L << 6),

    MWM_HINTS_INPUT_MODE = (1L << 2),

    MWM_INPUT_MODELESS                  = 0L,

    MWM_INPUT_PRIMARY_APPLICATION_MODAL = 1L,

    MWM_INPUT_FULL_APPLICATION_MODAL    = 3L

};

static QtMWMHints GetMWMHints(Display *display, Window window)

{

    QtMWMHints mwmhints;

    Atom type;

    int format;

    ulong nitems, bytesLeft;

    uchar *data = 0;

    if ((XGetWindowProperty(display, window, ATOM(_MOTIF_WM_HINTS), 0, 5, false,

                            ATOM(_MOTIF_WM_HINTS), &type, &format, &nitems, &bytesLeft,

                            &data) == Success)

        && (type == ATOM(_MOTIF_WM_HINTS)

            && format == 32

            && nitems >= 5)) {

        mwmhints = *(reinterpret_cast<QtMWMHints *>(data));

    } else {

        mwmhints.flags = 0L;

        mwmhints.functions = MWM_FUNC_ALL;

        mwmhints.decorations = MWM_DECOR_ALL;

        mwmhints.input_mode = 0L;

        mwmhints.status = 0L;

    }

    if (data)

        XFree(data);

    return mwmhints;

}

static void SetMWMHints(Display *display, Window window, const QtMWMHints &mwmhints)

{

    if (mwmhints.flags != 0l) {

        XChangeProperty(display, window, ATOM(_MOTIF_WM_HINTS), ATOM(_MOTIF_WM_HINTS), 32,

                        PropModeReplace, (unsigned char *) &mwmhints, 5);

    } else {

        XDeleteProperty(display, window, ATOM(_MOTIF_WM_HINTS));

    }

}

// Returns true if we should set WM_TRANSIENT_FOR on \a w

static inline bool isTransient(const QWidget *w)

{

    return ((w->windowType() == Qt::Dialog

             || w->windowType() == Qt::Sheet

             || w->windowType() == Qt::Tool

             || w->windowType() == Qt::SplashScreen

             || w->windowType() == Qt::ToolTip

             || w->windowType() == Qt::Drawer

             || w->windowType() == Qt::Popup)

            && !w->testAttribute(Qt::WA_X11BypassTransientForHint));

}

static void do_size_hints(QWidget* widget, QWExtra *x);

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

  QWidget member functions

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

const uint stdWidgetEventMask =                        // X event mask

        (uint)(

            KeyPressMask | KeyReleaseMask |

            ButtonPressMask | ButtonReleaseMask |

            KeymapStateMask |

            ButtonMotionMask | PointerMotionMask |

            EnterWindowMask | LeaveWindowMask |

            FocusChangeMask |

            ExposureMask |

            PropertyChangeMask |

            StructureNotifyMask

       );

const uint stdDesktopEventMask =                        // X event mask

       (uint)(

           KeymapStateMask |

           EnterWindowMask | LeaveWindowMask |

           PropertyChangeMask

      );

/*

  The qt_ functions below are implemented in qwidgetcreate_x11.cpp.

*/

Window qt_XCreateWindow(const QWidget *creator,

                         Display *display, Window parent,

                         int x, int y, uint w, uint h,

                         int borderwidth, int depth,

                         uint windowclass, Visual *visual,

                         ulong valuemask, XSetWindowAttributes *attributes);

Window qt_XCreateSimpleWindow(const QWidget *creator,

                               Display *display, Window parent,

                               int x, int y, uint w, uint h, int borderwidth,

                               ulong border, ulong background);

void qt_XDestroyWindow(const QWidget *destroyer,

                        Display *display, Window window);

static void qt_insert_sip(QWidget* scrolled_widget, int dx, int dy)

{

    if (!scrolled_widget->isWindow() && !scrolled_widget->internalWinId())

        return;

    QX11Data::ScrollInProgress sip = { X11->sip_serial++, scrolled_widget, dx, dy };

    X11->sip_list.append(sip);

    XClientMessageEvent client_message;

    client_message.type = ClientMessage;

    client_message.window = scrolled_widget->internalWinId();

    client_message.format = 32;

    client_message.message_type = ATOM(_QT_SCROLL_DONE);

    client_message.data.l[0] = sip.id;

    XSendEvent(X11->display, scrolled_widget->internalWinId(), False, NoEventMask,

        (XEvent*)&client_message);

}

static int qt_sip_count(QWidget* scrolled_widget)

{

    int sips=0;

    for (int i = 0; i < X11->sip_list.size(); ++i) {

        const QX11Data::ScrollInProgress &sip = X11->sip_list.at(i);

        if (sip.scrolled_widget == scrolled_widget)

            sips++;

    }

    return sips;

}

static void create_wm_client_leader()

{

    if (X11->wm_client_leader) return;

    X11->wm_client_leader =

        XCreateSimpleWindow(X11->display,

                             QX11Info::appRootWindow(),

                             0, 0, 1, 1, 0, 0, 0);

    // set client leader property to itself

    XChangeProperty(X11->display,

                     X11->wm_client_leader, ATOM(WM_CLIENT_LEADER),

                     XA_WINDOW, 32, PropModeReplace,

                     (unsigned char *)&X11->wm_client_leader, 1);

#ifndef QT_NO_SESSIONMANAGER

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

    QByteArray session = qApp->sessionId().toLatin1();

    if (!session.isEmpty()) {

        XChangeProperty(X11->display,

                         X11->wm_client_leader, ATOM(SM_CLIENT_ID),

                         XA_STRING, 8, PropModeReplace,

                         (unsigned char *)session.data(), session.size());

    }

#endif

}

/*!

   \internal

   Update the X11 cursor of the widget w.

   \a force is true if this function is called from dispatchEnterLeave, it means that the

   mouse is actually directly under this widget.

 */

void qt_x11_enforce_cursor(QWidget * w, bool force)

{

    if (!w->testAttribute(Qt::WA_WState_Created))

        return;

    static QPointer<QWidget> lastUnderMouse = 0;

    if (force) {

        lastUnderMouse = w;

    } else if (lastUnderMouse && lastUnderMouse->effectiveWinId() == w->effectiveWinId()) {

        w = lastUnderMouse;

    } else if (!w->internalWinId()) {

        return; //the mouse is not under this widget, and it's not native, so don't change it

    }

    while (!w->internalWinId() && w->parentWidget() && !w->isWindow() && !w->testAttribute(Qt::WA_SetCursor))

        w = w->parentWidget();

    QWidget *nativeParent = w;

    if (!w->internalWinId())

        nativeParent = w->nativeParentWidget();

    // This does the same as effectiveWinId(), but since it is possible

    // to not have a native parent widget due to a special hack in

    // qwidget for reparenting widgets to a different X11 screen,

    // added additional check to make sure native parent widget exists.

    if (!nativeParent || !nativeParent->internalWinId())

        return;

    WId winid = nativeParent->internalWinId();

    if (w->isWindow() || w->testAttribute(Qt::WA_SetCursor)) {

#ifndef QT_NO_CURSOR

        QCursor *oc = QApplication::overrideCursor();

        if (oc) {

            XDefineCursor(X11->display, winid, oc->handle());

        } else if (w->isEnabled()) {

            XDefineCursor(X11->display, winid, w->cursor().handle());

        } else {

            // enforce the windows behavior of clearing the cursor on

            // disabled widgets

            XDefineCursor(X11->display, winid, XNone);

        }

#endif

    } else {

        XDefineCursor(X11->display, winid, XNone);

    }

}

Q_GUI_EXPORT void qt_x11_enforce_cursor(QWidget * w)

{

    qt_x11_enforce_cursor(w, false);

}

static Bool checkForConfigureAndExpose(Display *, XEvent *e, XPointer)

{

    return e->type == ConfigureNotify || e->type == Expose;

}

Q_GUI_EXPORT void qt_x11_wait_for_window_manager(QWidget* w)

{

    if (!w || (!w->isWindow() && !w->internalWinId()))

        return;

    QApplication::flush();

    XEvent ev;

    QTime t;

    t.start();

    static const int maximumWaitTime = 2000;

    if (!w->testAttribute(Qt::WA_WState_Created))

        return;

    if (!(w->windowFlags() & Qt::X11BypassWindowManagerHint)) {

        // if the window is not override-redirect, then the window manager

        // will reparent us to the frame decoration window.

        while (!XCheckTypedWindowEvent(X11->display, w->effectiveWinId(), ReparentNotify, &ev)) {

            if (t.elapsed() > maximumWaitTime)

                return;

            qApp->syncX(); // non-busy wait

        }

    }

    while (!XCheckTypedWindowEvent(X11->display, w->effectiveWinId(), MapNotify, &ev)) {

        if (t.elapsed() > maximumWaitTime)

            return;

        qApp->syncX(); // non-busy wait

    }

    qApp->x11ProcessEvent(&ev);

    // ok, seems like the window manager successfully reparented us, we'll wait

    // for the first paint event to arrive, while handling ConfigureNotify in

    // the arrival order

    while(1)

    {

        if (XCheckIfEvent(X11->display, &ev, checkForConfigureAndExpose, 0)) {

            qApp->x11ProcessEvent(&ev);

            if (ev.type == Expose)

                return;

        }

        if (t.elapsed() > maximumWaitTime)

            return;

        qApp->syncX(); // non-busy wait

    }

}

void qt_change_net_wm_state(const QWidget* w, bool set, Atom one, Atom two = 0)

{

    if (!w->isVisible()) // not managed by the window manager

        return;

    XEvent e;

    e.xclient.type = ClientMessage;

    e.xclient.message_type = ATOM(_NET_WM_STATE);

    e.xclient.display = X11->display;

    e.xclient.window = w->internalWinId();

    e.xclient.format = 32;

    e.xclient.data.l[0] = set ? 1 : 0;

    e.xclient.data.l[1] = one;

    e.xclient.data.l[2] = two;

    e.xclient.data.l[3] = 0;

    e.xclient.data.l[4] = 0;

    XSendEvent(X11->display, RootWindow(X11->display, w->x11Info().screen()),

               false, (SubstructureNotifyMask | SubstructureRedirectMask), &e);

}

struct QX11WindowAttributes {

    const XWindowAttributes *att;

};

void qt_x11_getX11InfoForWindow(QX11Info * xinfo, const XWindowAttributes &a)

{

    QX11WindowAttributes att;

    att.att = &a;

    qt_x11_getX11InfoForWindow(xinfo,att);

}

static QVector<Atom> getNetWmState(QWidget *w)

{

    QVector<Atom> returnValue;

    // Don't read anything, just get the size of the property data

    Atom actualType;

    int actualFormat;

    ulong propertyLength;

    ulong bytesLeft;

    uchar *propertyData = 0;

    if (XGetWindowProperty(X11->display, w->internalWinId(), ATOM(_NET_WM_STATE), 0, 0,

                           False, XA_ATOM, &actualType, &actualFormat,

                           &propertyLength, &bytesLeft, &propertyData) == Success

        && actualType == XA_ATOM && actualFormat == 32) {

        returnValue.resize(bytesLeft / 4);

        XFree((char*) propertyData);

        // fetch all data

        if (XGetWindowProperty(X11->display, w->internalWinId(), ATOM(_NET_WM_STATE), 0,

                               returnValue.size(), False, XA_ATOM, &actualType, &actualFormat,

                               &propertyLength, &bytesLeft, &propertyData) != Success) {

            returnValue.clear();

        } else if (propertyLength != (ulong)returnValue.size()) {

            returnValue.resize(propertyLength);

        }

        // put it into netWmState

        if (!returnValue.isEmpty()) {

            memcpy(returnValue.data(), propertyData, returnValue.size() * sizeof(Atom));

        }

        XFree((char*) propertyData);

    }

    return returnValue;

}

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

{

    Q_Q(QWidget);

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

    Qt::WindowFlags &flags = data.window_flags;

    QWidget *parentWidget = q->parentWidget();

    if (type == Qt::ToolTip)

        flags |= Qt::WindowStaysOnTopHint | Qt::FramelessWindowHint | Qt::X11BypassWindowManagerHint;

    if (type == Qt::Popup)

        flags |= Qt::X11BypassWindowManagerHint;

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

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

    bool dialog = (type == Qt::Dialog

                   || type == Qt::Sheet);

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

    bool tool = (type == Qt::Tool || type == Qt::SplashScreen

                 || type == Qt::ToolTip || type == Qt::Drawer);

#ifdef ALIEN_DEBUG

    qDebug() << "QWidgetPrivate::create_sys START:" << q << "topLevel?" << topLevel << "WId:"

             << window << "initializeWindow:" << initializeWindow << "destroyOldWindow" << destroyOldWindow;

#endif

    if (topLevel) {

        if (parentWidget) { // if our parent stays on top, so must we

            QWidget *ptl = parentWidget->window();

            if(ptl && (ptl->windowFlags() & Qt::WindowStaysOnTopHint))

                flags |= Qt::WindowStaysOnTopHint;

        }

        if (type == Qt::SplashScreen) {

            if (X11->isSupportedByWM(ATOM(_NET_WM_WINDOW_TYPE_SPLASH))) {

                flags &= ~Qt::X11BypassWindowManagerHint;

            } else {

                flags |= Qt::X11BypassWindowManagerHint | Qt::FramelessWindowHint;

            }

        }

        // All these buttons depend on the system menu, so we enable it

        if (flags & (Qt::WindowMinimizeButtonHint

                     | Qt::WindowMaximizeButtonHint

                     | Qt::WindowContextHelpButtonHint))

            flags |= Qt::WindowSystemMenuHint;

    }

    Window parentw, destroyw = 0;

    WId id = 0;

    // always initialize

    if (!window)

        initializeWindow = true;

    QX11Info *parentXinfo = parentWidget ? &parentWidget->d_func()->xinfo : 0;

    if (desktop &&

        qt_x11_create_desktop_on_screen >= 0 &&

        qt_x11_create_desktop_on_screen != xinfo.screen()) {

        // desktop on a certain screen other than the default requested

        QX11InfoData *xd = &X11->screens[qt_x11_create_desktop_on_screen];

        xinfo.setX11Data(xd);