diff options
author | Timothy Pearson <kb9vqf@pearsoncomputing.net> | 2011-07-10 15:17:53 -0500 |
---|---|---|
committer | Timothy Pearson <kb9vqf@pearsoncomputing.net> | 2011-07-10 15:17:53 -0500 |
commit | 37e3f157c7d76f13de807fa66e36df209e1005fb (patch) | |
tree | 7a4f131b2ee065337dac341bff34515310efba4f /experimental/tqtinterface/qt4/src/kernel/tqdnd_x11.cpp | |
parent | 16630c3eff313238fa8412275555285c9195981b (diff) | |
download | tde-37e3f157c7d76f13de807fa66e36df209e1005fb.tar.gz tde-37e3f157c7d76f13de807fa66e36df209e1005fb.zip |
Added TQt4 HEAD
Diffstat (limited to 'experimental/tqtinterface/qt4/src/kernel/tqdnd_x11.cpp')
-rw-r--r-- | experimental/tqtinterface/qt4/src/kernel/tqdnd_x11.cpp | 1765 |
1 files changed, 1765 insertions, 0 deletions
diff --git a/experimental/tqtinterface/qt4/src/kernel/tqdnd_x11.cpp b/experimental/tqtinterface/qt4/src/kernel/tqdnd_x11.cpp new file mode 100644 index 000000000..78823494f --- /dev/null +++ b/experimental/tqtinterface/qt4/src/kernel/tqdnd_x11.cpp @@ -0,0 +1,1765 @@ +/**************************************************************************** +** +** XDND implementation for TQt. See http://www.cco.caltech.edu/~jafl/xdnd/ +** +** Created : 980320 +** +** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA. +** +** This file is part of the kernel module of the TQt GUI Toolkit. +** +** This file may be used under the terms of the GNU General +** Public License versions 2.0 or 3.0 as published by the Free +** Software Foundation and appearing in the files LICENSE.GPL2 +** and LICENSE.GPL3 included in the packaging of this file. +** Alternatively you may (at your option) use any later version +** of the GNU General Public License if such license has been +** publicly approved by Trolltech ASA (or its successors, if any) +** and the KDE Free TQt Foundation. +** +** Please review the following information to ensure GNU General +** Public Licensing requirements will be met: +** http://trolltech.com/products/qt/licenses/licensing/opensource/. +** If you are unsure which license is appropriate for your use, please +** review the following information: +** http://trolltech.com/products/qt/licenses/licensing/licensingoverview +** or contact the sales department at sales@trolltech.com. +** +** This file may be used under the terms of the Q Public License as +** defined by Trolltech ASA and appearing in the file LICENSE.TQPL +** included in the packaging of this file. Licensees holding valid TQt +** Commercial licenses may use this file in accordance with the TQt +** Commercial License Agreement provided with the Software. +** +** This file is provided "AS IS" with NO WARRANTY OF ANY KIND, +** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted +** herein. +** +**********************************************************************/ + +#include "tqplatformdefs.h" + +#include "tqapplication.h" + +#ifndef TQT_NO_DRAGANDDROP + +#include "tqwidget.h" +#include "tqintdict.h" +#include "tqdatetime.h" +#include "tqdict.h" +#include "tqguardedptr.h" +#include "tqdragobject.h" +#include "tqobjectlist.h" +#include "tqcursor.h" + +#include "tqt_x11_p.h" + +// conflict resolution + +// unused, may be used again later: const int XKeyPress = KeyPress; +// unused, may be used again later: const int XKeyRelease = KeyRelease; +#undef KeyPress +#undef KeyRelease + +// this stuff is copied from qapp_x11.cpp + +extern void qt_x11_intern_atom( const char *, Atom * ); + +#if defined(TQ_C_CALLBACKS) +extern "C" { +#endif + +extern void qt_ignore_badwindow(); +extern bool qt_badwindow(); +extern void qt_enter_modal( TQWidget *widget ); +extern void qt_leave_modal( TQWidget *widget ); + +#if defined(TQ_C_CALLBACKS) +} +#endif + +extern Window qt_x11_tqfindClientWindow( Window, Atom, bool ); +extern Atom qt_wm_state; + +// this stuff is copied from qclb_x11.cpp + +extern bool qt_xclb_wait_for_event( Display *dpy, Window win, int type, + XEvent *event, int timeout ); +extern bool qt_xclb_read_property( Display *dpy, Window win, Atom property, + bool deleteProperty, + TQByteArray *buffer, int *size, Atom *type, + int *format, bool nullterm ); +extern TQByteArray qt_xclb_read_incremental_property( Display *dpy, Window win, + Atom property, + int nbytes, bool nullterm ); +// and all this stuff is copied -into- qapp_x11.cpp + +void qt_xdnd_setup(); +void qt_handle_xdnd_enter( TQWidget *, const XEvent *, bool ); +void qt_handle_xdnd_position( TQWidget *, const XEvent *, bool ); +void qt_handle_xdnd_status( TQWidget *, const XEvent *, bool ); +void qt_handle_xdnd_leave( TQWidget *, const XEvent *, bool ); +void qt_handle_xdnd_drop( TQWidget *, const XEvent *, bool ); +void qt_handle_xdnd_finished( TQWidget *, const XEvent *, bool ); +void qt_xdnd_handle_selection_request( const XSelectionRequestEvent * ); +bool qt_xdnd_handle_badwindow(); +// client messages +Atom qt_xdnd_enter; +Atom qt_xdnd_position; +Atom qt_xdnd_status; +Atom qt_xdnd_leave; +Atom qt_xdnd_drop; +Atom qt_xdnd_finished; +Atom qt_xdnd_type_list; +const int qt_xdnd_version = 4; + +// Actions +// +// The Xdnd spec allows for user-defined actions. This could be implemented +// with a registration process in TQt. WE SHOULD do that later. +// +Atom qt_xdnd_action_copy; +Atom qt_xdnd_action_link; +Atom qt_xdnd_action_move; +Atom qt_xdnd_action_private; +static +TQDropEvent::Action xdndaction_to_qtaction(Atom atom) +{ + if ( atom == qt_xdnd_action_copy || atom == 0 ) + return TQDropEvent::Copy; + if ( atom == qt_xdnd_action_link ) + return TQDropEvent::Link; + if ( atom == qt_xdnd_action_move ) + return TQDropEvent::Move; + return TQDropEvent::Private; +} +static +int qtaction_to_xdndaction(TQDropEvent::Action a) +{ + switch ( a ) { + case TQDropEvent::Copy: + return qt_xdnd_action_copy; + case TQDropEvent::Link: + return qt_xdnd_action_link; + case TQDropEvent::Move: + return qt_xdnd_action_move; + case TQDropEvent::Private: + return qt_xdnd_action_private; + default: + return qt_xdnd_action_copy; + } +} + +// clean up the stuff used. +static void qt_xdnd_cleanup(); + +static void qt_xdnd_send_leave(); + +// XDND selection +Atom qt_xdnd_selection; +// other selection +static Atom qt_selection_property; +// INCR +static Atom qt_incr_atom; + +// properties for XDND drop sites +Atom qt_xdnd_aware; +Atom qt_xdnd_proxy; + +// real variables: +// xid of current drag source +static Atom qt_xdnd_dragsource_xid = 0; + +// the types in this drop. 100 is no good, but at least it's big. +const int qt_xdnd_max_type = 100; +static Atom qt_xdnd_types[qt_xdnd_max_type]; + +static TQIntDict<TQCString> * qt_xdnd_drag_types = 0; +static TQDict<Atom> * qt_xdnd_atom_numbers = 0; + +// timer used when target wants "continuous" move messages (eg. scroll) +static int heartbeat = -1; +// rectangle in which the answer will be the same +static TQRect qt_xdnd_source_sameanswer; +//static TQRect qt_xdnd_target_sameanswer; +static bool qt_xdnd_target_answerwas; +// top-level window we sent position to last. +static Window qt_xdnd_current_target; +// window to send events to (always valid if qt_xdnd_current_target) +static Window qt_xdnd_current_proxy_target; +// widget we forwarded position to last, and local position +static TQGuardedPtr<TQWidget> qt_xdnd_current_widget; +static TQPoint qt_xdnd_current_position; +// time of this drop, as type Atom to save on casts +static Atom qt_xdnd_source_current_time; +// timestamp from the XdndPosition and XdndDrop +static Time qt_xdnd_target_current_time; +// screen number containing the pointer... -1 means default +static int qt_xdnd_current_screen = -1; +// state of dragging... true if dragging, false if not +bool qt_xdnd_dragging = FALSE; + +// dict of payload data, sorted by type atom +static TQIntDict<TQByteArray> * qt_xdnd_target_data = 0; + +// first drag object, or 0 +static TQDragObject * qt_xdnd_source_object = 0; + +// Motif dnd +extern void qt_motifdnd_enable( TQWidget *, bool ); +extern TQByteArray qt_motifdnd_obtain_data( const char *format ); +extern const char *qt_motifdnd_format( int n ); + +bool qt_motifdnd_active = FALSE; +static bool dndCancelled = FALSE; + +// Shift/Ctrl handling, and final drop status +static TQDragObject::DragMode drag_mode; +static TQDropEvent::Action global_requested_action = TQDropEvent::Copy; +static TQDropEvent::Action global_accepted_action = TQDropEvent::Copy; + +// for embedding only +static TQWidget* current_embedding_widget = 0; +static XEvent last_enter_event; + +// cursors +static TQCursor *noDropCursor = 0; +static TQCursor *moveCursor = 0; +static TQCursor *copyCursor = 0; +static TQCursor *linkCursor = 0; + +static TQPixmap *defaultPm = 0; + +static const int default_pm_hotx = -2; +static const int default_pm_hoty = -16; +static const char* const default_pm[] = { +"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" +}; + +#define WStyle_Tool Qt::Tool +#define WStyle_NoBorder Qt::FramelessWindowHint + +class TQShapedPixmapWidget : public TQWidget { + +public: + TQShapedPixmapWidget(int screen = -1) : + TQWidget(TQApplication::desktop()->screen( screen ), + 0, (Qt::WindowType)(WStyle_Customize | WStyle_Tool | WStyle_NoBorder | WX11BypassWM) ) + { + } + + void setPixmap(TQPixmap pm) + { + const TQBitmap* mask = pm.tqmask(); + if ( mask ) { + setMask( *mask ); + } else { + clearMask(); + } + resize(pm.width(),pm.height()); + setErasePixmap(pm); + } +}; + +static TQShapedPixmapWidget * qt_xdnd_deco = 0; + +static TQWidget* desktop_proxy = 0; + +class TQExtraWidget : public TQWidget +{ +public: + TQWExtra* extraData() { return TQWidget::extraData(); } + TQTLWExtra* topData() { return TQWidget::topData(); } +}; + + +static bool qt_xdnd_enable( TQWidget* w, bool on ) +{ + if ( on ) { + TQWidget * xdnd_widget = 0; + if ( w->isDesktop() ) { + if ( desktop_proxy ) // *WE* already have one. + return FALSE; + + // As per Xdnd4, use XdndProxy + XGrabServer( w->x11Display() ); + Atom type = None; + int f; + unsigned long n, a; + WId *proxy_id_ptr; + XGetWindowProperty( w->x11Display(), w->winId(), + qt_xdnd_proxy, 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? + qt_ignore_badwindow(); + XGetWindowProperty( w->x11Display(), proxy_id, + qt_xdnd_proxy, 0, 1, False, + XA_WINDOW, &type, &f,&n,&a,(uchar**)&proxy_id_ptr ); + if ( qt_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); + + if ( !proxy_id ) { + xdnd_widget = desktop_proxy = new TQWidget; + proxy_id = desktop_proxy->winId(); + XChangeProperty ( w->x11Display(), + w->winId(), qt_xdnd_proxy, + XA_WINDOW, 32, PropModeReplace, + (unsigned char *)&proxy_id, 1 ); + XChangeProperty ( w->x11Display(), + proxy_id, qt_xdnd_proxy, + XA_WINDOW, 32, PropModeReplace, + (unsigned char *)&proxy_id, 1 ); + } + + XUngrabServer( w->x11Display() ); + } else { + xdnd_widget = w->tqtopLevelWidget(); + } + if ( xdnd_widget ) { + Atom atm = (Atom)qt_xdnd_version; + XChangeProperty ( xdnd_widget->x11Display(), xdnd_widget->winId(), + qt_xdnd_aware, XA_ATOM, 32, PropModeReplace, + (unsigned char *)&atm, 1 ); + return TRUE; + } else { + return FALSE; + } + } else { + if ( w->isDesktop() ) { + XDeleteProperty( w->x11Display(), w->winId(), + qt_xdnd_proxy ); + delete desktop_proxy; + desktop_proxy = 0; + } + return TRUE; + } +} + +const char* qt_xdnd_atom_to_str( Atom a ) +{ + if ( !a ) return 0; + + if ( a == XA_STRING ) + return "text/plain"; // some Xdnd clients are dumb + + if ( !qt_xdnd_drag_types ) { + qt_xdnd_drag_types = new TQIntDict<TQCString>( 17 ); + qt_xdnd_drag_types->setAutoDelete( TRUE ); + } + TQCString* result; + if ( !(result=qt_xdnd_drag_types->tqfind( a )) ) { + const char* mimeType = XGetAtomName( TQPaintDevice::x11AppDisplay(), a ); + if ( !mimeType ) + return 0; // only happens on protocol error + result = new TQCString( mimeType ); + qt_xdnd_drag_types->insert( (long)a, result ); + XFree((void*)mimeType); + } + return *result; +} + +Atom* qt_xdnd_str_to_atom( const char *mimeType ) +{ + if ( !mimeType || !*mimeType ) + return 0; + if ( !qt_xdnd_atom_numbers ) { + qt_xdnd_atom_numbers = new TQDict<Atom>( 17 ); + qt_xdnd_atom_numbers->setAutoDelete( TRUE ); + } + + Atom * result; + if ( (result = qt_xdnd_atom_numbers->tqfind( mimeType )) ) + return result; + + result = new Atom; + *result = 0; + qt_x11_intern_atom( mimeType, result ); + qt_xdnd_atom_numbers->insert( mimeType, result ); + qt_xdnd_atom_to_str( *result ); + + return result; +} + + +void qt_xdnd_setup() { + // set up protocol atoms + qt_x11_intern_atom( "XdndEnter", &qt_xdnd_enter ); + qt_x11_intern_atom( "XdndPosition", &qt_xdnd_position ); + qt_x11_intern_atom( "XdndtqStatus", &qt_xdnd_status ); + qt_x11_intern_atom( "XdndLeave", &qt_xdnd_leave ); + qt_x11_intern_atom( "XdndDrop", &qt_xdnd_drop ); + qt_x11_intern_atom( "XdndFinished", &qt_xdnd_finished ); + qt_x11_intern_atom( "XdndTypeList", &qt_xdnd_type_list ); + + qt_x11_intern_atom( "XdndSelection", &qt_xdnd_selection ); + + qt_x11_intern_atom( "XdndAware", &qt_xdnd_aware ); + qt_x11_intern_atom( "XdndProxy", &qt_xdnd_proxy ); + + + qt_x11_intern_atom( "XdndActionCopy", &qt_xdnd_action_copy ); + qt_x11_intern_atom( "XdndActionLink", &qt_xdnd_action_link ); + qt_x11_intern_atom( "XdndActionMove", &qt_xdnd_action_move ); + qt_x11_intern_atom( "XdndActionPrivate", &qt_xdnd_action_private ); + + qt_x11_intern_atom( "TQT_SELECTION", &qt_selection_property ); + qt_x11_intern_atom( "INCR", &qt_incr_atom ); + + qAddPostRoutine( qt_xdnd_cleanup ); +} + + +void qt_xdnd_cleanup() +{ + delete qt_xdnd_drag_types; + qt_xdnd_drag_types = 0; + delete qt_xdnd_atom_numbers; + qt_xdnd_atom_numbers = 0; + delete qt_xdnd_target_data; + qt_xdnd_target_data = 0; + delete noDropCursor; + noDropCursor = 0; + delete copyCursor; + copyCursor = 0; + delete moveCursor; + moveCursor = 0; + delete linkCursor; + linkCursor = 0; + delete defaultPm; + defaultPm = 0; + delete desktop_proxy; + desktop_proxy = 0; +} + + +static TQWidget * tqfind_child( TQWidget * tlw, TQPoint & p ) +{ + TQWidget * w = tlw; + + p = w->mapFromGlobal( p ); + bool done = FALSE; + while ( !done ) { + done = TRUE; + if ( ((TQExtraWidget*)w)->extraData() && + ((TQExtraWidget*)w)->extraData()->xDndProxy != 0 ) + break; // stop searching for widgets under the mouse cursor if found widget is a proxy. + if ( !w->childrenListObject().isEmpty() ) { + TQObjectListIt it( w->childrenListObject() ); + it.toLast(); + TQObject * o; + while( (o=it.current()) ) { + --it; + if ( o->isWidgetType() && + ((TQWidget*)o)->isVisible() && + ((TQWidget*)o)->tqgeometry().contains( p ) && + !((TQWidget*)o)->isTopLevel()) { + w = (TQWidget *)o; + done = FALSE; + p = w->mapFromParent( p ); + break; + } + } + } + } + return w; +} + + +static bool checkEmbedded(TQWidget* w, const XEvent* xe) +{ + if (!w) + return FALSE; + + if (current_embedding_widget != 0 && current_embedding_widget != w) { + qt_xdnd_current_target = ((TQExtraWidget*)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; + } + + TQWExtra* extra = ((TQExtraWidget*)w)->extraData(); + if ( extra && extra->xDndProxy != 0 ) { + + if (current_embedding_widget != w) { + + last_enter_event.xany.window = extra->xDndProxy; + XSendEvent( TQPaintDevice::x11AppDisplay(), extra->xDndProxy, False, NoEventMask, + &last_enter_event ); + current_embedding_widget = w; + } + + ((XEvent*)xe)->xany.window = extra->xDndProxy; + XSendEvent( TQPaintDevice::x11AppDisplay(), extra->xDndProxy, False, NoEventMask, + (XEvent*)xe ); + qt_xdnd_current_widget = w; + return TRUE; + } + current_embedding_widget = 0; + return FALSE; +} + +void qt_handle_xdnd_enter( TQWidget *, const XEvent * xe, bool /*passive*/ ) +{ + //if ( !w->neveHadAChildWithDropEventsOn() ) + //return; // haven't been set up for dnd + + qt_motifdnd_active = FALSE; + + last_enter_event.xclient = xe->xclient; + + qt_xdnd_target_answerwas = FALSE; + + const long *l = xe->xclient.data.l; + int version = (int)(((unsigned long)(l[1])) >> 24); + + if ( version > qt_xdnd_version ) + return; + + qt_xdnd_dragsource_xid = l[0]; + + int j = 0; + if ( l[1] & 1 ) { + // get the types from XdndTypeList + Atom type = None; + int f; + unsigned long n, a; + Atom *data; + XGetWindowProperty( TQPaintDevice::x11AppDisplay(), qt_xdnd_dragsource_xid, + qt_xdnd_type_list, 0, + qt_xdnd_max_type, False, XA_ATOM, &type, &f,&n,&a,(uchar**)&data ); + for ( ; j<qt_xdnd_max_type && j < (int)n; j++ ) { + qt_xdnd_types[j] = data[j]; + } + if ( data ) + XFree( (uchar*)data ); + } else { + // get the types from the message + int i; + for( i=2; i < 5; i++ ) { + qt_xdnd_types[j++] = l[i]; + } + } + qt_xdnd_types[j] = 0; +} + + + +void qt_handle_xdnd_position( TQWidget *w, const XEvent * xe, bool passive ) +{ + const unsigned long *l = (const unsigned long *)xe->xclient.data.l; + + TQPoint p( (l[2] & 0xffff0000) >> 16, l[2] & 0x0000ffff ); + TQWidget * c = tqfind_child( w, p ); // changes p to to c-local coordinates + + if (!passive && checkEmbedded(c, xe)) + return; + + if ( !c || (!c->acceptDrops() && c->isDesktop()) ) { + return; + } + + if ( l[0] != qt_xdnd_dragsource_xid ) { + //qDebug( "xdnd drag position from unexpected source (%08lx not %08lx)", + // l[0], qt_xdnd_dragsource_xid ); + return; + } + + if (l[3] != 0) { + // timestamp from the source + SET_QT_X_USER_TIME(l[3]); + qt_xdnd_target_current_time = l[3]; + } + + XClientMessageEvent response; + response.type = ClientMessage; + response.window = qt_xdnd_dragsource_xid; + response.format = 32; + response.message_type = qt_xdnd_status; + response.data.l[0] = w->winId(); + 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->isTopLevel() ) { + p = c->mapToParent( p ); + c = c->parentWidget(); + } + + TQRect answerRect( c->mapToGlobal( p ), TQSize( 1,1 ) ); + + TQDragMoveEvent me( p ); + TQDropEvent::Action accepted_action = xdndaction_to_qtaction(l[4]); + me.setAction(accepted_action); + + if ( c != qt_xdnd_current_widget ) { + qt_xdnd_target_answerwas = FALSE; + if ( qt_xdnd_current_widget ) { + TQDragLeaveEvent e; + TQApplication::sendEvent( qt_xdnd_current_widget, &e ); + } + if ( c->acceptDrops() ) { + qt_xdnd_current_widget = c; + qt_xdnd_current_position = p; + + TQDragEnterEvent de( p ); + de.setAction(accepted_action); + TQApplication::sendEvent( c, &de ); + if ( de.isAccepted() ) { + me.accept( de.answerRect() ); + if ( !de.isActionAccepted() ) // only as a copy (move if we del) + accepted_action = TQDropEvent::Copy; + else + me.acceptAction(TRUE); + } else { + me.ignore( de.answerRect() ); + } + } + } else { + if ( qt_xdnd_target_answerwas ) { + me.accept(); + me.acceptAction(global_requested_action == global_accepted_action); + } + } + + if ( !c->acceptDrops() ) { + qt_xdnd_current_widget = 0; + answerRect = TQRect( p, TQSize( 1, 1 ) ); + } else if ( xdndaction_to_qtaction(l[4]) < TQDropEvent::Private ) { + qt_xdnd_current_widget = c; + qt_xdnd_current_position = p; + + TQApplication::sendEvent( c, &me ); + qt_xdnd_target_answerwas = me.isAccepted(); + if ( me.isAccepted() ) { + response.data.l[1] = 1; // yes + if ( !me.isActionAccepted() ) // only as a copy (move if we del) + accepted_action = TQDropEvent::Copy; + } else { + response.data.l[0] = 0; + } + answerRect = me.answerRect().intersect( c->rect() ); + } else { + response.data.l[0] = 0; + answerRect = TQRect( p, TQSize( 1, 1 ) ); + } + answerRect = TQRect( 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); + global_accepted_action = accepted_action; + } + + // reset + qt_xdnd_target_current_time = CurrentTime; + + TQWidget * source = TQWidget::tqfind( qt_xdnd_dragsource_xid ); + + if ( source && source->isDesktop() && !source->acceptDrops() ) + source = 0; + + if ( source ) + qt_handle_xdnd_status( source, (const XEvent *)&response, passive ); + else + XSendEvent( TQPaintDevice::x11AppDisplay(), qt_xdnd_dragsource_xid, False, + NoEventMask, (XEvent*)&response ); +} + + +void qt_handle_xdnd_status( TQWidget * w, const XEvent * xe, bool /*passive*/ ) +{ + const unsigned long *l = (const unsigned long *)xe->xclient.data.l; + // Messy: TQDragResponseEvent is just a call to TQDragManager function + global_accepted_action = xdndaction_to_qtaction(l[4]); + TQDragResponseEvent e( (int)(l[1] & 1) ); + TQApplication::sendEvent( w, &e ); + + if ( (int)(l[1] & 2) == 0 ) { + TQPoint p( (l[2] & 0xffff0000) >> 16, l[2] & 0x0000ffff ); + TQSize s( (l[3] & 0xffff0000) >> 16, l[3] & 0x0000ffff ); + qt_xdnd_source_sameanswer = TQRect( p, s ); + if ( qt_xdnd_source_sameanswer.isNull() ) { + // Application wants "coninutous" move events + } + } else { + qt_xdnd_source_sameanswer = TQRect(); + } +} + + +void qt_handle_xdnd_leave( TQWidget *w, const XEvent * xe, bool /*passive*/ ) +{ + //qDebug( "xdnd leave" ); + if ( !qt_xdnd_current_widget || + w->tqtopLevelWidget() != qt_xdnd_current_widget->tqtopLevelWidget() ) { + return; // sanity + } + + if (checkEmbedded(current_embedding_widget, xe)) { + current_embedding_widget = 0; + qt_xdnd_current_widget = 0; + return; + } + + const unsigned long *l = (const unsigned long *)xe->xclient.data.l; + + TQDragLeaveEvent e; + TQApplication::sendEvent( qt_xdnd_current_widget, &e ); + + if ( l[0] != qt_xdnd_dragsource_xid ) { + // This often happens - leave other-process window quickly + //qDebug( "xdnd drag leave from unexpected source (%08lx not %08lx", + //l[0], qt_xdnd_dragsource_xid ); + qt_xdnd_current_widget = 0; + return; + } + + qt_xdnd_dragsource_xid = 0; + qt_xdnd_types[0] = 0; + qt_xdnd_current_widget = 0; +} + + +void qt_xdnd_send_leave() +{ + if ( !qt_xdnd_current_target ) + return; + + XClientMessageEvent leave; + leave.type = ClientMessage; + leave.window = qt_xdnd_current_target; + leave.format = 32; + leave.message_type = qt_xdnd_leave; + 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 + + TQWidget * w = TQWidget::tqfind( qt_xdnd_current_proxy_target ); + + if ( w && w->isDesktop() && !w->acceptDrops() ) + w = 0; + + if ( w ) + qt_handle_xdnd_leave( w, (const XEvent *)&leave, FALSE ); + else + XSendEvent( TQPaintDevice::x11AppDisplay(), qt_xdnd_current_proxy_target, False, + NoEventMask, (XEvent*)&leave ); + qt_xdnd_current_target = 0; + qt_xdnd_current_proxy_target = 0; +} + + + +void qt_handle_xdnd_drop( TQWidget *, const XEvent * xe, bool passive ) +{ + if ( !qt_xdnd_current_widget ) { + qt_xdnd_dragsource_xid = 0; + return; // sanity + } + + if (!passive && checkEmbedded(qt_xdnd_current_widget, xe)){ + current_embedding_widget = 0; + qt_xdnd_dragsource_xid = 0; + qt_xdnd_current_widget = 0; + return; + } + const unsigned long *l = (const unsigned long *)xe->xclient.data.l; + + //qDebug( "xdnd drop" ); + + if ( l[0] != qt_xdnd_dragsource_xid ) { + //qDebug( "xdnd drop from unexpected source (%08lx not %08lx", + // l[0], qt_xdnd_dragsource_xid ); + return; + } + + if (l[2] != 0) { + // update the "user time" from the timestamp in the event. + SET_QT_X_USER_TIME(l[2]); + qt_xdnd_target_current_time = l[2]; + } + + if ( qt_xdnd_source_object ) + qt_xdnd_source_object->setTarget( qt_xdnd_current_widget ); + + if ( !passive ) { + TQDropEvent de( qt_xdnd_current_position ); + de.setAction( global_accepted_action ); + TQApplication::sendEvent( qt_xdnd_current_widget, &de ); + if ( !de.isAccepted() ) { + // Ignore a failed drag + global_accepted_action = TQDropEvent::Copy; + dndCancelled = TRUE; + } + XClientMessageEvent finished; + finished.type = ClientMessage; + finished.window = qt_xdnd_dragsource_xid; + finished.format = 32; + finished.message_type = qt_xdnd_finished; + finished.data.l[0] = qt_xdnd_current_widget?qt_xdnd_current_widget->tqtopLevelWidget()->winId():0; + finished.data.l[1] = 0; // flags + XSendEvent( TQPaintDevice::x11AppDisplay(), qt_xdnd_dragsource_xid, False, + NoEventMask, (XEvent*)&finished ); + } else { + TQDragLeaveEvent e; + TQApplication::sendEvent( qt_xdnd_current_widget, &e ); + } + qt_xdnd_dragsource_xid = 0; + qt_xdnd_current_widget = 0; + + // reset + qt_xdnd_target_current_time = CurrentTime; +} + + +void qt_handle_xdnd_finished( TQWidget *, const XEvent * xe, bool passive ) +{ + const unsigned long *l = (const unsigned long *)xe->xclient.data.l; + + if ( l[0] && (l[0] == qt_xdnd_current_target + || l[0] == qt_xdnd_current_proxy_target) ) { + // + if ( !passive ) + (void ) checkEmbedded( qt_xdnd_current_widget, xe); + current_embedding_widget = 0; + qt_xdnd_current_target = 0; + qt_xdnd_current_proxy_target = 0; + delete qt_xdnd_source_object; + qt_xdnd_source_object = 0; + } +} + + +void TQDragManager::timerEvent( TQTimerEvent* e ) +{ + if ( e->timerId() == heartbeat && qt_xdnd_source_sameanswer.isNull() ) + move( TQCursor::pos() ); +} + +bool TQDragManager::eventFilter( TQObject * o, TQEvent * e) +{ + if ( beingCancelled ) { + if ( e->type() == TQEvent::KeyRelease && + ((TQKeyEvent*)e)->key() == Key_Escape ) { + tqApp->removeEventFilter( this ); + object = 0; + dragSource = 0; + beingCancelled = FALSE; + tqApp->exit_loop(); + return TRUE; // block the key release + } + return FALSE; + } + + TQ_ASSERT( object != 0 ); + + if ( !o->isWidgetType() ) + return FALSE; + + if ( e->type() == TQEvent::MouseMove ) { + TQMouseEvent* me = (TQMouseEvent *)e; + updateMode(me->stateAfter()); + move( me->globalPos() ); + return TRUE; + } else if ( e->type() == TQEvent::MouseButtonRelease ) { + tqApp->removeEventFilter( this ); + if ( willDrop ) + drop(); + else + cancel(); + object = 0; + dragSource = 0; + beingCancelled = FALSE; + tqApp->exit_loop(); + return TRUE; + } else if ( e->type() == TQEvent::DragResponse ) { + if ( ((TQDragResponseEvent *)e)->dragAccepted() ) { + if ( !willDrop ) { + willDrop = TRUE; + } + } else { + if ( willDrop ) { + willDrop = FALSE; + } + } + updateCursor(); + return TRUE; + } + + if ( e->type() == TQEvent::KeyPress + || e->type() == TQEvent::KeyRelease ) + { + TQKeyEvent *ke = ((TQKeyEvent*)e); + if ( ke->key() == Key_Escape && e->type() == TQEvent::KeyPress ) { + cancel(); + tqApp->removeEventFilter( this ); + object = 0; + dragSource = 0; + beingCancelled = FALSE; + tqApp->exit_loop(); + } else { + updateMode(ke->stateAfter()); + qt_xdnd_source_sameanswer = TQRect(); // force move + move( TQCursor::pos() ); + } + return TRUE; // Eat all key events + } + + // ### We bind modality to widgets, so we have to do this + // ### "manually". + // DnD is modal - eat all other interactive events + switch ( e->type() ) { + case TQEvent::MouseButtonPress: + case TQEvent::MouseButtonRelease: + case TQEvent::MouseButtonDblClick: + case TQEvent::MouseMove: + case TQEvent::KeyPress: + case TQEvent::KeyRelease: + case TQEvent::Wheel: + case TQEvent::Accel: + case TQEvent::AccelAvailable: + case TQEvent::AccelOverride: + return TRUE; + default: + return FALSE; + } +} + + +static TQt::ButtonState oldstate; +void TQDragManager::updateMode( TQt::ButtonState newstate ) +{ + if ( newstate == oldstate ) + return; + const int both = ShiftButton|ControlButton; + if ( (newstate & both) == both ) { + global_requested_action = TQDropEvent::Link; + } else { + bool local = qt_xdnd_source_object != 0; + if ( drag_mode == TQDragObject::DragMove ) + global_requested_action = TQDropEvent::Move; + else if ( drag_mode == TQDragObject::DragCopy ) + global_requested_action = TQDropEvent::Copy; + else if ( drag_mode == TQDragObject::DragLink ) + global_requested_action = TQDropEvent::Link; + else { + if ( drag_mode == TQDragObject::DragDefault && local ) + global_requested_action = TQDropEvent::Move; + else + global_requested_action = TQDropEvent::Copy; + if ( newstate & ShiftButton ) + global_requested_action = TQDropEvent::Move; + else if ( newstate & ControlButton ) + global_requested_action = TQDropEvent::Copy; + } + } + oldstate = newstate; +} + + +void TQDragManager::createCursors() +{ + if ( !noDropCursor ) { + noDropCursor = new TQCursor( Qt::ForbiddenCursor ); + if ( !pm_cursor[0].isNull() ) + moveCursor = new TQCursor(pm_cursor[0], 0,0); + if ( !pm_cursor[1].isNull() ) + copyCursor = new TQCursor(pm_cursor[1], 0,0); + if ( !pm_cursor[2].isNull() ) + linkCursor = new TQCursor(pm_cursor[2], 0,0); + } +} + +void TQDragManager::updateCursor() +{ + TQCursor *c; + if ( willDrop ) { + if ( global_accepted_action == TQDropEvent::Copy ) { + if ( global_requested_action == TQDropEvent::Move ) + c = moveCursor; // (source can delete) + else + c = copyCursor; + } else if ( global_accepted_action == TQDropEvent::Link ) { + c = linkCursor; + } else { + c = moveCursor; + } + if ( qt_xdnd_deco ) { + qt_xdnd_deco->show(); + qt_xdnd_deco->raise(); + } + } else { + c = noDropCursor; + //if ( qt_xdnd_deco ) + // qt_xdnd_deco->hide(); + } +#ifndef TQT_NO_CURSOR + if ( c ) + tqApp->setOverrideCursor( *c, TRUE ); +#endif +} + + +void TQDragManager::cancel( bool deleteSource ) +{ + killTimer( heartbeat ); + heartbeat = -1; + if ( object ) { + beingCancelled = TRUE; + object = 0; + } + + if ( qt_xdnd_current_target ) { + qt_xdnd_send_leave(); + } + +#ifndef TQT_NO_CURSOR + if ( restoreCursor ) { + TQApplication::restoreOverrideCursor(); + restoreCursor = FALSE; + } +#endif + + if ( deleteSource ) + delete qt_xdnd_source_object; + qt_xdnd_source_object = 0; + delete qt_xdnd_deco; + qt_xdnd_deco = 0; + + dndCancelled = TRUE; +} + +static +Window tqfindRealWindow( const TQPoint & pos, Window w, int md ) +{ + if ( qt_xdnd_deco && w == qt_xdnd_deco->winId() ) + return 0; + + if ( md ) { + qt_ignore_badwindow(); + XWindowAttributes attr; + XGetWindowAttributes( TQPaintDevice::x11AppDisplay(), w, &attr ); + if (qt_badwindow()) + return 0; + + if ( attr.map_state == IsViewable + && TQRect(attr.x,attr.y,attr.width,attr.height) + .contains(pos) ) + { + { + Atom type = None; + int f; + unsigned long n, a; + unsigned char *data; + + XGetWindowProperty( TQPaintDevice::x11AppDisplay(), w, qt_xdnd_aware, 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( TQPaintDevice::x11AppDisplay(), w, &r, &p, &c, &nc ) ) { + r=0; + for (uint i=nc; !r && i--; ) { + r = tqfindRealWindow( pos-TQPoint(attr.x,attr.y), + c[i], md-1 ); + } + XFree(c); + if ( r ) + return r; + + // We didn't tqfind a client window! Just use the + // innermost window. + } + + // No tqchildren! + return w; + } + } + return 0; +} + +void TQDragManager::move( const TQPoint & globalPos ) +{ + if (!object) { + // perhaps the target crashed? + return; + } + + int screen = TQCursor::x11Screen(); + if ( ( qt_xdnd_current_screen == -1 && screen != TQPaintDevice::x11AppScreen() ) || + ( screen != qt_xdnd_current_screen ) ) { + // recreate the pixmap on the new screen... + delete qt_xdnd_deco; + qt_xdnd_deco = new TQShapedPixmapWidget( screen ); + if (!TQWidget::mouseGrabber()) { + updatePixmap(); + qt_xdnd_deco->grabMouse(); + } + } + updatePixmap(); + + if ( qt_xdnd_source_sameanswer.contains( globalPos ) && + qt_xdnd_source_sameanswer.isValid() ) { + return; + } + + qt_xdnd_current_screen = screen; + Window rootwin = TQPaintDevice::x11AppRootWindow( qt_xdnd_current_screen ); + Window target = 0; + int lx = 0, ly = 0; + if ( !XTranslateCoordinates( TQPaintDevice::x11AppDisplay(), rootwin, rootwin, + globalPos.x(), globalPos.y(), + &lx, &ly, &target) ) + // some wierd error... + return; + + if ( target == rootwin ) { + // Ok. + } else if ( target ) { + //me + Window src = rootwin; + while (target != 0) { + int lx2, ly2; + Window t; + // translate coordinates + if (!XTranslateCoordinates(TQPaintDevice::x11AppDisplay(), src, target, + lx, ly, &lx2, &ly2, &t)) { + target = 0; + break; + } + lx = lx2; + ly = ly2; + src = target; + + // check if it has XdndAware + Atom type = None; + int f; + unsigned long n, a; + unsigned char *data = 0; + XGetWindowProperty(TQPaintDevice::x11AppDisplay(), target, qt_xdnd_aware, 0, 0, False, + AnyPropertyType, &type, &f,&n,&a,&data); + if (data) + XFree(data); + if (type) + break; + + // tqfind child at the coordinates + if (!XTranslateCoordinates( TQPaintDevice::x11AppDisplay(), src, src, + lx, ly, &lx2, &ly2, &target)) { + target = 0; + break; + } + } + if ( qt_xdnd_deco && (!target || target == qt_xdnd_deco->winId()) ) { + target = tqfindRealWindow(globalPos,rootwin,6); + } + } + + TQWidget* w; + if ( target ) { + w = TQWidget::tqfind( (WId)target ); + if ( w && w->isDesktop() && !w->acceptDrops() ) + w = 0; + } else { + w = 0; + target = rootwin; + } + + WId proxy_target = target; + int target_version = 1; + + { + Atom type = None; + int r, f; + unsigned long n, a; + WId *proxy_id; + qt_ignore_badwindow(); + r = XGetWindowProperty( qt_xdisplay(), target, qt_xdnd_proxy, 0, + 1, False, XA_WINDOW, &type, &f,&n,&a,(uchar**)&proxy_id ); + if ( ( r != Success ) || qt_badwindow() ) { + proxy_target = target = 0; + } else if ( type == XA_WINDOW && proxy_id ) { + proxy_target = *proxy_id; + XFree(proxy_id); + proxy_id = 0; + r = XGetWindowProperty( qt_xdisplay(), proxy_target, qt_xdnd_proxy, 0, + 1, False, XA_WINDOW, &type, &f,&n,&a,(uchar**)&proxy_id ); + if ( ( r != Success ) || qt_badwindow() || !type || !proxy_id || *proxy_id != proxy_target ) { + // Bogus + proxy_target = 0; + target = 0; + } + if ( proxy_id ) + XFree(proxy_id); + } + if ( proxy_target ) { + int *tv; + qt_ignore_badwindow(); + r = XGetWindowProperty( qt_xdisplay(), proxy_target, qt_xdnd_aware, 0, + 1, False, AnyPropertyType, &type, &f,&n,&a,(uchar**)&tv ); + if ( r != Success ) { + target = 0; + } else { + target_version = TQMIN(qt_xdnd_version,tv ? *tv : 1); + if ( tv ) + XFree( tv ); + if (!(!qt_badwindow() && type)) + target = 0; + } + } + } + + if ( target != qt_xdnd_current_target ) { + if ( qt_xdnd_current_target ) + qt_xdnd_send_leave(); + + qt_xdnd_current_target = target; + qt_xdnd_current_proxy_target = proxy_target; + if ( target ) { + TQMemArray<Atom> type; + int flags = target_version << 24; + const char* fmt; + int nfmt=0; + for (nfmt=0; (fmt=object->format(nfmt)); nfmt++) { + type.resize(nfmt+1); + type[nfmt] = *qt_xdnd_str_to_atom( fmt ); + } + if ( nfmt >= 3 ) { + XChangeProperty( TQPaintDevice::x11AppDisplay(), + object->source()->winId(), qt_xdnd_type_list, + XA_ATOM, 32, PropModeReplace, + (unsigned char *)type.data(), + type.size() ); + flags |= 0x0001; + } + XClientMessageEvent enter; + enter.type = ClientMessage; + enter.window = target; + enter.format = 32; + enter.message_type = qt_xdnd_enter; + enter.data.l[0] = object->source()->winId(); + enter.data.l[1] = flags; + enter.data.l[2] = type.size()>0 ? type[0] : 0; + enter.data.l[3] = type.size()>1 ? type[1] : 0; + enter.data.l[4] = type.size()>2 ? type[2] : 0; + // provisionally set the rectangle to 5x5 pixels... + qt_xdnd_source_sameanswer = TQRect( globalPos.x() - 2, + globalPos.y() -2 , 5, 5 ); + + if ( w ) { + qt_handle_xdnd_enter( w, (const XEvent *)&enter, FALSE ); + } else if ( target ) { + XSendEvent( TQPaintDevice::x11AppDisplay(), proxy_target, False, NoEventMask, + (XEvent*)&enter ); + } + } + } + + if ( target ) { + XClientMessageEvent move; + move.type = ClientMessage; + move.window = target; + move.format = 32; + move.message_type = qt_xdnd_position; + move.window = target; + move.data.l[0] = object->source()->winId(); + move.data.l[1] = 0; // flags + move.data.l[2] = (globalPos.x() << 16) + globalPos.y(); + move.data.l[3] = GET_QT_X_TIME(); + move.data.l[4] = qtaction_to_xdndaction( global_requested_action ); + + if ( w ) + qt_handle_xdnd_position( w, (const XEvent *)&move, FALSE ); + else + XSendEvent( TQPaintDevice::x11AppDisplay(), proxy_target, False, NoEventMask, + (XEvent*)&move ); + } else { + if ( willDrop ) { + willDrop = FALSE; + updateCursor(); + } + } +} + + +void TQDragManager::drop() +{ + killTimer( heartbeat ); + heartbeat = -1; + if ( !qt_xdnd_current_target ) + return; + + delete qt_xdnd_deco; + qt_xdnd_deco = 0; + + XClientMessageEvent drop; + drop.type = ClientMessage; + drop.window = qt_xdnd_current_target; + drop.format = 32; + drop.message_type = qt_xdnd_drop; + drop.data.l[0] = object->source()->winId(); + drop.data.l[1] = 0; // flags + drop.data.l[2] = GET_QT_X_TIME(); + drop.data.l[3] = 0; + drop.data.l[4] = 0; + + TQWidget * w = TQWidget::tqfind( qt_xdnd_current_proxy_target ); + + if ( w && w->isDesktop() && !w->acceptDrops() ) + w = 0; + + if ( w ) + qt_handle_xdnd_drop( w, (const XEvent *)&drop, FALSE ); + else + XSendEvent( TQPaintDevice::x11AppDisplay(), qt_xdnd_current_proxy_target, False, + NoEventMask, (XEvent*)&drop ); + +#ifndef TQT_NO_CURSOR + if ( restoreCursor ) { + TQApplication::restoreOverrideCursor(); + restoreCursor = FALSE; + } +#endif +} + + + +bool qt_xdnd_handle_badwindow() +{ + if ( qt_xdnd_source_object && qt_xdnd_current_target ) { + qt_xdnd_current_target = 0; + qt_xdnd_current_proxy_target = 0; + delete qt_xdnd_source_object; + qt_xdnd_source_object = 0; + delete qt_xdnd_deco; + qt_xdnd_deco = 0; + return TRUE; + } + if ( qt_xdnd_dragsource_xid ) { + qt_xdnd_dragsource_xid = 0; + if ( qt_xdnd_current_widget ) { + TQDragLeaveEvent e; + TQApplication::sendEvent( qt_xdnd_current_widget, &e ); + qt_xdnd_current_widget = 0; + } + return TRUE; + } + return FALSE; +} + + +/*! + \class TQDragMoveEvent tqevent.h + \ingroup events + \ingroup draganddrop + \brief The TQDragMoveEvent class provides an event which is sent while a drag and drop is in progress. + + When a widget \link TQWidget::setAcceptDrops() accepts drop + events\endlink, it will receive this event repeatedly while the + drag is within the widget's boundaries. The widget should examine + the event to see what data it \link TQDragMoveEvent::provides() + provides\endlink, and accept() the drop if appropriate. + + Note that this class inherits most of its functionality from + TQDropEvent. +*/ + + +/*! + Returns TRUE if this event provides format \a mimeType; otherwise + returns FALSE. + + \sa data() +*/ + +bool TQDropEvent::provides( const char *mimeType ) const +{ + if ( qt_motifdnd_active && qstrnicmp( mimeType, "text/", 5 ) == 0 ) + return TRUE; + + int n=0; + const char* f; + do { + f = format( n ); + if ( !f ) + return FALSE; + n++; + } while( qstricmp( mimeType, f ) ); + return TRUE; +} + +void qt_xdnd_handle_selection_request( const XSelectionRequestEvent * req ) +{ + if ( !req ) + return; + XEvent evt; + evt.xselection.type = SelectionNotify; + evt.xselection.display = req->display; + evt.xselection.requestor = req->requestor; + evt.xselection.selection = req->selection; + evt.xselection.target = req->target; + evt.xselection.property = None; + evt.xselection.time = req->time; + const char* format = qt_xdnd_atom_to_str( req->target ); + if ( format && qt_xdnd_source_object && + qt_xdnd_source_object->provides( format ) ) { + TQByteArray a = qt_xdnd_source_object->tqencodedData(format); + XChangeProperty ( TQPaintDevice::x11AppDisplay(), req->requestor, req->property, + req->target, 8, PropModeReplace, + (unsigned char *)a.data(), a.size() ); + evt.xselection.property = req->property; + } + // ### this can die if req->requestor crashes at the wrong + // ### moment + XSendEvent( TQPaintDevice::x11AppDisplay(), req->requestor, False, 0, &evt ); +} + +/* + XChangeProperty ( TQPaintDevice::x11AppDisplay(), req->requestor, req->property, + XA_STRING, 8, + PropModeReplace, + (uchar *)d->text(), strlen(d->text()) ); + evt.xselection.property = req->property; +*/ + +static TQByteArray qt_xdnd_obtain_data( const char *format ) +{ + TQByteArray result; + + TQWidget* w; + if ( qt_xdnd_dragsource_xid && qt_xdnd_source_object && + (w=TQWidget::tqfind( qt_xdnd_dragsource_xid )) + && (!w->isDesktop() || w->acceptDrops()) ) + { + TQDragObject * o = qt_xdnd_source_object; + if ( o->provides( format ) ) + result = o->tqencodedData(format); + return result; + } + + Atom * a = qt_xdnd_str_to_atom( format ); + if ( !a || !*a ) + return result; + + if ( !qt_xdnd_target_data ) + qt_xdnd_target_data = new TQIntDict<TQByteArray>( 17 ); + + if ( qt_xdnd_target_data->tqfind( (int)*a ) ) { + result = *(qt_xdnd_target_data->tqfind( (int)*a )); + } else { + if ( XGetSelectionOwner( TQPaintDevice::x11AppDisplay(), + qt_xdnd_selection ) == None ) + return result; // should never happen? + + TQWidget* tw = qt_xdnd_current_widget; + if ( !qt_xdnd_current_widget || + qt_xdnd_current_widget->isDesktop() ) { + tw = new TQWidget; + } + XConvertSelection( TQPaintDevice::x11AppDisplay(), + qt_xdnd_selection, + *a, + qt_xdnd_selection, + tw->winId(), + qt_xdnd_target_current_time ); + XFlush( TQPaintDevice::x11AppDisplay() ); + + XEvent xevent; + bool got=qt_xclb_wait_for_event( TQPaintDevice::x11AppDisplay(), + tw->winId(), + SelectionNotify, &xevent, 5000); + if ( got ) { + Atom type; + + if ( qt_xclb_read_property( TQPaintDevice::x11AppDisplay(), + tw->winId(), + qt_xdnd_selection, TRUE, + &result, 0, &type, 0, FALSE ) ) { + if ( type == qt_incr_atom ) { + int nbytes = result.size() >= 4 ? *((int*)result.data()) : 0; + result = qt_xclb_read_incremental_property( TQPaintDevice::x11AppDisplay(), + tw->winId(), + qt_xdnd_selection, + nbytes, FALSE ); + } else if ( type != *a ) { + // (includes None) qDebug( "TQt clipboard: unknown atom %ld", type); + } +#if 0 + // this needs to be matched by a qt_xdnd_target_data->clear() + // when each drag is finished. for 2.0, we do the safe thing + // and disable the entire caching. + if ( type != None ) + qt_xdnd_target_data->insert( (int)((long)a), new TQByteArray(result) ); +#endif + } + } + if ( !qt_xdnd_current_widget || + qt_xdnd_current_widget->isDesktop() ) { + delete tw; + } + } + + return result; +} + + +/* + Enable drag and drop for widget w by installing the proper + properties on w's toplevel widget. +*/ +bool qt_dnd_enable( TQWidget* w, bool on ) +{ + w = w->tqtopLevelWidget(); + + if ( on ) { + if ( ( (TQExtraWidget*)w)->topData()->dnd ) + return TRUE; // been there, done that + ((TQExtraWidget*)w)->topData()->dnd = 1; + } + + qt_motifdnd_enable( w, on ); + return qt_xdnd_enable( w, on ); +} + + +/*! + \class TQDropEvent tqevent.h + \ingroup events + \ingroup draganddrop + + \brief The TQDropEvent class provides an event which is sent when a drag and drop is completed. + + When a widget \link TQWidget::setAcceptDrops() accepts drop + events\endlink, it will receive this event if it has accepted the + most recent TQDragEnterEvent or TQDragMoveEvent sent to it. + + The widget should use data() to extract the data in an appropriate + format. +*/ + + +/*! + \fn TQDropEvent::TQDropEvent (const TQPoint & pos, Type typ) + + Constructs a drop event that drops a drop of type \a typ on point + \a pos. +*/ // ### pos is in which coordinate system? + + +/*! + Returns a byte array containing the drag's data, in \a format. + + data() normally needs to get the data from the drag source, which + is potentially very slow, so it's advisable to call this function + only if you're sure that you will need the data in \a format. + + The resulting data will have a size of 0 if the format was not + available. + + \sa format() TQByteArray::size() +*/ + +TQByteArray TQDropEvent::tqencodedData( const char *format ) const +{ + if ( qt_motifdnd_active ) + return qt_motifdnd_obtain_data( format ); + return qt_xdnd_obtain_data( format ); +} + +/*! + Returns a string describing one of the available data types for + this drag. Common examples are "text/plain" and "image/gif". If \a + n is less than zero or greater than the number of available data + types, format() returns 0. + + This function is provided mainly for debugging. Most drop targets + will use provides(). + + \sa data() provides() +*/ + +const char* TQDropEvent::format( int n ) const +{ + if ( qt_motifdnd_active ) + return qt_motifdnd_format( n ); + + int i = 0; + while( i<n && qt_xdnd_types[i] ) + i++; + if ( i < n ) + return 0; + + const char* name = qt_xdnd_atom_to_str( qt_xdnd_types[i] ); + if ( !name ) + return 0; // should never happen + + return name; +} + +bool TQDragManager::drag( TQDragObject * o, TQDragObject::DragMode mode ) +{ + if ( object == o || !o || !o->tqparent() ) + return FALSE; + + if ( object ) { + cancel(); + tqApp->removeEventFilter( this ); + beingCancelled = FALSE; + } + + if ( qt_xdnd_source_object ) { + // the last drag and drop operation hasn't finished, so we are going to wait + // for one second to see if it does... if the finish message comes after this, + // then we could still have problems, but this is highly unlikely + TQApplication::flushX(); + + TQTime started = TQTime::currentTime(); + TQTime now = started; + do { + XEvent event; + if ( XCheckTypedEvent( TQPaintDevice::x11AppDisplay(), + ClientMessage, &event ) ) + tqApp->x11ProcessEvent( &event ); + + now = TQTime::currentTime(); + if ( started > now ) // crossed midnight + started = now; + + // sleep 50ms, so we don't use up CPU cycles all the time. + struct timeval usleep_tv; + usleep_tv.tv_sec = 0; + usleep_tv.tv_usec = 50000; + select(0, 0, 0, 0, &usleep_tv); + } while ( qt_xdnd_source_object && started.msecsTo(now) < 1000 ); + } + + qt_xdnd_source_object = o; + qt_xdnd_source_object->setTarget( 0 ); + qt_xdnd_deco = new TQShapedPixmapWidget(); + + willDrop = FALSE; + + object = o; + updatePixmap(); + + dragSource = (TQWidget *)(object->tqparent()); + + tqApp->installEventFilter( this ); + qt_xdnd_source_current_time = GET_QT_X_TIME(); + XSetSelectionOwner( TQPaintDevice::x11AppDisplay(), qt_xdnd_selection, + dragSource->tqtopLevelWidget()->winId(), + qt_xdnd_source_current_time ); + oldstate = TQt::ButtonState(-1); // #### Should use state that caused the drag + drag_mode = mode; + global_accepted_action = TQDropEvent::Copy; + updateMode(TQt::ButtonState(0)); + qt_xdnd_source_sameanswer = TQRect(); + move(TQCursor::pos()); + heartbeat = startTimer(200); + +#ifndef TQT_NO_CURSOR + tqApp->setOverrideCursor( Qt::ArrowCursor ); + restoreCursor = TRUE; + updateCursor(); +#endif + + dndCancelled = FALSE; + qt_xdnd_dragging = TRUE; + + if (!TQWidget::mouseGrabber()) + qt_xdnd_deco->grabMouse(); + + tqApp->enter_loop(); // Do the DND. + +#ifndef TQT_NO_CURSOR + tqApp->restoreOverrideCursor(); +#endif + + delete qt_xdnd_deco; + qt_xdnd_deco = 0; + killTimer( heartbeat ); + heartbeat = -1; + qt_xdnd_current_screen = -1; + qt_xdnd_dragging = FALSE; + + return ((! dndCancelled) && // source del? + (global_accepted_action == TQDropEvent::Copy && + global_requested_action == TQDropEvent::Move)); + + // qt_xdnd_source_object persists until we get an xdnd_finish message +} + +void TQDragManager::updatePixmap() +{ + if ( qt_xdnd_deco ) { + TQPixmap pm; + TQPoint pm_hot(default_pm_hotx,default_pm_hoty); + if ( object ) { + pm = object->pixmap(); + if ( !pm.isNull() ) + pm_hot = object->pixmapHotSpot(); + } + if ( pm.isNull() ) { + if ( !defaultPm ) + defaultPm = new TQPixmap(default_pm); + pm = *defaultPm; + } + qt_xdnd_deco->setPixmap(pm); + qt_xdnd_deco->move(TQCursor::pos()-pm_hot); + qt_xdnd_deco->tqrepaint(FALSE); + //if ( willDrop ) { + qt_xdnd_deco->show(); + //} else { + // qt_xdnd_deco->hide(); + //} + } +} + +#endif // TQT_NO_DRAGANDDROP |