mcs/class/Managed.Windows.Forms/System.Windows.Forms/X11Dnd.cs

   1 // Permission is hereby granted, free of charge, to any person obtaining
   2 // a copy of this software and associated documentation files (the
   3 // "Software"), to deal in the Software without restriction, including
   4 // without limitation the rights to use, copy, modify, merge, publish,
   5 // distribute, sublicense, and/or sell copies of the Software, and to
   6 // permit persons to whom the Software is furnished to do so, subject to
   7 // the following conditions:
   8 //
   9 // The above copyright notice and this permission notice shall be
  10 // included in all copies or substantial portions of the Software.
  11 //
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  18 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  19 //
  20 // Copyright (c) 2005 Novell, Inc.
  21 //
  22 // Authors:
  23 //      Jackson Harper (jackson@ximian.com)
  24 //
  25 //
  26
  27
  28 using System;
  29 using System.IO;
  30 using System.Text;
  31 using System.Drawing;
  32 using System.Collections;
  33 using System.Runtime.Serialization;
  34 using System.Runtime.InteropServices;
  35 using System.Runtime.Serialization.Formatters.Binary;
  36
  37 namespace System.Windows.Forms {
  38
  39         internal class X11Dnd {
  40
  41                 private enum State {
  42                         Accepting,
  43                         Dragging
  44                 }
  45
  46                 private enum DragState {
  47                         None,
  48                         Beginning,
  49                         Dragging,
  50                         Entered
  51                 }
  52
  53                 private interface IDataConverter {
  54                         void GetData (X11Dnd dnd, DataObject data, ref XEvent xevent);
  55                         void SetData (X11Dnd dnd, object data, ref XEvent xevent);
  56                 }
  57
  58                 private delegate void MimeConverter (IntPtr dsp,
  59                                 DataObject data, ref XEvent xevent);
  60
  61                 private class MimeHandler {
  62                         public string Name;
  63                         public IntPtr Type;
  64                         public IntPtr NonProtocol;
  65                         public IDataConverter Converter;
  66
  67                         public MimeHandler (string name, IDataConverter converter)
  68                         {
  69                                 Name = name;
  70                                 Converter = converter;
  71                         }
  72
  73                         public override string ToString ()
  74                         {
  75                                 return "MimeHandler {" + Name + "}";
  76                         }
  77                 }
  78
  79                 private MimeHandler [] MimeHandlers = {
  80 //                        new MimeHandler ("WCF_DIB"),
  81 //                        new MimeHandler ("image/gif", new MimeConverter (ImageConverter)),
  82 //                      new MimeHandler ("text/rtf", new MimeConverter (RtfConverter)),
  83 //                      new MimeHandler ("text/richtext", new MimeConverter (RtfConverter)),
  84
  85                         new MimeHandler ("text/plain", new TextConverter ()),
  86                         new MimeHandler ("text/html", new HtmlConverter ()),
  87                         new MimeHandler ("text/uri-list", new UriListConverter ()),
  88                         new MimeHandler ("application/x-mono-serialized-object",
  89                                         new SerializedObjectConverter ())
  90                 };
  91
  92                 private class SerializedObjectConverter : IDataConverter {
  93
  94                         public void GetData (X11Dnd dnd, DataObject data, ref XEvent xevent)
  95                         {
  96                                 MemoryStream stream = dnd.GetData (ref xevent);
  97                                 BinaryFormatter bf = new BinaryFormatter ();
  98
  99                                 if (stream.Length == 0)
 100                                         return;
 101
 102                                 stream.Seek (0, 0);
 103                                 object obj = bf.Deserialize (stream);
 104                                 data.SetData (obj);
 105                         }
 106
 107                         public void SetData (X11Dnd dnd, object data, ref XEvent xevent)
 108                         {
 109                                 if (data == null)
 110                                         return;
 111
 112                                 MemoryStream stream = new MemoryStream ();
 113                                 BinaryFormatter bf = new BinaryFormatter ();
 114
 115                                 bf.Serialize (stream, data);
 116
 117                                 IntPtr buffer = Marshal.AllocHGlobal ((int) stream.Length);
 118                                 stream.Seek (0, 0);
 119
 120                                 for (int i = 0; i < stream.Length; i++) {
 121                                         Marshal.WriteByte (buffer, i, (byte) stream.ReadByte ());
 122                                 }
 123
 124                                 dnd.SetProperty (ref xevent, buffer, (int) stream.Length);
 125                         }
 126                 }
 127
 128                 private class HtmlConverter : IDataConverter {
 129
 130                         public void GetData (X11Dnd dnd, DataObject data, ref XEvent xevent)
 131                         {
 132                                 string text = dnd.GetText (ref xevent, false);
 133                                 if (text == null)
 134                                         return;
 135                                 data.SetData (DataFormats.Text, text);
 136                                 data.SetData (DataFormats.UnicodeText, text);
 137                         }
 138
 139                         public void SetData (X11Dnd dnd, object data, ref XEvent xevent)
 140                         {
 141                                 IntPtr buffer;
 142                                 int len;
 143                                 string str = data as string;
 144
 145                                 if (str == null)
 146                                         return;
 147
 148                                 if (xevent.SelectionRequestEvent.target == (IntPtr)Atom.XA_STRING) {
 149                                         byte [] bytes = Encoding.ASCII.GetBytes (str);
 150                                         buffer = Marshal.AllocHGlobal (bytes.Length);
 151                                         len = bytes.Length;
 152                                         for (int i = 0; i < len; i++)
 153                                                 Marshal.WriteByte (buffer, i, bytes [i]);
 154                                 } else {
 155                                         buffer = Marshal.StringToHGlobalAnsi (str);
 156                                         len = 0;
 157                                         while (Marshal.ReadByte (buffer, len) != 0)
 158                                                 len++;
 159                                 }
 160
 161                                 dnd.SetProperty (ref xevent, buffer, len);
 162
 163                                 Marshal.FreeHGlobal (buffer);
 164                         }
 165                 }
 166
 167                 private class TextConverter : IDataConverter {
 168
 169                         public void GetData (X11Dnd dnd, DataObject data, ref XEvent xevent)
 170                         {
 171                                 string text = dnd.GetText (ref xevent, true);
 172                                 if (text == null)
 173                                         return;
 174                                 data.SetData (DataFormats.Text, text);
 175                                 data.SetData (DataFormats.UnicodeText, text);
 176                         }
 177
 178                         public void SetData (X11Dnd dnd, object data, ref XEvent xevent)
 179                         {
 180                                 IntPtr buffer;
 181                                 int len;
 182                                 string str = data as string;
 183
 184                                 if (data == null)
 185                                         return;
 186
 187                                 if (xevent.SelectionRequestEvent.target == (IntPtr)Atom.XA_STRING) {
 188                                         byte [] bytes = Encoding.ASCII.GetBytes (str);
 189                                         buffer = Marshal.AllocHGlobal (bytes.Length);
 190                                         len = bytes.Length;
 191                                         for (int i = 0; i < len; i++)
 192                                                 Marshal.WriteByte (buffer, i, bytes [i]);
 193                                 } else {
 194                                         buffer = Marshal.StringToHGlobalAnsi (str);
 195                                         len = 0;
 196                                         while (Marshal.ReadByte (buffer, len) != 0)
 197                                                 len++;
 198                                 }
 199
 200                                 dnd.SetProperty (ref xevent, buffer, len);
 201
 202                                 Marshal.FreeHGlobal (buffer);
 203                         }
 204                 }
 205
 206                 private class UriListConverter : IDataConverter {
 207
 208                         public void GetData (X11Dnd dnd, DataObject data, ref XEvent xevent)
 209                         {
 210                                 string text = dnd.GetText (ref xevent, false);
 211                                 if (text == null)
 212                                         return;
 213
 214                                 // TODO: Do this in a loop instead of just splitting
 215                                 ArrayList uri_list = new ArrayList ();
 216                                 string [] lines = text.Split (new char [] { '\r', '\n' });
 217                                 foreach (string line in lines) {
 218                                         // # is a comment line (see RFC 2483)
 219                                         if (line.StartsWith ("#"))
 220                                                 continue;
 221                                         try {
 222                                                 Uri uri = new Uri (line);
 223                                                 uri_list.Add (uri.LocalPath);
 224                                         } catch { }
 225                                 }
 226
 227                                 string [] l = (string []) uri_list.ToArray (typeof (string));
 228                                 if (l.Length < 1)
 229                                         return;
 230                                 data.SetData (DataFormats.FileDrop, l);
 231                                 data.SetData ("FileName", l [0]);
 232                                 data.SetData ("FileNameW", l [0]);
 233                         }
 234
 235                         public void SetData (X11Dnd dnd, object data, ref XEvent xevent)
 236                         {
 237                                 string [] uri_list = data as string [];
 238
 239                                 if (uri_list == null)
 240                                         return;
 241
 242                                 StringBuilder res = new StringBuilder ();
 243                                 foreach (string uri_str in uri_list) {
 244                                         Uri uri = new Uri (uri_str);
 245                                         res.Append (uri.ToString ());
 246                                         res.Append ("\r\n");
 247                                 }
 248
 249                                 IntPtr buffer = Marshal.StringToHGlobalAnsi ((string) data);
 250                                 int len = 0;
 251                                 while (Marshal.ReadByte (buffer, len) != 0)
 252                                         len++;
 253
 254                                 dnd.SetProperty (ref xevent, buffer, len);
 255                         }
 256                 }
 257
 258                 private class DragData {
 259                         public IntPtr Window;
 260                         public DragState State;
 261                         public object Data;
 262                         public IntPtr Action;
 263                         public IntPtr [] SupportedTypes;
 264                         public MouseButtons MouseState;
 265
 266                         public IntPtr LastWindow;
 267                         public IntPtr LastTopLevel;
 268
 269                         public bool WillAccept;
 270
 271                         public void Reset ()
 272                         {
 273                                 State = DragState.None;
 274                                 Data = null;
 275                                 SupportedTypes = null;
 276                                 WillAccept = false;
 277                         }
 278                 }
 279
 280                 private class DropData {
 281
 282                 }
 283
 284                 // This version seems to be the most common
 285                 private static readonly IntPtr [] XdndVersion = new IntPtr [] { new IntPtr (4) };
 286
 287                 private IntPtr display;
 288                 private DragData drag_data;
 289
 290                 private IntPtr XdndAware;
 291                 private IntPtr XdndSelection;
 292                 private IntPtr XdndEnter;
 293                 private IntPtr XdndLeave;
 294                 private IntPtr XdndPosition;
 295                 private IntPtr XdndDrop;
 296                 private IntPtr XdndFinished;
 297                 private IntPtr XdndStatus;
 298                 private IntPtr XdndTypeList;
 299                 private IntPtr XdndActionCopy;
 300                 private IntPtr XdndActionMove;
 301                 private IntPtr XdndActionLink;
 302                 private IntPtr XdndActionPrivate;
 303                 private IntPtr XdndActionList;
 304                 private IntPtr XdndActionDescription;
 305                 private IntPtr XdndActionAsk;
 306
 307                 private State state;
 308
 309                 private int converts_pending;
 310                 private bool position_recieved;
 311                 private bool status_sent;
 312                 private IntPtr target;
 313                 private IntPtr source;
 314                 private IntPtr toplevel;
 315                 private DataObject data;
 316
 317                 private IntPtr drag_action;
 318                 private Control control;
 319                 private int pos_x, pos_y;
 320                 private DragDropEffects allowed;
 321                 private DragEventArgs drag_event;
 322
 323                 private Cursor CursorNo;
 324                 private Cursor CursorCopy;
 325                 private Cursor CursorMove;
 326                 private Cursor CursorLink;
 327                 private IntPtr CurrentCursorHandle;
 328
 329                 public X11Dnd (IntPtr display)
 330                 {
 331                         this.display = display;
 332                         Init ();
 333                 }
 334
 335                 public bool InDrag()
 336                 {
 337                         if (drag_data == null)
 338                                 return false;
 339                         return drag_data.State != DragState.None;
 340                 }
 341
 342                 public void SetAllowDrop (Hwnd hwnd, bool allow)
 343                 {
 344                         int[] atoms;
 345
 346                         if (hwnd.allow_drop == allow)
 347                                 return;
 348
 349                         atoms = new int[XdndVersion.Length];
 350                         for (int i = 0; i < XdndVersion.Length; i++) {
 351                                 atoms[i] = XdndVersion[i].ToInt32();
 352                         }
 353
 354                         XplatUIX11.XChangeProperty (display, hwnd.whole_window, XdndAware,
 355                                         (IntPtr) Atom.XA_ATOM, 32,
 356                                         PropertyMode.Replace, atoms, allow ? 1 : 0);
 357                         hwnd.allow_drop = allow;
 358                 }
 359
 360                 public DragDropEffects StartDrag (IntPtr handle, object data,
 361                                 DragDropEffects allowed_effects)
 362                 {
 363                         drag_data = new DragData ();
 364                         drag_data.Window = handle;
 365                         drag_data.State = DragState.Beginning;
 366                         drag_data.MouseState = XplatUIX11.MouseState;
 367                         drag_data.Data = data;
 368                         drag_data.SupportedTypes = DetermineSupportedTypes (data);
 369
 370                         drag_data.Action = ActionFromEffect (allowed_effects);
 371
 372                         if (CursorNo == null) {
 373                                 // Make sure the cursors are created
 374                                 CursorNo = new Cursor (typeof (X11Dnd), "DnDNo.cur");
 375                                 CursorCopy = new Cursor (typeof (X11Dnd), "DnDCopy.cur");
 376                                 CursorMove = new Cursor (typeof (X11Dnd), "DnDMove.cur");
 377                                 CursorLink = new Cursor (typeof (X11Dnd), "DnDLink.cur");
 378                         }
 379
 380                         drag_data.LastTopLevel = IntPtr.Zero;
 381                         return DragDropEffects.Copy;
 382                 }
 383
 384                 public void HandleButtonRelease (ref XEvent xevent)
 385                 {
 386                         if (drag_data == null)
 387                                 return;
 388
 389                         if (!((drag_data.MouseState == MouseButtons.Left &&
 390                                               xevent.ButtonEvent.button == 1) ||
 391                                             (drag_data.MouseState == MouseButtons.Right &&
 392                                                             xevent.ButtonEvent.button == 3)))
 393                                 return;
 394
 395                         if (drag_data.State == DragState.Beginning) {
 396                                 state = State.Accepting;
 397                         } else if (drag_data.State != DragState.None) {
 398
 399                                 if (drag_data.WillAccept) {
 400                                         SendDrop (drag_data.LastTopLevel, xevent.AnyEvent.window,
 401                                                         xevent.ButtonEvent.time);
 402                                 }
 403
 404                                 XplatUIX11.XUngrabPointer (display, IntPtr.Zero);
 405                                 drag_data.State = DragState.None;
 406                                 // WE can't reset the drag data yet as it is still
 407                                 // most likely going to be used by the SelectionRequest
 408                                 // handlers
 409                         }
 410                 }
 411
 412                 public bool HandleMotionNotify (ref XEvent xevent)
 413                 {
 414                         if (drag_data == null)
 415                                 return false;
 416
 417                         if (drag_data.State == DragState.Beginning) {
 418                                 int suc;
 419
 420                                 drag_data.State = DragState.Dragging;
 421
 422                                 suc = XplatUIX11.XSetSelectionOwner (display, XdndSelection,
 423                                                 drag_data.Window,
 424                                                 xevent.ButtonEvent.time);
 425
 426                                 if (suc == 0) {
 427                                         Console.Error.WriteLine ("Could not take ownership of XdndSelection aborting drag.");
 428                                         drag_data.Reset ();
 429                                         return false;
 430                                 }
 431
 432                                 suc = XplatUIX11.XGrabPointer (display, xevent.AnyEvent.window,
 433                                                 false,
 434                                                 EventMask.ButtonMotionMask |
 435                                                 EventMask.PointerMotionMask |
 436                                                 EventMask.ButtonPressMask |
 437                                                 EventMask.ButtonReleaseMask,
 438                                                 GrabMode.GrabModeAsync,
 439                                                 GrabMode.GrabModeAsync,
 440                                                 IntPtr.Zero, IntPtr.Zero/*CursorCopy.Handle*/, IntPtr.Zero);
 441
 442                                 if (suc != 0) {
 443                                         Console.Error.WriteLine ("Could not grab pointer aborting drag.");
 444                                         drag_data.Reset ();
 445                                         return false;
 446                                 }
 447
 448                                 drag_data.State = DragState.Dragging;
 449                         } else if (drag_data.State != DragState.None) {
 450                                 bool dnd_aware = false;
 451                                 IntPtr toplevel = IntPtr.Zero;
 452                                 IntPtr window = XplatUIX11.RootWindowHandle;
 453
 454                                 IntPtr root, child;
 455                                 int x_temp, y_temp;
 456                                 int mask_return;
 457
 458                                 while (XplatUIX11.XQueryPointer (display,
 459                                                        window,
 460                                                        out root, out child,
 461                                                        out x_temp, out y_temp,
 462                                                        out xevent.MotionEvent.x,
 463                                                        out xevent.MotionEvent.y,
 464                                                        out mask_return)) {
 465
 466                                         if (!dnd_aware) {
 467                                                 dnd_aware = IsWindowDndAware (window);
 468                                                 if (dnd_aware) {
 469                                                         toplevel = window;
 470                                                         xevent.MotionEvent.x_root = x_temp;
 471                                                         xevent.MotionEvent.y_root = y_temp;
 472                                                 }
 473                                         }
 474
 475                                         if (child == IntPtr.Zero)
 476                                                 break;
 477
 478                                         window = child;
 479                                 }
 480
 481                                 if (window != drag_data.LastWindow && drag_data.State == DragState.Entered) {
 482                                         drag_data.State = DragState.Dragging;
 483
 484                                         // TODO: Send a Leave if this is an MWF window
 485
 486                                         if (toplevel != drag_data.LastTopLevel)
 487                                                 SendLeave (drag_data.LastTopLevel, xevent.MotionEvent.window);
 488                                 }
 489
 490                                 drag_data.State = DragState.Entered;
 491                                 if (toplevel != drag_data.LastTopLevel) {
 492                                         // Entering a new toplevel window
 493                                         SendEnter (toplevel, drag_data.Window, drag_data.SupportedTypes);
 494                                 } else {
 495                                         // Already in a toplevel window, so send a position
 496                                         SendPosition (toplevel, drag_data.Window,
 497                                                         drag_data.Action,
 498                                                         xevent.MotionEvent.x_root,
 499                                                         xevent.MotionEvent.y_root,
 500                                                         xevent.MotionEvent.time);
 501                                 }
 502
 503                                 drag_data.LastTopLevel = toplevel;
 504                                 drag_data.LastWindow = window;
 505                                 return true;
 506                         }
 507                         return false;
 508                 }
 509
 510                 // DEBUG CODE REMOVE
 511                 private string GetText (IntPtr handle) {
 512                         string text = String.Empty;
 513                         IntPtr  textptr;
 514
 515                         textptr = IntPtr.Zero;
 516
 517                         XplatUIX11.XFetchName (display, handle, ref textptr);
 518                         if (textptr != IntPtr.Zero) {
 519                                 text = Marshal.PtrToStringAnsi(textptr);
 520                                 XplatUIX11.XFree (textptr);
 521                         }
 522
 523                         return text;
 524                 }
 525
 526
 527                 // return true if the event is handled here
 528                 public bool HandleClientMessage (ref XEvent xevent)
 529                 {
 530                         // most common so we check it first
 531                         if (xevent.ClientMessageEvent.message_type == XdndPosition)
 532                                 return Accepting_HandlePositionEvent (ref xevent);
 533                         if (xevent.ClientMessageEvent.message_type == XdndEnter)
 534                                 return Accepting_HandleEnterEvent (ref xevent);
 535                         if (xevent.ClientMessageEvent.message_type == XdndDrop)
 536                                 return Accepting_HandleDropEvent (ref xevent);
 537                         if (xevent.ClientMessageEvent.message_type == XdndLeave)
 538                                 return Accepting_HandleLeaveEvent (ref xevent);
 539                         if (xevent.ClientMessageEvent.message_type == XdndStatus)
 540                                 return HandleStatusEvent (ref xevent);
 541
 542                         return false;
 543                 }
 544
 545                 public bool HandleSelectionNotifyEvent (ref XEvent xevent)
 546                 {
 547                         if (source != XplatUIX11.XGetSelectionOwner (display, XdndSelection))
 548                                 return false;
 549
 550                         MimeHandler handler = FindHandler ((IntPtr) xevent.SelectionEvent.target);
 551                         if (handler == null)
 552                                 return false;
 553                         if (data == null)
 554                                 data = new DataObject ();
 555
 556                         handler.Converter.GetData (this, data, ref xevent);
 557
 558                         converts_pending--;
 559                         if (converts_pending <= 0 && position_recieved) {
 560                                 drag_event = new DragEventArgs (data, 0, pos_x, pos_y,
 561                                         allowed, DragDropEffects.None);
 562                                 control.DndEnter (drag_event);
 563                                 SendStatus (source, drag_event.Effect);
 564                                 status_sent = true;
 565                         }
 566                         return true;
 567                 }
 568
 569                 public bool HandleSelectionRequestEvent (ref XEvent xevent)
 570                 {
 571                         if (xevent.SelectionRequestEvent.selection != XdndSelection)
 572                                 return false;
 573
 574                         MimeHandler handler = FindHandler (xevent.SelectionRequestEvent.target);
 575                         if (handler == null)
 576                                 return false;
 577
 578                         handler.Converter.SetData (this, drag_data.Data, ref xevent);
 579
 580                         return true;
 581                 }
 582
 583                 private void SetProperty (ref XEvent xevent, IntPtr data, int length)
 584                 {
 585                         XEvent sel = new XEvent();
 586                         sel.SelectionEvent.type = XEventName.SelectionNotify;
 587                         sel.SelectionEvent.send_event = true;
 588                         sel.SelectionEvent.display = display;
 589                         sel.SelectionEvent.selection = xevent.SelectionRequestEvent.selection;
 590                         sel.SelectionEvent.target = xevent.SelectionRequestEvent.target;
 591                         sel.SelectionEvent.requestor = xevent.SelectionRequestEvent.requestor;
 592                         sel.SelectionEvent.time = xevent.SelectionRequestEvent.time;
 593                         sel.SelectionEvent.property = IntPtr.Zero;
 594
 595                         XplatUIX11.XChangeProperty (display, xevent.SelectionRequestEvent.requestor,
 596                                         xevent.SelectionRequestEvent.property,
 597                                         xevent.SelectionRequestEvent.target,
 598                                         8, PropertyMode.Replace, data, length);
 599                         sel.SelectionEvent.property = xevent.SelectionRequestEvent.property;
 600
 601                         XplatUIX11.XSendEvent (display, xevent.SelectionRequestEvent.requestor, false,
 602                                         (IntPtr)EventMask.NoEventMask, ref sel);
 603                         return;
 604                 }
 605
 606                 private void Reset ()
 607                 {
 608                         ResetSourceData ();
 609                         ResetTargetData ();
 610                 }
 611
 612                 private void ResetSourceData ()
 613                 {
 614                         converts_pending = 0;
 615                         data = null;
 616                 }
 617
 618                 private void ResetTargetData ()
 619                 {
 620                         position_recieved = false;
 621                         status_sent = false;
 622                 }
 623
 624                 private bool Accepting_HandleEnterEvent (ref XEvent xevent)
 625                 {
 626                         Reset ();
 627
 628                         source = xevent.ClientMessageEvent.ptr1;
 629                         toplevel = xevent.AnyEvent.window;
 630                         target = IntPtr.Zero;
 631
 632                         ConvertData (ref xevent);
 633
 634                         return true;
 635                 }
 636
 637                 private bool Accepting_HandlePositionEvent (ref XEvent xevent)
 638                 {
 639                         pos_x = (int) xevent.ClientMessageEvent.ptr3 >> 16;
 640                         pos_y = (int) xevent.ClientMessageEvent.ptr3 & 0xFFFF;
 641
 642                         // Copy is implicitly allowed
 643                         allowed = EffectFromAction (xevent.ClientMessageEvent.ptr5) | DragDropEffects.Copy;
 644
 645                         IntPtr parent, child, new_child, last_drop_child;
 646                         parent = XplatUIX11.XRootWindow (display, 0);
 647                         child = toplevel;
 648                         last_drop_child = IntPtr.Zero;
 649                         while (true) {
 650                                 int xd, yd;
 651                                 new_child = IntPtr.Zero;
 652
 653                                 if (!XplatUIX11.XTranslateCoordinates (display,
 654                                                     parent, child, pos_x, pos_y,
 655                                                     out xd, out yd, out new_child))
 656                                         break;
 657                                 if (new_child == IntPtr.Zero)
 658                                         break;
 659                                 child = new_child;
 660
 661                                 Hwnd h = Hwnd.ObjectFromHandle (child);
 662                                 Control d = Control.FromHandle (h.client_window);
 663                                 if (d != null && d.allow_drop)
 664                                         last_drop_child = child;
 665                         }
 666
 667                         if (last_drop_child != IntPtr.Zero)
 668                                 child = last_drop_child;
 669
 670                         if (target != child) {
 671                                 // We have moved into a new control
 672                                 // or into a control for the first time
 673                                 Finish ();
 674                         }
 675                         target = child;
 676                         Hwnd hwnd = Hwnd.ObjectFromHandle (target);
 677                         Control c = Control.FromHandle (hwnd.client_window);
 678
 679                         if (c == null)
 680                                 return true;
 681                         if (!c.allow_drop) {
 682                                 SendStatus (source, DragDropEffects.None);
 683                                 Finish ();
 684                                 return true;
 685                         }
 686
 687                         control = c;
 688                         position_recieved = true;
 689
 690                         if (converts_pending > 0)
 691                                 return true;
 692                         if (!status_sent) {
 693                                 drag_event = new DragEventArgs (data, 0, pos_x, pos_y,
 694                                         allowed, DragDropEffects.None);
 695                                 control.DndEnter (drag_event);
 696                                 SendStatus (source, drag_event.Effect);
 697                                 status_sent = true;
 698                         } else {
 699                                 drag_event.x = pos_x;
 700                                 drag_event.y = pos_y;
 701                                 control.DndOver (drag_event);
 702                                 SendStatus (source, drag_event.Effect);
 703                         }
 704
 705                         return true;
 706                 }
 707
 708                 private void Finish ()
 709                 {
 710                         if (control != null) {
 711                                 if (drag_event == null) {
 712                                         if (data == null)
 713                                                 data = new DataObject ();
 714                                         drag_event = new DragEventArgs (data,
 715                                                         0, pos_x, pos_y,
 716                                         allowed, DragDropEffects.None);
 717                                 }
 718                                 control.DndLeave (drag_event);
 719                         }
 720                         ResetTargetData ();
 721                 }
 722
 723                 private bool Accepting_HandleDropEvent (ref XEvent xevent)
 724                 {
 725                         if (control != null && drag_event != null) {
 726                                 drag_event = new DragEventArgs (data,
 727                                                 0, pos_x, pos_y,
 728                                         allowed, DragDropEffects.None);
 729                                 control.DndDrop (drag_event);
 730                         }
 731                         SendFinished ();
 732                         return true;
 733                 }
 734
 735                 private bool Accepting_HandleLeaveEvent (ref XEvent xevent)
 736                 {
 737                         if (control != null && drag_event != null)
 738                                 control.DndLeave (drag_event);
 739                         // Reset ();
 740                         return true;
 741                 }
 742
 743                 private bool HandleStatusEvent (ref XEvent xevent)
 744                 {
 745                         if (drag_data != null && drag_data.State == DragState.Entered) {
 746                                 drag_data.WillAccept = ((int) xevent.ClientMessageEvent.ptr2 & 0x1) != 0;
 747                                 Cursor cursor = CursorNo;
 748                                 if (drag_data.WillAccept) {
 749                                         // Same order as on MS
 750                                         IntPtr action = xevent.ClientMessageEvent.ptr5;
 751                                         if (action == XdndActionCopy)
 752                                                 cursor = CursorCopy;
 753                                         else if (action == XdndActionLink)
 754                                                 cursor = CursorLink;
 755                                         else if (action == XdndActionMove)
 756                                                 cursor = CursorMove;
 757
 758                                 }
 759
 760                                         // TODO: Try not to set the cursor so much
 761                                 //if (cursor.Handle != CurrentCursorHandle) {
 762                                         XplatUIX11.XChangeActivePointerGrab (display,
 763                                                         EventMask.ButtonMotionMask |
 764                                                         EventMask.PointerMotionMask |
 765                                                         EventMask.ButtonPressMask |
 766                                                         EventMask.ButtonReleaseMask,
 767                                                         cursor.Handle, IntPtr.Zero);
 768                                         CurrentCursorHandle = cursor.Handle;
 769                                         //}
 770                         }
 771                         return true;
 772                 }
 773
 774                 private DragDropEffects EffectFromAction (IntPtr action)
 775                 {
 776                         DragDropEffects allowed = DragDropEffects.None;
 777
 778                         if (action == XdndActionCopy)
 779                                 allowed = DragDropEffects.Copy;
 780                         else if (action == XdndActionMove)
 781                                 allowed |= DragDropEffects.Move;
 782                         if (action == XdndActionLink)
 783                                 allowed |= DragDropEffects.Link;
 784                         return allowed;
 785                 }
 786
 787                 private IntPtr ActionFromEffect (DragDropEffects effect)
 788                 {
 789                         IntPtr action = IntPtr.Zero;
 790
 791                         // We can't OR together actions on XDND so sadly the primary
 792                         // is the only one shown here
 793                         if ((effect & DragDropEffects.Copy) != 0)
 794                                 action = XdndActionCopy;
 795                         else if ((effect & DragDropEffects.Move) != 0)
 796                                 action = XdndActionMove;
 797                         else if ((effect & DragDropEffects.Link) != 0)
 798                                 action = XdndActionLink;
 799                         return action;
 800                 }
 801
 802                 private bool ConvertData (ref XEvent xevent)
 803                 {
 804                         bool match = false;
 805
 806                         if (source != XplatUIX11.XGetSelectionOwner (display, XdndSelection)) {
 807                                 return false;
 808                         }
 809
 810                         Control mwfcontrol = MwfWindow (source);
 811
 812                         if (mwfcontrol != null && drag_data != null) {
 813                                 DataObject dragged = drag_data.Data as DataObject;
 814                                 if (dragged != null) {
 815                                         data = dragged;
 816                                 } else {
 817                                         if (data == null)
 818                                                 data = new DataObject ();
 819                                         SetDataWithFormats (drag_data.Data);
 820                                 }
 821                                 return true;
 822                         }
 823
 824                         foreach (IntPtr atom in SourceSupportedList (ref xevent)) {
 825                                 MimeHandler handler = FindHandler (atom);
 826                                 if (handler == null)
 827                                         continue;
 828                                 XplatUIX11.XConvertSelection (display, XdndSelection, handler.Type,
 829                                         handler.NonProtocol, toplevel, IntPtr.Zero /* CurrentTime */);
 830                                 converts_pending++;
 831                                 match = true;
 832                         }
 833                         return match;
 834                 }
 835
 836                 private void SetDataWithFormats (object value)
 837                 {
 838                         if (value is string) {
 839                                 data.SetData (DataFormats.Text, value);
 840                                 data.SetData (DataFormats.UnicodeText, value);
 841                         }
 842
 843                         data.SetData (value);
 844                 }
 845
 846                 private MimeHandler FindHandler (IntPtr atom)
 847                 {
 848                         if (atom == IntPtr.Zero)
 849                                 return null;
 850                         foreach (MimeHandler handler in MimeHandlers) {
 851                                 if (handler.Type == atom)
 852                                         return handler;
 853                         }
 854                         return null;
 855                 }
 856
 857                 private MimeHandler FindHandler (string name)
 858                 {
 859                         foreach (MimeHandler handler in MimeHandlers) {
 860                                 if (handler.Name == name)
 861                                         return handler;
 862                         }
 863                         return null;
 864                 }
 865
 866                 private void SendStatus (IntPtr source, DragDropEffects effect)
 867                 {
 868                         XEvent xevent = new XEvent ();
 869
 870                         xevent.AnyEvent.type = XEventName.ClientMessage;
 871                         xevent.AnyEvent.display = display;
 872                         xevent.ClientMessageEvent.window = source;
 873                         xevent.ClientMessageEvent.message_type = XdndStatus;
 874                         xevent.ClientMessageEvent.format = 32;
 875                         xevent.ClientMessageEvent.ptr1 = toplevel;
 876                         if (effect != DragDropEffects.None)
 877                                 xevent.ClientMessageEvent.ptr2 = (IntPtr) 1;
 878
 879                         xevent.ClientMessageEvent.ptr5 = ActionFromEffect (effect);
 880                         XplatUIX11.XSendEvent (display, source, false, IntPtr.Zero, ref xevent);
 881                 }
 882
 883                 private void SendEnter (IntPtr handle, IntPtr from, IntPtr [] supported)
 884                 {
 885                         XEvent xevent = new XEvent ();
 886
 887                         xevent.AnyEvent.type = XEventName.ClientMessage;
 888                         xevent.AnyEvent.display = display;
 889                         xevent.ClientMessageEvent.window = handle;
 890                         xevent.ClientMessageEvent.message_type = XdndEnter;
 891                         xevent.ClientMessageEvent.format = 32;
 892                         xevent.ClientMessageEvent.ptr1 = from;
 893
 894                         // (int) xevent.ClientMessageEvent.ptr2 & 0x1)
 895                         // int ptr2 = 0x1;
 896                         // xevent.ClientMessageEvent.ptr2 = (IntPtr) ptr2;
 897                         // (e)->xclient.data.l[1] = ((e)->xclient.data.l[1] & ~(0xFF << 24)) | ((v) << 24)
 898                         xevent.ClientMessageEvent.ptr2 = (IntPtr) ((long)XdndVersion [0] << 24);
 899
 900                         if (supported.Length > 0)
 901                                 xevent.ClientMessageEvent.ptr3 = supported [0];
 902                         if (supported.Length > 1)
 903                                 xevent.ClientMessageEvent.ptr4 = supported [1];
 904                         if (supported.Length > 2)
 905                                 xevent.ClientMessageEvent.ptr5 = supported [2];
 906
 907                         XplatUIX11.XSendEvent (display, handle, false, IntPtr.Zero, ref xevent);
 908                 }
 909
 910                 private void SendDrop (IntPtr handle, IntPtr from, IntPtr time)
 911                 {
 912                         XEvent xevent = new XEvent ();
 913
 914                         xevent.AnyEvent.type = XEventName.ClientMessage;
 915                         xevent.AnyEvent.display = display;
 916                         xevent.ClientMessageEvent.window = handle;
 917                         xevent.ClientMessageEvent.message_type = XdndDrop;
 918                         xevent.ClientMessageEvent.format = 32;
 919                         xevent.ClientMessageEvent.ptr1 = from;
 920                         xevent.ClientMessageEvent.ptr3 = time;
 921
 922                         XplatUIX11.XSendEvent (display, handle, false, IntPtr.Zero, ref xevent);
 923                 }
 924
 925                 private void SendPosition (IntPtr handle, IntPtr from, IntPtr action, int x, int y, IntPtr time)
 926                 {
 927                         XEvent xevent = new XEvent ();
 928
 929                         xevent.AnyEvent.type = XEventName.ClientMessage;
 930                         xevent.AnyEvent.display = display;
 931                         xevent.ClientMessageEvent.window = handle;
 932                         xevent.ClientMessageEvent.message_type = XdndPosition;
 933                         xevent.ClientMessageEvent.format = 32;
 934                         xevent.ClientMessageEvent.ptr1 = from;
 935                         xevent.ClientMessageEvent.ptr3 = (IntPtr) ((x << 16) | (y & 0xFFFF));
 936                         xevent.ClientMessageEvent.ptr4 = time;
 937                         xevent.ClientMessageEvent.ptr5 = action;
 938
 939                         XplatUIX11.XSendEvent (display, handle, false, IntPtr.Zero, ref xevent);
 940                 }
 941
 942                 private void SendLeave (IntPtr handle, IntPtr from)
 943                 {
 944                         XEvent xevent = new XEvent ();
 945
 946                         xevent.AnyEvent.type = XEventName.ClientMessage;
 947                         xevent.AnyEvent.display = display;
 948                         xevent.ClientMessageEvent.window = handle;
 949                         xevent.ClientMessageEvent.message_type = XdndLeave;
 950                         xevent.ClientMessageEvent.format = 32;
 951                         xevent.ClientMessageEvent.ptr1 = from;
 952
 953                         XplatUIX11.XSendEvent (display, handle, false, IntPtr.Zero, ref xevent);
 954                 }
 955
 956                 private void SendFinished ()
 957                 {
 958                         XEvent xevent = new XEvent ();
 959
 960                         xevent.AnyEvent.type = XEventName.ClientMessage;
 961                         xevent.AnyEvent.display = display;
 962                         xevent.ClientMessageEvent.window = source;
 963                         xevent.ClientMessageEvent.message_type = XdndFinished;
 964                         xevent.ClientMessageEvent.format = 32;
 965                         xevent.ClientMessageEvent.ptr1 = toplevel;
 966
 967                         XplatUIX11.XSendEvent (display, source, false, IntPtr.Zero, ref xevent);
 968                 }
 969
 970                 // There is a somewhat decent amount of overhead
 971                 // involved in setting up dnd so we do it lazily
 972                 // as a lot of applications do not even use it.
 973                 private void Init ()
 974                 {
 975                         XdndAware = XplatUIX11.XInternAtom (display, "XdndAware", false);
 976                         XdndEnter = XplatUIX11.XInternAtom (display, "XdndEnter", false);
 977                         XdndLeave = XplatUIX11.XInternAtom (display, "XdndLeave", false);
 978                         XdndPosition = XplatUIX11.XInternAtom (display, "XdndPosition", false);
 979                         XdndStatus = XplatUIX11.XInternAtom (display, "XdndStatus", false);
 980                         XdndDrop = XplatUIX11.XInternAtom (display, "XdndDrop", false);
 981                         XdndSelection = XplatUIX11.XInternAtom (display, "XdndSelection", false);
 982                         XdndFinished = XplatUIX11.XInternAtom (display, "XdndFinished", false);
 983                         XdndTypeList = XplatUIX11.XInternAtom (display, "XdndTypeList", false);
 984                         XdndActionCopy = XplatUIX11.XInternAtom (display, "XdndActionCopy", false);
 985                         XdndActionMove = XplatUIX11.XInternAtom (display, "XdndActionMove", false);
 986                         XdndActionLink = XplatUIX11.XInternAtom (display, "XdndActionLink", false);
 987                         XdndActionPrivate = XplatUIX11.XInternAtom (display, "XdndActionPrivate", false);
 988                         XdndActionList = XplatUIX11.XInternAtom (display, "XdndActionList", false);
 989                         XdndActionDescription = XplatUIX11.XInternAtom (display, "XdndActionDescription", false);
 990                         XdndActionAsk = XplatUIX11.XInternAtom (display, "XdndActionAsk", false);
 991
 992                         foreach (MimeHandler handler in MimeHandlers) {
 993                                 handler.Type = XplatUIX11.XInternAtom (display, handler.Name, false);
 994                                 handler.NonProtocol = XplatUIX11.XInternAtom (display,
 995                                                 String.Concat ("MWFNonP+", handler.Name), false);
 996                         }
 997
 998                 }
 999
1000                 private IntPtr [] SourceSupportedList (ref XEvent xevent)
1001                 {
1002                         IntPtr [] res;
1003
1004
1005                         if (((int) xevent.ClientMessageEvent.ptr2 & 0x1) == 0) {
1006                                 res = new IntPtr [3];
1007                                 res [0] = xevent.ClientMessageEvent.ptr3;
1008                                 res [1] = xevent.ClientMessageEvent.ptr4;
1009                                 res [2] = xevent.ClientMessageEvent.ptr5;
1010                         } else {
1011                                 IntPtr type;
1012                                 int format;
1013                                 IntPtr count;
1014                                 IntPtr remaining;
1015                                 IntPtr data = IntPtr.Zero;
1016
1017                                 XplatUIX11.XGetWindowProperty (display, source, XdndTypeList,
1018                                                 IntPtr.Zero, new IntPtr(32), false, (IntPtr) Atom.XA_ATOM,
1019                                                 out type, out format, out count,
1020                                                 out remaining, ref data);
1021
1022                                 res = new IntPtr [count.ToInt32()];
1023                                 for (int i = 0; i < count.ToInt32(); i++) {
1024                                         res [i] = (IntPtr) Marshal.ReadInt32 (data, i *
1025                                                         Marshal.SizeOf (typeof (int)));
1026                                 }
1027
1028                                 XplatUIX11.XFree (data);
1029                         }
1030
1031                         return res;
1032                 }
1033
1034                 private string GetText (ref XEvent xevent, bool unicode)
1035                 {
1036                         int nread = 0;
1037                         IntPtr nitems;
1038                         IntPtr bytes_after;
1039
1040                         StringBuilder builder = new StringBuilder ();
1041                         do {
1042                                 IntPtr actual_type;
1043                                 int actual_fmt;
1044                                 IntPtr data = IntPtr.Zero;
1045
1046                                 if (0 != XplatUIX11.XGetWindowProperty (display,
1047                                                     xevent.AnyEvent.window,
1048                                                     (IntPtr) xevent.SelectionEvent.property,
1049                                                     IntPtr.Zero, new IntPtr(0xffffff), false,
1050                                                     (IntPtr) Atom.AnyPropertyType, out actual_type,
1051                                                     out actual_fmt, out nitems, out bytes_after,
1052                                                     ref data)) {
1053                                         XplatUIX11.XFree (data);
1054                                         break;
1055                                 }
1056
1057                                 if (unicode)
1058                                         builder.Append (Marshal.PtrToStringUni (data));
1059                                 else
1060                                         builder.Append (Marshal.PtrToStringAnsi (data));
1061                                 nread += nitems.ToInt32();
1062
1063                                 XplatUIX11.XFree (data);
1064                         } while (bytes_after.ToInt32() > 0);
1065                         if (nread == 0)
1066                                 return null;
1067                         return builder.ToString ();
1068                 }
1069
1070                 private MemoryStream GetData (ref XEvent xevent)
1071                 {
1072                         int nread = 0;
1073                         IntPtr nitems;
1074                         IntPtr bytes_after;
1075
1076                         MemoryStream res = new MemoryStream ();
1077                         do {
1078                                 IntPtr actual_type;
1079                                 int actual_fmt;
1080                                 IntPtr data = IntPtr.Zero;
1081
1082                                 if (0 != XplatUIX11.XGetWindowProperty (display,
1083                                                     xevent.AnyEvent.window,
1084                                                     (IntPtr) xevent.SelectionEvent.property,
1085                                                     IntPtr.Zero, new IntPtr(0xffffff), false,
1086                                                     (IntPtr) Atom.AnyPropertyType, out actual_type,
1087                                                     out actual_fmt, out nitems, out bytes_after,
1088                                                     ref data)) {
1089                                         XplatUIX11.XFree (data);
1090                                         break;
1091                                 }
1092
1093                                 for (int i = 0; i < nitems.ToInt32(); i++)
1094                                         res.WriteByte (Marshal.ReadByte (data, i));
1095                                 nread += nitems.ToInt32();
1096
1097                                 XplatUIX11.XFree (data);
1098                         } while (bytes_after.ToInt32() > 0);
1099                         return res;
1100                 }
1101
1102                 private Control MwfWindow (IntPtr window)
1103                 {
1104                         Hwnd hwnd = Hwnd.ObjectFromHandle (window);
1105                         if (hwnd == null)
1106                                 return null;
1107
1108                         Control res = Control.FromHandle (hwnd.client_window);
1109                         return res;
1110                 }
1111
1112                 private bool IsWindowDndAware (IntPtr handle)
1113                 {
1114                         bool res = true;
1115                         // Check the version number, we need greater than 3
1116                         IntPtr actual;
1117                         int format;
1118                         IntPtr count;
1119                         IntPtr remaining;
1120                         IntPtr data = IntPtr.Zero;
1121
1122                         XplatUIX11.XGetWindowProperty (display, handle, XdndAware, IntPtr.Zero, new IntPtr(0x8000000), false,
1123                                         (IntPtr) Atom.XA_ATOM, out actual, out format,
1124                                         out count, out remaining, ref data);
1125
1126                         if (actual != (IntPtr) Atom.XA_ATOM || format != 32 ||
1127                                         count.ToInt32() == 0 || data == IntPtr.Zero) {
1128                                 if (data != IntPtr.Zero)
1129                                         XplatUIX11.XFree (data);
1130                                 return false;
1131                         }
1132
1133                         int version = Marshal.ReadInt32 (data, 0);
1134
1135                         if (version < 3) {
1136                                 Console.Error.WriteLine ("XDND Version too old (" + version + ").");
1137                                 XplatUIX11.XFree (data);
1138                                 return false;
1139                         }
1140
1141                         // First type is actually the XDND version
1142                         if (count.ToInt32() > 1) {
1143                                 res = false;
1144                                 for (int i = 1; i < count.ToInt32(); i++) {
1145                                         IntPtr type = (IntPtr) Marshal.ReadInt32 (data, i *
1146                                                         Marshal.SizeOf (typeof (int)));
1147                                         for (int j = 0; j < drag_data.SupportedTypes.Length; j++) {
1148                                                 if (drag_data.SupportedTypes [j] == type) {
1149                                                         res = true;
1150                                                         break;
1151                                                 }
1152                                         }
1153                                 }
1154                         }
1155
1156                         XplatUIX11.XFree (data);
1157                         return res;
1158                 }
1159
1160                 private IntPtr [] DetermineSupportedTypes (object data)
1161                 {
1162                         ArrayList res = new ArrayList ();
1163
1164                         if (data is string) {
1165                                 MimeHandler handler = FindHandler ("text/plain");
1166                                 if (handler != null)
1167                                         res.Add (handler.Type);
1168                         }/* else if (data is Bitmap)
1169                                 res.Add (data);
1170
1171                          */
1172
1173                         if (data is IDataObject) {
1174
1175
1176                         }
1177
1178                         if (data is ISerializable) {
1179                                 MimeHandler handler = FindHandler ("application/x-mono-serialized-object");
1180                                 if (handler != null)
1181                                         res.Add (handler.Type);
1182                         }
1183
1184                         return (IntPtr []) res.ToArray (typeof (IntPtr));
1185                 }
1186         }
1187 }