src/gui/kernel/qdnd_x11.cpp File Reference

#include "qplatformdefs.h"
#include "qapplication.h"
#include "qwidget.h"
#include "qpixmap.h"
#include "qbitmap.h"
#include "qdesktopwidget.h"
#include "qevent.h"
#include "qdatetime.h"
#include "qiodevice.h"
#include "qpointer.h"
#include "qcursor.h"
#include "qvariant.h"
#include "qvector.h"
#include "qurl.h"
#include "qdebug.h"
#include "qimagewriter.h"
#include "qbuffer.h"
#include "qdnd_p.h"
#include "qt_x11_p.h"
#include "qx11info_x11.h"
#include "qwidget_p.h"
#include "qcursor_p.h"

Include dependency graph for qdnd_x11.cpp:

Go to the source code of this file.

Classes
class	QShapedPixmapWidget
struct	XdndData
class	QExtraWidget
Defines
#define	DEBUG   if(0) qDebug
#define	DNDDEBUG   if(0) qDebug()
Enumerations
enum
Functions
static int	findXdndDropTransactionByWindow (Window window)
static int	findXdndDropTransactionByTime (Time timestamp)
static void	restartXdndDropExpiryTimer ()
static Window	findXdndAwareParent (Window window)
static void	handle_xdnd_position (QWidget *, const XEvent *, bool)
static void	handle_xdnd_status (QWidget *w, const XEvent *xe, bool)
static Qt::DropAction	xdndaction_to_qtaction (Atom atom)
static int	qtaction_to_xdndaction (Qt::DropAction a)
static void	qt_xdnd_cleanup ()
static void	qt_xdnd_send_leave ()
static WId	xdndProxy (WId w)
static bool	xdndEnable (QWidget *w, bool on)
static QWidget *	find_child (QWidget *tlw, QPoint &p)
static bool	checkEmbedded (QWidget *w, const XEvent *xe)
static Bool	xdnd_position_scanner (Display *, XEvent *event, XPointer)
static Bool	xdnd_status_scanner (Display *, XEvent *event, XPointer)
static Window	findRealWindow (const QPoint &pos, Window w, int md)
static QByteArray	xdndObtainData (const char *format)
Variables
static int	transaction_expiry_timer = -1
const int	xdnd_version = 5
static Atom	qt_xdnd_dragsource_xid = 0
const int	qt_xdnd_max_type = 100
static Atom	qt_xdnd_types [qt_xdnd_max_type+1]
static int	heartbeat = -1
static QRect	qt_xdnd_source_sameanswer
static Window	qt_xdnd_current_target
static Window	qt_xdnd_current_proxy_target
static Time	qt_xdnd_source_current_time
static QPointer< QWidget >	qt_xdnd_current_widget
static QPoint	qt_xdnd_current_position
static Time	qt_xdnd_target_current_time
static int	qt_xdnd_current_screen = -1
bool	qt_xdnd_dragging = false
static bool	waiting_for_status = false
static Qt::DropAction	last_target_accepted_action = Qt::IgnoreAction
static Qt::DropAction	global_accepted_action = Qt::CopyAction
static Qt::DropActions	possible_actions = Qt::IgnoreAction
static QWidget *	current_embedding_widget = 0
static XEvent	last_enter_event
static QCursor *	noDropCursor = 0
static QCursor *	moveCursor = 0
static QCursor *	copyCursor = 0
static QCursor *	linkCursor = 0
static QPixmap *	defaultPm = 0
static const int	default_pm_hotx = -2
static const int	default_pm_hoty = -16
static const char *const	default_pm []
static XdndData	xdnd_data = { 0, 0 }

---

Define Documentation

#define DEBUG   if(0) qDebug

Definition at line 57 of file qdnd_x11.cpp.

#define DNDDEBUG   if(0) qDebug()

Definition at line 63 of file qdnd_x11.cpp.

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

---

Enumeration Type Documentation

anonymous enum

Definition at line 94 of file qdnd_x11.cpp.

{ XdndDropTransactionTimeout = 5000 }; // 5 seconds

---

Function Documentation

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

Definition at line 702 of file qdnd_x11.cpp.

References current_embedding_widget, last_enter_event, qt_xdnd_current_proxy_target, qt_xdnd_current_target, qt_xdnd_current_widget, qt_xdnd_send_leave(), w, and X11.

Referenced by handle_xdnd_position(), QX11Data::xdndHandleDrop(), QX11Data::xdndHandleFinished(), 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;
}

Here is the call graph for this function:

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

Definition at line 669 of file qdnd_x11.cpp.

References QObject::children(), i, QWidget::mapFromGlobal(), QWidget::mapFromParent(), p, qobject_cast< QWidget * >(), QObject::QObjectList(), and w.

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->isVisible() &&
                     w->geometry().contains(p) &&
                     !w->isWindow()) {
                    widget = w;
                    done = false;
                    p = widget->mapFromParent(p);
                    break;
                }
            }
        }
    }
    return widget;
}

Here is the call graph for this function:

static Window findRealWindow	(	const QPoint &	pos,
		Window	w,
		int	md
	)			[static]

Definition at line 1318 of file qdnd_x11.cpp.

References a, ATOM, c, data, XdndData::deco, i, QWidget::internalWinId(), n, p, type, w, X11, xdnd_data, and XNone.

Referenced by QDragManager::move().

{
    if (xdnd_data.deco && w == xdnd_data.deco->internalWinId())
        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)) {
            {
                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)
                    return w;
            }

            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);
                }
                XFree(c);
                if (r)
                    return r;

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

            // No children!
            return w;
        }
    }
    return 0;
}

Here is the call graph for this function:

static Window findXdndAwareParent

(

Window

window

)

[static]

Definition at line 105 of file qdnd_x11.cpp.

References a, ATOM, data, n, Success, type, and X11.

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;
}

static int findXdndDropTransactionByTime

(

Time

timestamp

)

[static]

Definition at line 79 of file qdnd_x11.cpp.

References i, t, and X11.

Referenced by 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;
}

static int findXdndDropTransactionByWindow

(

Window

window

)

[static]

Definition at line 66 of file qdnd_x11.cpp.

References i, t, and X11.

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;
}

static void handle_xdnd_position	(	QWidget *	,
		const XEvent *	,
		bool
	)			[static]

Definition at line 775 of file qdnd_x11.cpp.

References QDragMoveEvent::accept(), QWidget::acceptDrops(), QDragMoveEvent::answerRect(), ATOM, c, checkEmbedded(), QDragPrivate::data, DEBUG, Qt::Desktop, QDragManager::dragPrivate(), QDropEvent::dropAction(), QDragManager::dropData, QWidget::find(), find_child(), handle_xdnd_status(), Qt::IgnoreAction, QRect::intersected(), QEvent::isAccepted(), QApplication::keyboardModifiers(), l, last_target_accepted_action, QApplication::mouseButtons(), QDragManager::object, p, QDragPrivate::possible_actions, possible_actions, qt_xdnd_current_position, qt_xdnd_current_widget, qt_xdnd_dragsource_xid, qt_xdnd_target_current_time, qtaction_to_xdndaction(), QDragManager::self(), QCoreApplication::sendEvent(), QDropEvent::setDropAction(), QRect::setLeft(), w, QWidget::windowType(), X11, and xdndaction_to_qtaction().

Referenced by QDragManager::move(), 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;
    }

    if (l[3] != 0) {
        // timestamp from the source
        qt_xdnd_target_current_time = X11->userTime = 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->internalWinId();
    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);
}

Here is the call graph for this function:

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

Definition at line 929 of file qdnd_x11.cpp.

References QDragManager::emitActionChanged(), global_accepted_action, Qt::IgnoreAction, l, p, qt_xdnd_current_proxy_target, qt_xdnd_source_sameanswer, s, QDragManager::self(), QDragManager::updateCursor(), waiting_for_status, QDragManager::willDrop, and xdndaction_to_qtaction().

Referenced by 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;
}

Here is the call graph for this function:

void qt_xdnd_cleanup

(

)

[static]

Definition at line 650 of file qdnd_x11.cpp.

References copyCursor, XdndData::deco, defaultPm, XdndData::desktop_proxy, linkCursor, moveCursor, noDropCursor, and xdnd_data.

Referenced by 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;
}

void qt_xdnd_send_leave

(

)

[static]

Definition at line 1007 of file qdnd_x11.cpp.

References ATOM, Qt::Desktop, QDragManager::emitActionChanged(), QWidget::find(), global_accepted_action, Qt::IgnoreAction, qt_xdnd_current_proxy_target, qt_xdnd_current_target, qt_xdnd_dragsource_xid, qt_xdnd_source_current_time, QDragManager::self(), QDragManager::updateCursor(), w, waiting_for_status, QDragManager::willDrop, and X11.

Referenced by QDragManager::cancel(), checkEmbedded(), and QDragManager::move().

{
    if (!qt_xdnd_current_target)
        return;

    XClientMessageEvent leave;
    leave.type = ClientMessage;
    leave.window = qt_xdnd_current_target;
    leave.format = 32;
    leave.message_type = ATOM(XdndLeave);
    leave.data.l[0] = qt_xdnd_dragsource_xid;
    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
    QDragManager *manager = QDragManager::self();
    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;
}

Here is the call graph for this function:

static int qtaction_to_xdndaction

(

Qt::DropAction

a

)

[static]

Definition at line 161 of file qdnd_x11.cpp.

References ATOM, Qt::CopyAction, Qt::IgnoreAction, Qt::LinkAction, Qt::MoveAction, Qt::TargetMoveAction, and XNone.

Referenced by handle_xdnd_position(), QDragManager::move(), 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);
    }
}

static void restartXdndDropExpiryTimer

(

)

[static]

Definition at line 96 of file qdnd_x11.cpp.

References QObject::killTimer(), QDragManager::self(), QObject::startTimer(), transaction_expiry_timer, and XdndDropTransactionTimeout.

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

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

Here is the call graph for this function:

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

Definition at line 907 of file qdnd_x11.cpp.

References ATOM.

Referenced by QX11Data::xdndHandlePosition().

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

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

    return false;
}

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

Definition at line 953 of file qdnd_x11.cpp.

References ATOM.

Referenced by QX11Data::xdndHandleStatus().

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

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

    return false;
}

static Qt::DropAction xdndaction_to_qtaction

(

Atom

atom

)

[static]

Definition at line 150 of file qdnd_x11.cpp.

References ATOM, Qt::CopyAction, Qt::LinkAction, and Qt::MoveAction.

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;
}

static bool xdndEnable	(	QWidget *	w,
		bool	on
	)			[static]

Definition at line 321 of file qdnd_x11.cpp.

References ATOM, Qt::Desktop, XdndData::desktop_proxy, DNDDEBUG, QWidget::internalWinId(), QWidget::testAttribute(), w, Qt::WA_WState_Created, QWidget::WId(), X11, xdnd_data, xdnd_version, and xdndProxy().

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->internalWinId());

            if (!proxy_id) {
                xdnd_widget = xdnd_data.desktop_proxy = new QWidget;
                proxy_id = xdnd_data.desktop_proxy->internalWinId();
                XChangeProperty (X11->display, w->internalWinId(), 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->internalWinId();
            Atom atm = (Atom)xdnd_version;
            Q_ASSERT(xdnd_widget->testAttribute(Qt::WA_WState_Created));
            XChangeProperty(X11->display, xdnd_widget->internalWinId(), 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;
    }
}

Here is the call graph for this function:

static QByteArray xdndObtainData

(

const char *

format

)

[static]

Definition at line 1728 of file qdnd_x11.cpp.

References a, QList< T >::append(), ATOM, QByteArray::data(), DEBUG, Qt::Desktop, QDragManager::dragPrivate(), QWidget::find(), i, INCR, QWidget::internalWinId(), o, QDragManager::object, qt_xdnd_current_widget, qt_xdnd_dragsource_xid, qt_xdnd_target_current_time, qt_xdnd_types, QDragManager::self(), QByteArray::size(), type, w, X11, and XNone.

Referenced by QDropData::retrieveData_sys().

{
    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();
        if (o->data->hasFormat(QLatin1String(format)))
            result = o->data->data(QLatin1String(format));
        return result;
    }

    QList<Atom> atoms;
    int i = 0;
    while ((qt_xdnd_types[i])) {
        atoms.append(qt_xdnd_types[i]);
        ++i;
    }
    Atom a = X11->xdndMimeAtomForFormat(QLatin1String(format), atoms);
    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->internalWinId(),
                      qt_xdnd_target_current_time);
    XFlush(X11->display);

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

        if (X11->clipboardReadProperty(tw->internalWinId(), ATOM(XdndSelection), true, &result, 0, &type, 0, false)) {
            if (type == ATOM(INCR)) {
                int nbytes = result.size() >= 4 ? *((int*)result.data()) : 0;
                result = X11->clipboardReadIncrementalProperty(tw->internalWinId(), 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));
}

Here is the call graph for this function:

static WId xdndProxy

(

WId

w

)

[static]

Definition at line 295 of file qdnd_x11.cpp.

References a, ATOM, n, type, QWidget::WId(), X11, and XNone.

Referenced by QDragManager::move(), and xdndEnable().

{
    Atom type = XNone;
    int f;
    unsigned long n, a;
    WId *proxy_id_ptr;
    XGetWindowProperty(X11->display, w, ATOM(XdndProxy), 0, 1, False,
                       XA_WINDOW, &type, &f,&n,&a,(uchar**)&proxy_id_ptr);
    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,(uchar**)&proxy_id_ptr);
        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;
}

Here is the call graph for this function:

---

Variable Documentation

QCursor* copyCursor = 0 [static]

Definition at line 227 of file qdnd_x11.cpp.

Referenced by QDragManager::drag(), qt_xdnd_cleanup(), and QDragManager::updateCursor().

QWidget* current_embedding_widget = 0 [static]

Definition at line 221 of file qdnd_x11.cpp.

Referenced by checkEmbedded(), QDragManager::drop(), QX11Data::xdndHandleDrop(), QX11Data::xdndHandleFinished(), and QX11Data::xdndHandleLeave().

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 234 of file qdnd_x11.cpp.

Referenced by QDragManager::updatePixmap().

const int default_pm_hotx = -2 [static]

Definition at line 232 of file qdnd_x11.cpp.

Referenced by QDragManager::updatePixmap().

const int default_pm_hoty = -16 [static]

Definition at line 233 of file qdnd_x11.cpp.

Referenced by QDragManager::updatePixmap().

QPixmap* defaultPm = 0 [static]

Definition at line 230 of file qdnd_x11.cpp.

Referenced by qt_xdnd_cleanup(), and QDragManager::updatePixmap().

Qt::DropAction global_accepted_action = Qt::CopyAction [static]

Definition at line 217 of file qdnd_x11.cpp.

Referenced by QDragManager::cancel(), QDragManager::drag(), handle_xdnd_status(), qt_xdnd_send_leave(), QDragManager::updateCursor(), and QX11Data::xdndHandleDrop().

int heartbeat = -1 [static]

Definition at line 192 of file qdnd_x11.cpp.

Referenced by QDragManager::cancel(), QDragManager::drag(), QDragManager::drop(), and QDragManager::timerEvent().

XEvent last_enter_event [static]

Definition at line 222 of file qdnd_x11.cpp.

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

Qt::DropAction last_target_accepted_action = Qt::IgnoreAction [static]

Definition at line 214 of file qdnd_x11.cpp.

Referenced by handle_xdnd_position().

QCursor* linkCursor = 0 [static]

Definition at line 228 of file qdnd_x11.cpp.

Referenced by QDragManager::drag(), qt_xdnd_cleanup(), and QDragManager::updateCursor().

QCursor* moveCursor = 0 [static]

Definition at line 226 of file qdnd_x11.cpp.

Referenced by QDragManager::drag(), qt_xdnd_cleanup(), and QDragManager::updateCursor().

QCursor* noDropCursor = 0 [static]

Definition at line 225 of file qdnd_x11.cpp.

Referenced by QDragManager::drag(), qt_xdnd_cleanup(), and QDragManager::updateCursor().

Qt::DropActions possible_actions = Qt::IgnoreAction [static]

Definition at line 218 of file qdnd_x11.cpp.

Referenced by handle_xdnd_position(), QDragManager::move(), and QX11Data::xdndHandleDrop().

QPoint qt_xdnd_current_position [static]

Definition at line 203 of file qdnd_x11.cpp.

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

Window qt_xdnd_current_proxy_target [static]

Definition at line 198 of file qdnd_x11.cpp.

Referenced by checkEmbedded(), QDragManager::drop(), handle_xdnd_status(), QDragManager::move(), qt_xdnd_send_leave(), QX11Data::xdndHandleBadwindow(), and QX11Data::xdndHandleFinished().

int qt_xdnd_current_screen = -1 [static]

Definition at line 207 of file qdnd_x11.cpp.

Referenced by QDragManager::drag(), and QDragManager::move().

Window qt_xdnd_current_target [static]

Definition at line 196 of file qdnd_x11.cpp.

Referenced by QDragManager::cancel(), checkEmbedded(), QDragManager::drop(), QDragManager::move(), qt_xdnd_send_leave(), QX11Data::xdndHandleBadwindow(), QX11Data::xdndHandleFinished(), and QX11Data::xdndHandleSelectionRequest().

QPointer<QWidget> qt_xdnd_current_widget [static]

Definition at line 202 of file qdnd_x11.cpp.

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

bool qt_xdnd_dragging = false

Definition at line 209 of file qdnd_x11.cpp.

Referenced by QDragManager::cancel(), QDragManager::drag(), QDragManager::drop(), qt_try_modal(), and QETWidget::translateMouseEvent().

Atom qt_xdnd_dragsource_xid = 0 [static]

Definition at line 185 of file qdnd_x11.cpp.

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

const int qt_xdnd_max_type = 100

Definition at line 188 of file qdnd_x11.cpp.

Referenced by QX11Data::xdndHandleEnter().

Time qt_xdnd_source_current_time [static]

Definition at line 199 of file qdnd_x11.cpp.

Referenced by QDragManager::drop(), QDragManager::move(), qt_xdnd_send_leave(), and QX11Data::xdndHandleSelectionRequest().

QRect qt_xdnd_source_sameanswer [static]

Definition at line 194 of file qdnd_x11.cpp.

Referenced by QDragManager::drag(), QDragManager::eventFilter(), handle_xdnd_status(), QDragManager::move(), and QDragManager::timerEvent().

Time qt_xdnd_target_current_time [static]

Definition at line 205 of file qdnd_x11.cpp.

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

Atom qt_xdnd_types[qt_xdnd_max_type+1] [static]

Definition at line 189 of file qdnd_x11.cpp.

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

int transaction_expiry_timer = -1 [static]

Definition at line 93 of file qdnd_x11.cpp.

Referenced by restartXdndDropExpiryTimer(), and QDragManager::timerEvent().

bool waiting_for_status = false [static]

Definition at line 211 of file qdnd_x11.cpp.

Referenced by handle_xdnd_status(), QDragManager::move(), qt_xdnd_send_leave(), QX11Data::xdndHandleDrop(), and QX11Data::xdndHandleFinished().

XdndData xdnd_data = { 0, 0 } [static]

Definition at line 281 of file qdnd_x11.cpp.

Referenced by QDragManager::cancel(), QDragManager::drag(), QDragManager::drop(), findRealWindow(), QDragManager::move(), qt_xdnd_cleanup(), QDragManager::updateCursor(), QDragManager::updatePixmap(), xdndEnable(), and QX11Data::xdndHandleBadwindow().

const int xdnd_version = 5

Definition at line 148 of file qdnd_x11.cpp.

Referenced by QDragManager::move(), xdndEnable(), and QX11Data::xdndHandleEnter().

---