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

**

** Copyright (C) 2010 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 "qplatformdefs.h"

#include "qx11embed_x11.h"

#include <qapplication.h>

#include <qevent.h>

#include <qpainter.h>

#include <qlayout.h>

#include <qstyle.h>

#include <qstyleoption.h>

#include <qdatetime.h>

#include <qpointer.h>

#include <qdebug.h>

#include <qx11info_x11.h>

#include <private/qt_x11_p.h>

#include <private/qwidget_p.h>

#define XK_MISCELLANY

#define XK_LATIN1

#define None 0

#include <X11/Xlib.h>

#include <X11/Xatom.h>

#include <X11/Xutil.h>

#include <X11/keysymdef.h>

#include <X11/X.h>

#ifndef XK_ISO_Left_Tab

#define XK_ISO_Left_Tab 0xFE20

#endif

//#define QX11EMBED_DEBUG

#ifdef QX11EMBED_DEBUG

#include <qdebug.h>

#endif

QT_BEGIN_NAMESPACE

/*!

    \class QX11EmbedWidget

    \ingroup advanced

    \brief The QX11EmbedWidget class provides an XEmbed client widget.

    XEmbed is an X11 protocol that supports the embedding of a widget

    from one application into another application.

    An XEmbed \e{client widget} is a window that is embedded into a

    \e container. A container is the graphical location that embeds

    (or \e swallows) an external application.

    QX11EmbedWidget is a widget used for writing XEmbed applets or

    plugins. When it has been embedded and the container receives tab

    focus, focus is passed on to the widget. When the widget reaches

    the end of its focus chain, focus is passed back to the

    container. Window activation, accelerator support, modality and

    drag and drop (XDND) are also handled.

    The widget and container can both initiate the embedding. If the

    widget is the initiator, the X11 window ID of the container that

    it wants to embed itself into must be passed to embedInto().

    If the container initiates the embedding, the window ID of the

    embedded widget must be known. The container calls embed(),

    passing the window ID.

    This example shows an application that embeds a QX11EmbedWidget

    subclass into the window whose ID is passed as a command-line

    argument:

    \snippet doc/src/snippets/qx11embedwidget/main.cpp 0

    The problem of obtaining the window IDs is often solved by the

    container invoking the application that provides the widget as a

    separate process (as a panel invokes a docked applet), passing

    its window ID to the new process as a command-line argument. The

    new process can then call embedInto() with the container's window

    ID, as shown in the example code above. Similarly, the new

    process can report its window ID to the container through IPC, in

    which case the container can embed the widget.

    When the widget has been embedded, it emits the signal

    embedded(). If it is closed by the container, the widget emits

    containerClosed(). If an error occurs when embedding, error() is

    emitted.

    There are XEmbed widgets available for KDE and GTK+. The GTK+

    equivalent of QX11EmbedWidget is GtkPlug. The corresponding KDE 3

    widget is called QXEmbed.

    \sa QX11EmbedContainer, {XEmbed Specification}

*/

/*!

    \class QX11EmbedContainer

    \ingroup advanced

    \brief The QX11EmbedContainer class provides an XEmbed container

    widget.

    XEmbed is an X11 protocol that supports the embedding of a widget

    from one application into another application.

    An XEmbed \e container is the graphical location that embeds an

    external \e {client widget}. A client widget is a window that is

    embedded into a container.

    When a widget has been embedded and the container receives tab

    focus, focus is passed on to the widget. When the widget reaches

    the end of its focus chain, focus is passed back to the

    container. Window activation, accelerator support, modality and

    drag and drop (XDND) are also handled.

    QX11EmbedContainer is commonly used for writing panels or

    toolbars that hold applets, or for \e swallowing X11

    applications. When writing a panel application, one container

    widget is created on the toolbar, and it can then either swallow

    another widget using embed(), or allow an XEmbed widget to be

    embedded into itself. The container's X11 window ID, which is

    retrieved with winId(), must then be known to the client widget.

    After embedding, the client's window ID can be retrieved with

    clientWinId().

    In the following example, a container widget is created as the

    main widget. It then invokes an application called "playmovie",

    passing its window ID as a command line argument. The "playmovie"

    program is an XEmbed client widget. The widget embeds itself into

    the container using the container's window ID.

    \snippet doc/src/snippets/qx11embedcontainer/main.cpp 0

    When the client widget is embedded, the container emits the

    signal clientIsEmbedded(). The signal clientClosed() is emitted

    when a widget is closed.

    It is possible for QX11EmbedContainer to embed XEmbed widgets

    from toolkits other than Qt, such as GTK+. Arbitrary (non-XEmbed)

    X11 widgets can also be embedded, but the XEmbed-specific

    features such as window activation and focus handling are then

    lost.

    The GTK+ equivalent of QX11EmbedContainer is GtkSocket. The

    corresponding KDE 3 widget is called QXEmbed.

    \sa QX11EmbedWidget, {XEmbed Specification}

*/

/*! \fn void QX11EmbedWidget::embedded()

    This signal is emitted by the widget that has been embedded by an

    XEmbed container.

*/

/*! \fn void QX11EmbedWidget::containerClosed()

    This signal is emitted by the client widget when the container

    closes the widget. This can happen if the container itself

    closes, or if the widget is rejected.

    The container can reject a widget for any reason, but the most

    common cause of a rejection is when an attempt is made to embed a

    widget into a container that already has an embedded widget.

*/

/*! \fn void QX11EmbedContainer::clientIsEmbedded()

    This signal is emitted by the container when a client widget has

    been embedded.

*/

/*! \fn void QX11EmbedContainer::clientClosed()

    This signal is emitted by the container when the client widget

    closes.

*/

/*!

    \fn void QX11EmbedWidget::error(QX11EmbedWidget::Error error)

    This signal is emitted if an error occurred as a result of

    embedding into or communicating with a container. The specified

    \a error describes the problem that occurred.

    \sa QX11EmbedWidget::Error

*/

/*!

    \fn QX11EmbedContainer::Error QX11EmbedContainer::error() const

    Returns the last error that occurred.

*/

/*! \fn void QX11EmbedContainer::error(QX11EmbedContainer::Error error)

    This signal is emitted if an error occurred when embedding or

    communicating with a client. The specified \a error describes the

    problem that occurred.

    \sa QX11EmbedContainer::Error

*/

/*!

    \enum QX11EmbedWidget::Error

    \value Unknown An unrecognized error occurred.

    \value InvalidWindowID The X11 window ID of the container was

        invalid. This error is usually triggered by passing an invalid

        window ID to embedInto().

    \omitvalue Internal

*/

/*!

    \enum QX11EmbedContainer::Error

    \value Unknown An unrecognized error occurred.

    \value InvalidWindowID The X11 window ID of the container was

        invalid. This error is usually triggered by passing an invalid

        window ID to embed().

    \omitvalue Internal

*/

const int XButtonPress = ButtonPress;

const int XButtonRelease = ButtonRelease;

#undef ButtonPress

#undef ButtonRelease

// This is a hack to move topData() out from QWidgetPrivate to public.  We

// need to to inspect window()'s embedded state.

class QHackWidget : public QWidget

{

    Q_DECLARE_PRIVATE(QWidget)

public:

    QTLWExtra* topData() { return d_func()->topData(); }

};

static unsigned int XEMBED_VERSION = 0;

enum QX11EmbedMessageType {

    XEMBED_EMBEDDED_NOTIFY = 0,

    XEMBED_WINDOW_ACTIVATE = 1,

    XEMBED_WINDOW_DEACTIVATE = 2,

    XEMBED_REQUEST_FOCUS = 3,

    XEMBED_FOCUS_IN = 4,

    XEMBED_FOCUS_OUT = 5,

    XEMBED_FOCUS_NEXT = 6,

    XEMBED_FOCUS_PREV = 7,

    XEMBED_MODALITY_ON = 10,

    XEMBED_MODALITY_OFF = 11,

    XEMBED_REGISTER_ACCELERATOR = 12,

    XEMBED_UNREGISTER_ACCELERATOR = 13,

    XEMBED_ACTIVATE_ACCELERATOR = 14

};

enum QX11EmbedFocusInDetail {

    XEMBED_FOCUS_CURRENT = 0,

    XEMBED_FOCUS_FIRST = 1,

    XEMBED_FOCUS_LAST = 2

};

enum QX11EmbedFocusInFlags {

    XEMBED_FOCUS_OTHER = (0 << 0),

    XEMBED_FOCUS_WRAPAROUND = (1 << 0)

};

enum QX11EmbedInfoFlags {

    XEMBED_MAPPED = (1 << 0)

};

enum QX11EmbedAccelModifiers {

    XEMBED_MODIFIER_SHIFT = (1 << 0),

    XEMBED_MODIFIER_CONTROL = (1 << 1),

    XEMBED_MODIFIER_ALT = (1 << 2),

    XEMBED_MODIFIER_SUPER = (1 << 3),

    XEMBED_MODIFIER_HYPER = (1 << 4)

};

enum QX11EmbedAccelFlags {

    XEMBED_ACCELERATOR_OVERLOADED = (1 << 0)

};

// Silence the default X11 error handler.

static int x11ErrorHandler(Display *, XErrorEvent *)

{

    return 0;

}

// Returns the X11 timestamp. Maintained mainly by qapplication

// internals, but also updated by the XEmbed widgets.

static Time x11Time()

{

    return qt_x11Data->time;

}

// Gives the version and flags of the supported XEmbed protocol.

static unsigned int XEmbedVersion()

{

    return 0;

}

// Sends an XEmbed message.

static void sendXEmbedMessage(WId window, Display *display, long message,

                  long detail = 0, long data1 = 0, long data2 = 0)

{

    XClientMessageEvent c;

    memset(&c, 0, sizeof(c));

    c.type = ClientMessage;

    c.message_type = ATOM(_XEMBED);

    c.format = 32;

    c.display = display;

    c.window = window;

    c.data.l[0] = x11Time();

    c.data.l[1] = message;

    c.data.l[2] = detail;

    c.data.l[3] = data1;

    c.data.l[4] = data2;

    XSendEvent(display, window, false, NoEventMask, (XEvent *) &c);

}

// From qapplication_x11.cpp

static XKeyEvent lastKeyEvent;

static QCoreApplication::EventFilter oldX11EventFilter;

// The purpose of this global x11 filter is for one to capture the key

// events in their original state, but most importantly this is the

// only way to get the WM_TAKE_FOCUS message from WM_PROTOCOLS.

static bool x11EventFilter(void *message, long *result)

{

    XEvent *event = reinterpret_cast<XEvent *>(message);

    if (event->type == XKeyPress || event->type == XKeyRelease)

	lastKeyEvent = event->xkey;

    if (oldX11EventFilter && oldX11EventFilter != &x11EventFilter)

	return oldX11EventFilter(message, result);

    else

	return false;

}

//

struct functorData

{

    Window id, rootWindow;

    bool clearedWmState;

    bool reparentedToRoot;

};

static Bool functor(Display *display, XEvent *event, XPointer arg)

{

    functorData *data = (functorData *) arg;

    if (!data->reparentedToRoot && event->type == ReparentNotify

        && event->xreparent.window == data->id

        && event->xreparent.parent == data->rootWindow) {

        data->reparentedToRoot = true;

        return true;

    }

    if (!data->clearedWmState

        && event->type == PropertyNotify

        && event->xproperty.window == data->id

        && event->xproperty.atom == ATOM(WM_STATE)) {

	if (event->xproperty.state == PropertyDelete) {

            data->clearedWmState = true;

            return true;

        }

	Atom ret;

	int format, status;

	unsigned char *retval;

	unsigned long nitems, after;

	status = XGetWindowProperty(display, data->id, ATOM(WM_STATE), 0, 2, False, ATOM(WM_STATE),

				    &ret, &format, &nitems, &after, &retval );

	if (status == Success && ret == ATOM(WM_STATE) && format == 32 && nitems > 0) {

            long *state = (long *)retval;

	    if (state[0] == WithdrawnState) {

                data->clearedWmState = true;

		return true;

            }

	}

    }

    return false;

}

class QX11EmbedWidgetPrivate : public QWidgetPrivate

{

    Q_DECLARE_PUBLIC(QX11EmbedWidget)

public:

    inline QX11EmbedWidgetPrivate()

    {

        lastError = QX11EmbedWidget::Unknown;

        container = 0;

    }

    void setEmbedded();

    void emitError(QX11EmbedWidget::Error error) {

        Q_Q(QX11EmbedWidget);

        lastError = error;

        emit q->error(error);

    }

    enum FocusWidgets {

        FirstFocusWidget,

        LastFocusWidget

    };

    int focusOriginator;

    QWidget *getFocusWidget(FocusWidgets fw);

    void checkActivateWindow(QObject *o);

    QX11EmbedWidget *xEmbedWidget(QObject *o) const;

    void clearFocus();

    WId container;

    QPointer<QWidget> currentFocus;

    QX11EmbedWidget::Error lastError;

};

/*!

    Constructs a QX11EmbedWidget object with the given \a parent.

*/

QX11EmbedWidget::QX11EmbedWidget(QWidget *parent)

    : QWidget(*new QX11EmbedWidgetPrivate, parent, 0)

{

    XSetErrorHandler(x11ErrorHandler);

    setAttribute(Qt::WA_NativeWindow);

    setAttribute(Qt::WA_DontCreateNativeAncestors);

    createWinId();

    XSelectInput(x11Info().display(), internalWinId(),

                 KeyPressMask | KeyReleaseMask | ButtonPressMask

                    | ButtonReleaseMask

                    | KeymapStateMask | ButtonMotionMask | PointerMotionMask

                    | FocusChangeMask

                    | ExposureMask | StructureNotifyMask

                    | SubstructureNotifyMask | PropertyChangeMask);

    long data[] = {XEMBED_VERSION, XEMBED_MAPPED};

    XChangeProperty(x11Info().display(), internalWinId(), ATOM(_XEMBED_INFO),

                    ATOM(_XEMBED_INFO), 32, PropModeReplace,

                    (unsigned char*) data, 2);

    setFocusPolicy(Qt::StrongFocus);

    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

    QApplication::instance()->installEventFilter(this);

#ifdef QX11EMBED_DEBUG

    qDebug() << "QX11EmbedWidget::QX11EmbedWidget: constructed client"

             << (void *)this << "with winId" << winId();

#endif

}

/*!

    Destructs the QX11EmbedWidget object. If the widget is embedded

    when deleted, it is hidden and then detached from its container,

    so that the container is free to embed a new widget.

*/

QX11EmbedWidget::~QX11EmbedWidget()

{

    Q_D(QX11EmbedWidget);

    if (d->container) {

#ifdef QX11EMBED_DEBUG

        qDebug() << "QX11EmbedWidget::~QX11EmbedWidget: unmapping"

                 << (void *)this << "with winId" << winId()

                 << "from container with winId" << d->container;

#endif

        XUnmapWindow(x11Info().display(), internalWinId());

        XReparentWindow(x11Info().display(), internalWinId(), x11Info().appRootWindow(), 0, 0);

    }

#ifdef QX11EMBED_DEBUG

    qDebug() << "QX11EmbedWidget::~QX11EmbedWidget: destructed client"

             << (void *)this << "with winId" << winId();

#endif

}

/*!

    Returns the type of error that occurred last. This is the same error code

    that is emitted by the error() signal.

    \sa Error

*/