qdnd_x11.cpp File Reference

#include "qplatformdefs.h"
#include "qapplication.h"
#include "qabstracteventdispatcher.h"
#include "qwidget.h"
#include "qpainter.h"
#include "qpixmap.h"
#include "qbitmap.h"
#include "qdesktopwidget.h"
#include "qevent.h"
#include "qiodevice.h"
#include "qpointer.h"
#include "qcursor.h"
#include "qelapsedtimer.h"
#include "qvariant.h"
#include "qvector.h"
#include "qurl.h"
#include "qdebug.h"
#include "qimagewriter.h"
#include "qbuffer.h"
#include "qtextcodec.h"
#include "qdnd_p.h"
#include "qapplication_p.h"
#include "qt_x11_p.h"
#include "qx11info_x11.h"
#include "qwidget_p.h"
#include "qcursor_p.h"
#include <X11/extensions/Xfixes.h>
#include "qdnd_x11.moc"

Go to the source code of this file.

Classes
class	QExtraWidget
class	QShapedPixmapWidget
struct	XdndData

Macros
#define	DEBUG   if(0) qDebug
#define	DNDDEBUG   if(0) qDebug()

Enumerations
enum	{ XdndDropTransactionTimeout = 5000 }

Functions
static bool	checkEmbedded (QWidget *w, const XEvent *xe)
static QWidget *	find_child (QWidget *tlw, QPoint &p)
static Window	findRealWindow (const QPoint &pos, Window w, int md, bool ignoreNonXdndAwareWindows)
static Window	findXdndAwareParent (Window window)
static int	findXdndDropTransactionByTime (Time timestamp)
static int	findXdndDropTransactionByWindow (Window window)
static void	handle_xdnd_position (QWidget *, const XEvent *, bool)
static void	handle_xdnd_status (QWidget *w, const XEvent *xe, bool)
static void	qt_xdnd_cleanup ()
static void	qt_xdnd_send_leave ()
static int	qtaction_to_xdndaction (Qt::DropAction a)
static void	restartXdndDropExpiryTimer ()
static bool	windowInteractsWithPosition (const QPoint &pos, Window w, int shapeType)
static Bool	xdnd_position_scanner (Display *, XEvent *event, XPointer)
static Bool	xdnd_status_scanner (Display *, XEvent *event, XPointer)
static Qt::DropAction	xdndaction_to_qtaction (Atom atom)
static bool	xdndEnable (QWidget *w, bool on)
static QVariant	xdndObtainData (const char *format, QVariant::Type requestedType)
static WId	xdndProxy (WId w)

Variables
static QCursor *	copyCursor = 0
static QWidget *	current_embedding_widget = 0
static const char *const	default_pm []
static const int	default_pm_hotx = -2
static const int	default_pm_hoty = -16
static QPixmap *	defaultPm = 0
static Qt::DropAction	global_accepted_action = Qt::CopyAction
static int	heartbeat = -1
static XEvent	last_enter_event
static Qt::DropAction	last_target_accepted_action = Qt::IgnoreAction
static QCursor *	linkCursor = 0
static QCursor *	moveCursor = 0
static QCursor *	noDropCursor = 0
static Qt::DropActions	possible_actions = Qt::IgnoreAction
static QPoint	qt_xdnd_current_position
static Window	qt_xdnd_current_proxy_target
static int	qt_xdnd_current_screen = -1
static Window	qt_xdnd_current_target
static QPointer< QWidget >	qt_xdnd_current_widget
bool	qt_xdnd_dragging = false
static Atom	qt_xdnd_dragsource_xid = 0
const int	qt_xdnd_max_type = 100
static Time	qt_xdnd_source_current_time
static QRect	qt_xdnd_source_sameanswer
static Time	qt_xdnd_target_current_time
static Atom	qt_xdnd_types [qt_xdnd_max_type+1]
static int	transaction_expiry_timer = -1
static bool	waiting_for_status = false
static XdndData	xdnd_data = { 0, 0 }
const int	xdnd_version = 5

Macro Definition Documentation

DEBUG

#define DEBUG   if(0) qDebug

Definition at line 85 of file qdnd_x11.cpp.

Referenced by findRealWindow(), handle_xdnd_position(), QX11Data::xdndHandleDrop(), QX11Data::xdndHandleFinished(), QX11Data::xdndHandleLeave(), QX11Data::xdndHandlePosition(), QX11Data::xdndHandleStatus(), QX11Data::xdndMimeDataForAtom(), and xdndObtainData().

DNDDEBUG

#define DNDDEBUG   if(0) qDebug()

Definition at line 91 of file qdnd_x11.cpp.

Referenced by findRealWindow(), xdndEnable(), QX11Data::xdndHandleDrop(), and QX11Data::xdndHandleFinished().

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
XdndDropTransactionTimeout

Definition at line 122 of file qdnd_x11.cpp.

{ XdndDropTransactionTimeout = 5000 }; // 5 seconds

Function Documentation

checkEmbedded()

static bool checkEmbedded ( QWidget *  w, const XEvent *  xe  )

static

Definition at line 767 of file qdnd_x11.cpp.

Referenced by handle_xdnd_position(), QX11Data::xdndHandleDrop(), and QX11Data::xdndHandleLeave().

{
    if (!w)
        return false;

    if (current_embedding_widget != 0 && current_embedding_widget != w) {
        qt_xdnd_current_target = ((QExtraWidget*)current_embedding_widget)->extraData()->xDndProxy;
        qt_xdnd_current_proxy_target = qt_xdnd_current_target;
        qt_xdnd_send_leave();
        qt_xdnd_current_target = 0;
        qt_xdnd_current_proxy_target = 0;
        current_embedding_widget = 0;
    }

    QWExtra* extra = ((QExtraWidget*)w)->extraData();
    if (extra && extra->xDndProxy != 0) {

        if (current_embedding_widget != w) {

            last_enter_event.xany.window = extra->xDndProxy;
            XSendEvent(X11->display, extra->xDndProxy, False, NoEventMask, &last_enter_event);
            current_embedding_widget = w;
        }

        ((XEvent*)xe)->xany.window = extra->xDndProxy;
        XSendEvent(X11->display, extra->xDndProxy, False, NoEventMask, (XEvent*)xe);
        if (qt_xdnd_current_widget != w) {
            qt_xdnd_current_widget = w;
        }
        return true;
    }
    current_embedding_widget = 0;
    return false;
}

find_child()

static QWidget* find_child ( QWidget *  tlw, QPoint &  p  )

static

Definition at line 732 of file qdnd_x11.cpp.

Referenced by handle_xdnd_position().

{
    QWidget *widget = tlw;

    p = widget->mapFromGlobal(p);
    bool done = false;
    while (!done) {
        done = true;
        if (((QExtraWidget*)widget)->extraData() &&
             ((QExtraWidget*)widget)->extraData()->xDndProxy != 0)
            break; // stop searching for widgets under the mouse cursor if found widget is a proxy.
        QObjectList children = widget->children();
        if (!children.isEmpty()) {
            for(int i = children.size(); i > 0;) {
                --i;
                QWidget *w = qobject_cast<QWidget *>(children.at(i));
                if (!w)
                    continue;
                if (w->testAttribute(Qt::WA_TransparentForMouseEvents))
                    continue;
                if (w->isVisible() &&
                     w->geometry().contains(p) &&
                     !w->isWindow()) {
                    widget = w;
                    done = false;
                    p = widget->mapFromParent(p);
                    break;
                }
            }
        }
    }
    return widget;
}

findRealWindow()

static Window findRealWindow ( const QPoint &  pos, Window  w, int  md, bool  ignoreNonXdndAwareWindows  )

static

Definition at line 1442 of file qdnd_x11.cpp.

{
    if (xdnd_data.deco && w == xdnd_data.deco->effectiveWinId())
        return 0;

    if (md) {
        X11->ignoreBadwindow();
        XWindowAttributes attr;
        XGetWindowAttributes(X11->display, w, &attr);
        if (X11->badwindow())
            return 0;

        if (attr.map_state == IsViewable
            && QRect(attr.x,attr.y,attr.width,attr.height).contains(pos)) {
            bool windowContainsMouse = !ignoreNonXdndAwareWindows;
            {
                Atom   type = XNone;
                int f;
                unsigned long n, a;
                unsigned char *data;

                XGetWindowProperty(X11->display, w, ATOM(XdndAware), 0, 0, False,
                                   AnyPropertyType, &type, &f,&n,&a,&data);
                if (data) XFree(data);
                if (type) {
#ifdef QT_NO_SHAPE
                    return w;
#else // !QT_NO_SHAPE
                    const QPoint relPos = pos - QPoint(attr.x,attr.y);
                    // When ShapeInput and ShapeBounding are not set they return a single rectangle with the geometry of the window, this is why we
                    // need an && here so that in the case one is set and the other is not we still get the correct result.
#if defined(ShapeInput) && defined(ShapeBounding)
                    windowContainsMouse = windowInteractsWithPosition(relPos, w, ShapeInput) && windowInteractsWithPosition(relPos, w, ShapeBounding);
#elif defined(ShapeBounding)
                    windowContainsMouse = windowInteractsWithPosition(relPos, w, ShapeBounding);
#else
                    windowContainsMouse = true;
#endif
                    if (windowContainsMouse)
                        return w;
#endif // QT_NO_SHAPE
                }
            }

            Window r, p;
            Window* c;
            uint nc;
            if (XQueryTree(X11->display, w, &r, &p, &c, &nc)) {
                r=0;
                for (uint i=nc; !r && i--;) {
                    r = findRealWindow(pos-QPoint(attr.x,attr.y),
                                        c[i], md-1, ignoreNonXdndAwareWindows);
                }
                XFree(c);
                if (r)
                    return r;

                // We didn't find a client window!  Just use the
                // innermost window.
            }

            // No children!
            if (!windowContainsMouse)
                return 0;
            else
                return w;
        }
    }
    return 0;
}

findXdndAwareParent()

static Window findXdndAwareParent ( Window  window )

static

Definition at line 133 of file qdnd_x11.cpp.

Referenced by QX11Data::xdndHandleSelectionRequest().

{
    Window target = 0;
    forever {
        // check if window has XdndAware
        Atom type = 0;
        int f;
        unsigned long n, a;
        unsigned char *data = 0;
        if (XGetWindowProperty(X11->display, window, ATOM(XdndAware), 0, 0, False,
                               AnyPropertyType, &type, &f,&n,&a,&data) == Success) {
        if (data)
                XFree(data);
        if (type) {
                target = window;
                break;
            }
        }

        // try window's parent
        Window root;
        Window parent;
        Window *children;
        uint unused;
        if (!XQueryTree(X11->display, window, &root, &parent, &children, &unused))
            break;
        if (children)
            XFree(children);
        if (window == root)
            break;
        window = parent;
    }
    return target;
}

findXdndDropTransactionByTime()

static int findXdndDropTransactionByTime ( Time  timestamp )

static

Definition at line 107 of file qdnd_x11.cpp.

Referenced by QX11Data::xdndHandleDrop(), and QX11Data::xdndHandleSelectionRequest().

{
    int at = -1;
    for (int i = 0; i < X11->dndDropTransactions.count(); ++i) {
        const QXdndDropTransaction &t = X11->dndDropTransactions.at(i);
        if (t.timestamp == timestamp) {
            at = i;
            break;
        }
    }
    return at;
}

findXdndDropTransactionByWindow()

static int findXdndDropTransactionByWindow ( Window  window )

static

Definition at line 94 of file qdnd_x11.cpp.

Referenced by QX11Data::xdndHandleFinished(), and QX11Data::xdndHandleSelectionRequest().

{
    int at = -1;
    for (int i = 0; i < X11->dndDropTransactions.count(); ++i) {
        const QXdndDropTransaction &t = X11->dndDropTransactions.at(i);
        if (t.target == window || t.proxy_target == window) {
            at = i;
            break;
        }
    }
    return at;
}

handle_xdnd_position()

static void handle_xdnd_position ( QWidget *  w, const XEvent *  xe, bool  passive  )

static

Definition at line 842 of file qdnd_x11.cpp.

Referenced by findRealWindow(), findXdndAwareParent(), and QX11Data::xdndHandlePosition().

{
    const unsigned long *l = (const unsigned long *)xe->xclient.data.l;

    QPoint p((l[2] & 0xffff0000) >> 16, l[2] & 0x0000ffff);
    QWidget * c = find_child(w, p); // changes p to to c-local coordinates

    if (!passive && checkEmbedded(c, xe))
        return;

    if (!c || (!c->acceptDrops() && (c->windowType() == Qt::Desktop)))
        return;

    if (l[0] != qt_xdnd_dragsource_xid) {
        DEBUG("xdnd drag position from unexpected source (%08lx not %08lx)", l[0], qt_xdnd_dragsource_xid);
        return;
    }

    // timestamp from the source
    if (l[3] != 0) {
        // Some X server/client combination swallow the first 32 bit and
        // interpret a set bit 31 as negative sign.
        qt_xdnd_target_current_time = X11->userTime =
            ((sizeof(Time) == 8 && xe->xclient.data.l[3] < 0)
             ? uint(l[3])
             : l[3]);
    }

    QDragManager *manager = QDragManager::self();
    QMimeData *dropData = manager->object ? manager->dragPrivate()->data : manager->dropData;

    XClientMessageEvent response;
    response.type = ClientMessage;
    response.window = qt_xdnd_dragsource_xid;
    response.format = 32;
    response.message_type = ATOM(XdndStatus);
    response.data.l[0] = w->effectiveWinId();
    response.data.l[1] = 0; // flags
    response.data.l[2] = 0; // x, y
    response.data.l[3] = 0; // w, h
    response.data.l[4] = 0; // action

    if (!passive) { // otherwise just reject
        while (c && !c->acceptDrops() && !c->isWindow()) {
            p = c->mapToParent(p);
            c = c->parentWidget();
        }
        QWidget *target_widget = c && c->acceptDrops() ? c : 0;

        QRect answerRect(c->mapToGlobal(p), QSize(1,1));

        if (manager->object) {
            possible_actions = manager->dragPrivate()->possible_actions;
        } else {
            possible_actions = Qt::DropActions(xdndaction_to_qtaction(l[4]));
//             possible_actions |= Qt::CopyAction;
        }
        QDragMoveEvent me(p, possible_actions, dropData, QApplication::mouseButtons(), QApplication::keyboardModifiers());

        Qt::DropAction accepted_action = Qt::IgnoreAction;


        if (target_widget != qt_xdnd_current_widget) {
            if (qt_xdnd_current_widget) {
                QDragLeaveEvent e;
                QApplication::sendEvent(qt_xdnd_current_widget, &e);
            }
            if (qt_xdnd_current_widget != target_widget) {
                qt_xdnd_current_widget = target_widget;
            }
            if (target_widget) {
                qt_xdnd_current_position = p;

                last_target_accepted_action = Qt::IgnoreAction;
                QDragEnterEvent de(p, possible_actions, dropData, QApplication::mouseButtons(), QApplication::keyboardModifiers());
                QApplication::sendEvent(target_widget, &de);
                if (de.isAccepted() && de.dropAction() != Qt::IgnoreAction)
                    last_target_accepted_action = de.dropAction();
            }
        }

        DEBUG() << "qt_handle_xdnd_position action=" << X11->xdndAtomToString(l[4]);
        if (!target_widget) {
            answerRect = QRect(p, QSize(1, 1));
        } else {
            qt_xdnd_current_widget = c;
            qt_xdnd_current_position = p;

            if (last_target_accepted_action != Qt::IgnoreAction) {
                me.setDropAction(last_target_accepted_action);
                me.accept();
            }
            QApplication::sendEvent(c, &me);
            if (me.isAccepted()) {
                response.data.l[1] = 1; // yes
                accepted_action = me.dropAction();
                last_target_accepted_action = accepted_action;
            } else {
                response.data.l[0] = 0;
                last_target_accepted_action = Qt::IgnoreAction;
            }
            answerRect = me.answerRect().intersected(c->rect());
        }
        answerRect = QRect(c->mapToGlobal(answerRect.topLeft()), answerRect.size());

        if (answerRect.left() < 0)
            answerRect.setLeft(0);
        if (answerRect.right() > 4096)
            answerRect.setRight(4096);
        if (answerRect.top() < 0)
            answerRect.setTop(0);
        if (answerRect.bottom() > 4096)
            answerRect.setBottom(4096);
        if (answerRect.width() < 0)
            answerRect.setWidth(0);
        if (answerRect.height() < 0)
            answerRect.setHeight(0);

        response.data.l[2] = (answerRect.x() << 16) + answerRect.y();
        response.data.l[3] = (answerRect.width() << 16) + answerRect.height();
        response.data.l[4] = qtaction_to_xdndaction(accepted_action);
    }

    // reset
    qt_xdnd_target_current_time = CurrentTime;

    QWidget * source = QWidget::find(qt_xdnd_dragsource_xid);
    if (source && (source->windowType() == Qt::Desktop) && !source->acceptDrops())
        source = 0;

    DEBUG() << "sending XdndStatus";
    if (source)
        handle_xdnd_status(source, (const XEvent *)&response, passive);
    else
        XSendEvent(X11->display, qt_xdnd_dragsource_xid, False, NoEventMask, (XEvent*)&response);
}

handle_xdnd_status()

static void handle_xdnd_status ( QWidget *  w, const XEvent *  xe, bool    )

static

Definition at line 1001 of file qdnd_x11.cpp.

Referenced by findXdndAwareParent(), handle_xdnd_position(), and QX11Data::xdndHandleStatus().

{
    const unsigned long *l = (const unsigned long *)xe->xclient.data.l;
    // ignore late status messages
    if (l[0] && l[0] != qt_xdnd_current_proxy_target)
        return;
    Qt::DropAction newAction = (l[1] & 0x1) ? xdndaction_to_qtaction(l[4]) : Qt::IgnoreAction;

    if ((int)(l[1] & 2) == 0) {
        QPoint p((l[2] & 0xffff0000) >> 16, l[2] & 0x0000ffff);
        QSize s((l[3] & 0xffff0000) >> 16, l[3] & 0x0000ffff);
        qt_xdnd_source_sameanswer = QRect(p, s);
    } else {
        qt_xdnd_source_sameanswer = QRect();
    }
    QDragManager *manager = QDragManager::self();
    manager->willDrop = (l[1] & 0x1);
    if (global_accepted_action != newAction)
        manager->emitActionChanged(newAction);
    global_accepted_action = newAction;
    manager->updateCursor();
    waiting_for_status = false;
}

qt_xdnd_cleanup()

void qt_xdnd_cleanup ( )

static

Definition at line 713 of file qdnd_x11.cpp.

Referenced by qtaction_to_xdndaction(), and QX11Data::xdndSetup().

{
    delete noDropCursor;
    noDropCursor = 0;
    delete copyCursor;
    copyCursor = 0;
    delete moveCursor;
    moveCursor = 0;
    delete linkCursor;
    linkCursor = 0;
    delete defaultPm;
    defaultPm = 0;
    delete xdnd_data.desktop_proxy;
    xdnd_data.desktop_proxy = 0;
    delete xdnd_data.deco;
    xdnd_data.deco = 0;
}

qt_xdnd_send_leave()

void qt_xdnd_send_leave ( )

static

Definition at line 1079 of file qdnd_x11.cpp.

Referenced by checkEmbedded(), findRealWindow(), and qtaction_to_xdndaction().

{
    if (!qt_xdnd_current_target)
        return;

    QDragManager *manager = QDragManager::self();

    XClientMessageEvent leave;
    leave.type = ClientMessage;
    leave.window = qt_xdnd_current_target;
    leave.format = 32;
    leave.message_type = ATOM(XdndLeave);
    leave.data.l[0] = manager->dragPrivate()->source->effectiveWinId();
    leave.data.l[1] = 0; // flags
    leave.data.l[2] = 0; // x, y
    leave.data.l[3] = 0; // w, h
    leave.data.l[4] = 0; // just null

    QWidget * w = QWidget::find(qt_xdnd_current_proxy_target);

    if (w && (w->windowType() == Qt::Desktop) && !w->acceptDrops())
        w = 0;

    if (w)
        X11->xdndHandleLeave(w, (const XEvent *)&leave, false);
    else
        XSendEvent(X11->display, qt_xdnd_current_proxy_target, False,
                    NoEventMask, (XEvent*)&leave);

    // reset the drag manager state
    manager->willDrop = false;
    if (global_accepted_action != Qt::IgnoreAction)
        manager->emitActionChanged(Qt::IgnoreAction);
    global_accepted_action = Qt::IgnoreAction;
    manager->updateCursor();
    qt_xdnd_current_target = 0;
    qt_xdnd_current_proxy_target = 0;
    qt_xdnd_source_current_time = 0;
    waiting_for_status = false;
}

qtaction_to_xdndaction()

static int qtaction_to_xdndaction ( Qt::DropAction  a )

static

Definition at line 189 of file qdnd_x11.cpp.

Referenced by findRealWindow(), handle_xdnd_position(), and QX11Data::xdndHandleDrop().

{
    switch (a) {
    case Qt::CopyAction:
        return ATOM(XdndActionCopy);
    case Qt::LinkAction:
        return ATOM(XdndActionLink);
    case Qt::MoveAction:
    case Qt::TargetMoveAction:
        return ATOM(XdndActionMove);
    case Qt::IgnoreAction:
        return XNone;
    default:
        return ATOM(XdndActionCopy);
    }
}

restartXdndDropExpiryTimer()

static void restartXdndDropExpiryTimer ( )

static

Definition at line 124 of file qdnd_x11.cpp.

Referenced by findRealWindow(), QX11Data::xdndHandleFinished(), and QX11Data::xdndHandleSelectionRequest().

{
    if (transaction_expiry_timer != -1)
        QDragManager::self()->killTimer(transaction_expiry_timer);
    transaction_expiry_timer = QDragManager::self()->startTimer(XdndDropTransactionTimeout);
}

windowInteractsWithPosition()

static bool windowInteractsWithPosition ( const QPoint &  pos, Window  w, int  shapeType  )

static

Definition at line 1427 of file qdnd_x11.cpp.

Referenced by findRealWindow().

{
    int nrectanglesRet, dummyOrdering;
    XRectangle *rectangles = XShapeGetRectangles(QX11Info::display(), w, shapeType, &nrectanglesRet, &dummyOrdering);
    bool interacts = false;
    if (rectangles) {
        for (int i = 0; !interacts && i < nrectanglesRet; ++i)
            interacts = QRect(rectangles[i].x, rectangles[i].y, rectangles[i].width, rectangles[i].height).contains(pos);
        XFree(rectangles);
    }
    return interacts;
}

xdnd_position_scanner()

static Bool xdnd_position_scanner ( Display *  , XEvent *  event, XPointer    )

static

Definition at line 979 of file qdnd_x11.cpp.

Referenced by QX11Data::xdndHandlePosition().

{
    if (event->type != ClientMessage)
        return false;
    XClientMessageEvent *ev = &event->xclient;

    if (ev->message_type == ATOM(XdndPosition))
        return true;

    return false;
}

xdnd_status_scanner()

static Bool xdnd_status_scanner ( Display *  , XEvent *  event, XPointer    )

static

Definition at line 1025 of file qdnd_x11.cpp.

Referenced by QX11Data::xdndHandleStatus().

{
    if (event->type != ClientMessage)
        return false;
    XClientMessageEvent *ev = &event->xclient;

    if (ev->message_type == ATOM(XdndStatus))
        return true;

    return false;
}

xdndaction_to_qtaction()

static Qt::DropAction xdndaction_to_qtaction ( Atom  atom )

static

Definition at line 178 of file qdnd_x11.cpp.

Referenced by handle_xdnd_position(), and handle_xdnd_status().

{
    if (atom == ATOM(XdndActionCopy) || atom == 0)
        return Qt::CopyAction;
    if (atom == ATOM(XdndActionLink))
        return Qt::LinkAction;
    if (atom == ATOM(XdndActionMove))
        return Qt::MoveAction;
    return Qt::CopyAction;
}

xdndEnable()

static bool xdndEnable ( QWidget *  w, bool  on  )

static

Definition at line 363 of file qdnd_x11.cpp.

Referenced by QX11Data::dndEnable().

{
    DNDDEBUG << "xdndEnable" << w << on;
    if (on) {
        QWidget * xdnd_widget = 0;
        if ((w->windowType() == Qt::Desktop)) {
            if (xdnd_data.desktop_proxy) // *WE* already have one.
                return false;

            // As per Xdnd4, use XdndProxy
            XGrabServer(X11->display);
            Q_ASSERT(w->testAttribute(Qt::WA_WState_Created));
            WId proxy_id = xdndProxy(w->effectiveWinId());

            if (!proxy_id) {
                xdnd_widget = xdnd_data.desktop_proxy = new QWidget;
                proxy_id = xdnd_data.desktop_proxy->effectiveWinId();
                XChangeProperty (X11->display, w->effectiveWinId(), ATOM(XdndProxy),
                                 XA_WINDOW, 32, PropModeReplace, (unsigned char *)&proxy_id, 1);
                XChangeProperty (X11->display, proxy_id, ATOM(XdndProxy),
                                 XA_WINDOW, 32, PropModeReplace, (unsigned char *)&proxy_id, 1);
            }

            XUngrabServer(X11->display);
        } else {
            xdnd_widget = w->window();
        }
        if (xdnd_widget) {
            DNDDEBUG << "setting XdndAware for" << xdnd_widget << xdnd_widget->effectiveWinId();
            Atom atm = (Atom)xdnd_version;
            Q_ASSERT(xdnd_widget->testAttribute(Qt::WA_WState_Created));
            XChangeProperty(X11->display, xdnd_widget->effectiveWinId(), ATOM(XdndAware),
                             XA_ATOM, 32, PropModeReplace, (unsigned char *)&atm, 1);
            return true;
        } else {
            return false;
        }
    } else {
        if ((w->windowType() == Qt::Desktop)) {
            XDeleteProperty(X11->display, w->internalWinId(), ATOM(XdndProxy));
            delete xdnd_data.desktop_proxy;
            xdnd_data.desktop_proxy = 0;
        } else {
            DNDDEBUG << "not deleting XDndAware";
        }
        return true;
    }
}

xdndObtainData()

static QVariant xdndObtainData ( const char *  format, QVariant::Type  requestedType  )

static

Definition at line 1883 of file qdnd_x11.cpp.

{
    QByteArray result;

    QWidget* w;
    QDragManager *manager = QDragManager::self();
    if (qt_xdnd_dragsource_xid && manager->object &&
         (w=QWidget::find(qt_xdnd_dragsource_xid))
         && (!(w->windowType() == Qt::Desktop) || w->acceptDrops()))
    {
        QDragPrivate * o = QDragManager::self()->dragPrivate();
        const QString mimeType = QString::fromLatin1(format);
        if (o->data->hasFormat(mimeType)) {
            result = o->data->data(mimeType);
        } else if (mimeType.startsWith(QLatin1String("image/")) && o->data->hasImage()) {
            // ### duplicated from QInternalMimeData::renderDataHelper
            QImage image = qvariant_cast<QImage>(o->data->imageData());
            QBuffer buf(&result);
            buf.open(QBuffer::WriteOnly);
            image.save(&buf, mimeType.mid(mimeType.indexOf(QLatin1Char('/')) + 1).toLatin1().toUpper());
        }
        return result;
    }

    QList<Atom> atoms;
    int i = 0;
    while ((qt_xdnd_types[i])) {
        atoms.append(qt_xdnd_types[i]);
        ++i;
    }
    QByteArray encoding;
    Atom a = X11->xdndMimeAtomForFormat(QLatin1String(format), requestedType, atoms, &encoding);
    if (!a)
        return result;

    if (XGetSelectionOwner(X11->display, ATOM(XdndSelection)) == XNone)
        return result; // should never happen?

    QWidget* tw = qt_xdnd_current_widget;
    if (!qt_xdnd_current_widget || (qt_xdnd_current_widget->windowType() == Qt::Desktop))
        tw = new QWidget;

    XConvertSelection(X11->display, ATOM(XdndSelection), a, ATOM(XdndSelection), tw->effectiveWinId(),
                      qt_xdnd_target_current_time);
    XFlush(X11->display);

    XEvent xevent;
    bool got=X11->clipboardWaitForEvent(tw->effectiveWinId(), SelectionNotify, &xevent, 5000);
    if (got) {
        Atom type;

        if (X11->clipboardReadProperty(tw->effectiveWinId(), ATOM(XdndSelection), true, &result, 0, &type, 0)) {
            if (type == ATOM(INCR)) {
                int nbytes = result.size() >= 4 ? *((int*)result.data()) : 0;
                result = X11->clipboardReadIncrementalProperty(tw->effectiveWinId(), ATOM(XdndSelection), nbytes, false);
            } else if (type != a && type != XNone) {
                DEBUG("Qt clipboard: unknown atom %ld", type);
            }
        }
    }
    if (!qt_xdnd_current_widget || (qt_xdnd_current_widget->windowType() == Qt::Desktop))
        delete tw;

    return X11->xdndMimeConvertToFormat(a, result, QLatin1String(format), requestedType, encoding);
}

xdndProxy()

static WId xdndProxy ( WId  w )

static

Definition at line 335 of file qdnd_x11.cpp.

Referenced by findRealWindow(), and xdndEnable().

{
    Atom type = XNone;
    int f;
    unsigned long n, a;
    unsigned char *retval = 0;
    XGetWindowProperty(X11->display, w, ATOM(XdndProxy), 0, 1, False,
                       XA_WINDOW, &type, &f,&n,&a,&retval);
    WId *proxy_id_ptr = (WId *)retval;
    WId proxy_id = 0;
    if (type == XA_WINDOW && proxy_id_ptr) {
        proxy_id = *proxy_id_ptr;
        XFree(proxy_id_ptr);
        proxy_id_ptr = 0;
        // Already exists. Real?
        X11->ignoreBadwindow();
        XGetWindowProperty(X11->display, proxy_id, ATOM(XdndProxy), 0, 1, False,
                           XA_WINDOW, &type, &f,&n,&a,&retval);
        proxy_id_ptr = (WId *)retval;
        if (X11->badwindow() || type != XA_WINDOW || !proxy_id_ptr || *proxy_id_ptr != proxy_id)
            // Bogus - we will overwrite.
            proxy_id = 0;
    }
    if (proxy_id_ptr)
        XFree(proxy_id_ptr);
    return proxy_id;
}

Variable Documentation

copyCursor

QCursor* copyCursor = 0

static

Definition at line 255 of file qdnd_x11.cpp.

Referenced by qt_xdnd_cleanup().

current_embedding_widget

QWidget* current_embedding_widget = 0

static

Definition at line 249 of file qdnd_x11.cpp.

Referenced by findRealWindow(), and QX11Data::xdndHandleFinished().

default_pm

const char* const default_pm[]

static

Initial value:

= {
"13 9 3 1",
".      c None",
"       c #000000",
"X      c #FFFFFF",
"X X X X X X X",
" X X X X X X ",
"X ......... X",
" X.........X ",
"X ......... X",
" X.........X ",
"X ......... X",
" X X X X X X ",
"X X X X X X X"
}

Definition at line 262 of file qdnd_x11.cpp.

default_pm_hotx

const int default_pm_hotx = -2

static

Definition at line 260 of file qdnd_x11.cpp.

default_pm_hoty

const int default_pm_hoty = -16

static

Definition at line 261 of file qdnd_x11.cpp.

defaultPm

QPixmap* defaultPm = 0

static

Definition at line 258 of file qdnd_x11.cpp.

Referenced by qt_xdnd_cleanup().

global_accepted_action

Qt::DropAction global_accepted_action = Qt::CopyAction

static

Definition at line 245 of file qdnd_x11.cpp.

Referenced by QX11Data::dndEnable(), handle_xdnd_status(), qt_xdnd_send_leave(), and QX11Data::xdndHandleDrop().

heartbeat

int heartbeat = -1

static

Definition at line 220 of file qdnd_x11.cpp.

Referenced by QX11Data::dndEnable(), and findRealWindow().

last_enter_event

XEvent last_enter_event

static

Definition at line 250 of file qdnd_x11.cpp.

Referenced by checkEmbedded(), and QX11Data::xdndHandleEnter().

last_target_accepted_action

Qt::DropAction last_target_accepted_action = Qt::IgnoreAction

static

Definition at line 242 of file qdnd_x11.cpp.

Referenced by handle_xdnd_position().

linkCursor

QCursor* linkCursor = 0

static

Definition at line 256 of file qdnd_x11.cpp.

Referenced by qt_xdnd_cleanup().

moveCursor

QCursor* moveCursor = 0

static

Definition at line 254 of file qdnd_x11.cpp.

Referenced by QLineControl::cursorForward(), QLineControl::cursorWordBackward(), QLineControl::cursorWordForward(), QLineControl::end(), QLineControl::home(), QCalendarView::keyboardSearch(), qt_xdnd_cleanup(), QLineControl::selectAll(), QLineControl::setCursorMoveStyle(), QLineControl::setCursorPosition(), QLineControl::setInputMask(), QTextControl::toHtml(), and QPlainTextEdit::toPlainText().

noDropCursor

QCursor* noDropCursor = 0

static

Definition at line 253 of file qdnd_x11.cpp.

Referenced by qt_xdnd_cleanup().

possible_actions

Qt::DropActions possible_actions = Qt::IgnoreAction

static

Definition at line 246 of file qdnd_x11.cpp.

Referenced by findRealWindow(), handle_xdnd_position(), and QX11Data::xdndHandleDrop().

qt_xdnd_current_position

QPoint qt_xdnd_current_position

static

Definition at line 231 of file qdnd_x11.cpp.

qt_xdnd_current_proxy_target

Window qt_xdnd_current_proxy_target

static

Definition at line 226 of file qdnd_x11.cpp.

Referenced by checkEmbedded(), findRealWindow(), handle_xdnd_status(), qt_xdnd_send_leave(), QX11Data::xdndHandleBadwindow(), and QX11Data::xdndHandleFinished().

qt_xdnd_current_screen

int qt_xdnd_current_screen = -1

static

Definition at line 235 of file qdnd_x11.cpp.

Referenced by findRealWindow().

qt_xdnd_current_target

Window qt_xdnd_current_target

static

Definition at line 224 of file qdnd_x11.cpp.

Referenced by checkEmbedded(), findRealWindow(), qt_xdnd_send_leave(), QX11Data::xdndHandleBadwindow(), QX11Data::xdndHandleFinished(), and QX11Data::xdndHandleSelectionRequest().

qt_xdnd_current_widget

QPointer<QWidget> qt_xdnd_current_widget

static

Definition at line 230 of file qdnd_x11.cpp.

Referenced by xdndObtainData().

qt_xdnd_dragging

bool qt_xdnd_dragging = false

Definition at line 237 of file qdnd_x11.cpp.

Referenced by QX11Data::dndEnable(), findRealWindow(), qt_try_modal(), QETWidget::translateMouseEvent(), QApplication::x11ProcessEvent(), and QX11Data::xdndHandleDrop().

qt_xdnd_dragsource_xid

Atom qt_xdnd_dragsource_xid = 0

static

Definition at line 213 of file qdnd_x11.cpp.

Referenced by handle_xdnd_position(), QX11Data::xdndHandleBadwindow(), QX11Data::xdndHandleDrop(), QX11Data::xdndHandleEnter(), QX11Data::xdndHandleLeave(), and xdndObtainData().

qt_xdnd_max_type

const int qt_xdnd_max_type = 100

Definition at line 216 of file qdnd_x11.cpp.

Referenced by QX11Data::xdndHandleEnter().

qt_xdnd_source_current_time

Time qt_xdnd_source_current_time

static

Definition at line 227 of file qdnd_x11.cpp.

Referenced by findRealWindow(), qt_xdnd_send_leave(), and QX11Data::xdndHandleSelectionRequest().

qt_xdnd_source_sameanswer

QRect qt_xdnd_source_sameanswer

static

Definition at line 222 of file qdnd_x11.cpp.

qt_xdnd_target_current_time

Time qt_xdnd_target_current_time

static

Definition at line 233 of file qdnd_x11.cpp.

Referenced by handle_xdnd_position(), QX11Data::xdndHandleDrop(), and xdndObtainData().

qt_xdnd_types

Atom qt_xdnd_types[qt_xdnd_max_type+1]

static

Definition at line 217 of file qdnd_x11.cpp.

Referenced by QX11Data::xdndHandleEnter(), QX11Data::xdndHandleLeave(), and xdndObtainData().

transaction_expiry_timer

int transaction_expiry_timer = -1

static

Definition at line 121 of file qdnd_x11.cpp.

Referenced by restartXdndDropExpiryTimer().

waiting_for_status

bool waiting_for_status = false

static

Definition at line 239 of file qdnd_x11.cpp.

Referenced by findRealWindow(), handle_xdnd_status(), qt_xdnd_send_leave(), and QX11Data::xdndHandleDrop().

xdnd_data

XdndData xdnd_data = { 0, 0 }

static

Definition at line 321 of file qdnd_x11.cpp.

xdnd_version

const int xdnd_version = 5

Definition at line 176 of file qdnd_x11.cpp.

Referenced by findRealWindow(), xdndEnable(), and QX11Data::xdndHandleEnter().